We study the dispersion problem for k mobile agents on an n-node anonymous, memory-less graph with maximum degree Δ. Agents must autonomously relocate so that no two agents occupy the same node. While an optimal O(k)-time, O(log(k + Δ))-memory algorithm is known under synchronous settings, the best known asynchronous algorithm requires O(k log min {k, Δ}) time due to the difficulty of distinguishing unvisited nodes from nodes temporarily vacated by agents. We close this gap by presenting the first fully asynchronous algorithm achieving asymptotically optimal O(k) time and O(log(k + Δ)) memory. Our main technical contribution is the Port-1 Tree (P1Tree), a novel structural property of a port-labeled graph. By forcing the DFS traversal to prioritize edges locally labeled with port 1, P1Tree allows agents to verify the status of neighboring nodes in O(1) asynchronous epochs without relying on timing assumptions or oscillations used in synchronous settings. We show that this approach yields optimal bounds for both rooted and general initial configurations.

Butterflies, or 4-cycles in bipartite graphs, are crucial for identifying cohesive structures and dense subgraphs. We propose distributed agent-based algorithms for Butterfly Counting in a bipartite graph G((A, B), E), where the agents first determine their partition for which they construct a spanning tree and elect a leader in O(n log λ) rounds with O(log λ) bits of memory per agent. A novel meeting mechanism between adjacent agents enhances efficiency and removes the need for prior graph knowledge, requiring only the highest agent ID (λ) among n agents. Building on these foundations, agents count butterflies per node in O(Δ) rounds and compute the total butterfly count of G in O(Δ + min{|A|, |B|}) rounds.

The dispersion problem has received much attention recently in the distributed computing literature. In this problem, k ≤ 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 log2 k) 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 the results were obtained through novel techniques to quickly find empty nodes to settle agents, which may be of independent interest.

We study the dispersion problem in anonymous port-labeled graphs: k ≤ n mobile agents, each with a unique ID and initially located arbitrarily on the nodes of an n-node graph with maximum degree Δ, must autonomously relocate so that no node hosts more than one agent. Dispersion serves as a fundamental task in the distributed computing of mobile agents, and its complexity stems from key challenges in local coordination under anonymity and limited memory. The goal is to minimize both the time to achieve dispersion and the memory required per agent. It is known that any algorithm requires Ω(k) time in the worst case, and Ω(log k) bits of memory per agent. A recent result [Kshemkalyani et al., 2025] gives an optimal O(k)-time algorithm in the synchronous setting and an O(k log k)-time algorithm in the asynchronous setting, both using O(log(k+Δ)) bits. We close the complexity gap in the asynchronous setting by presenting the first dispersion algorithm that runs in optimal O(k) time using O(log(k+Δ)) bits of memory per agent. Our solution relies on a novel technique for constructing a port-one tree in anonymous graphs, which may be of independent interest.

Over the years, much research involving mobile computational entities has been performed. From modeling actual microscopic (and smaller) robots, to modeling software processes on a network, many important problems have been studied in this context. Gathering is one such fundamental problem in this area. The problem of gathering k robots, initially arbitrarily placed on the nodes of an n-node graph, asks that these robots coordinate and communicate in a local manner, as opposed to global, to move around the graph, find each other, and settle down on a single node as fast as possible. A more difficult problem to solve is gathering with detection, where once the robots gather, they must subsequently realize that gathering has occurred and then terminate.In this paper, we propose a deterministic approach to solve gathering with detection for any arbitrary connected graph that is faster than existing deterministic solutions for even just gathering (without the requirement of detection) for arbitrary graphs. In contrast to earlier work on gathering, it leverages the fact that there are more robots present in the system to achieve gathering with detection faster than those previous papers that focused on just gathering. The state of the art solution for deterministic gathering [Ta-Shma and Zwick, TALG, 2014] takes $\tilde O\left({{n^5}\log \ell }\right)$ rounds, where is the smallest label among robots and $\tilde O$ hides a polylog factor. We design a deterministic algorithm for gathering with detection with the following trade-offs depending on how many robots are present: (i) when k ≥ ⌊n/2⌋ + 1, the algorithm takes O(n3) rounds, (ii) when k ≥ ⌊n/3⌋ + 1, the algorithm takes O(n4log n) rounds, and (iii) otherwise, the algorithm takes $\tilde O\left({{n^5}}\right)$ rounds. The algorithm is not required to know k, but only n.

This article investigates the message complexity of two fundamental problems, leader election and agreement in the crash-fault synchronous and fully-connected distributed network. We present randomized (Monte Carlo) algorithms for both the problems and also show non-trivial lower bounds on the message complexity. Our algorithms achieve sublinear message complexity in the so-called implicit version of the two problems when tolerating more than a constant fraction of the faulty nodes. In comparison to the state-of-art, our results improved and extended the works of [Gilbert-Kowalski, SODA’10] (which studied only the agreement problem) in several directions. Specifically, our algorithms tolerate any number of faulty nodes up to$(n -\operatorname{polylog}n)$. The message complexity (and also the time complexity) of our algorithms is optimal (up to a$\operatorname{polylog}n$factor). Further, our algorithm works in anonymous networks, where nodes do not know each other. To the best of our knowledge, these are the first sub-linear results for both the leader election and the agreement problem in the crash-fault distributed networks.

This paper considers the problem of Byzantine dispersion and extends previous work along several parameters. The problem of Byzantine dispersion asks: given n robots, up tofof which are Byzantine, initially placed arbitrarily on annnode anonymous graph, design a terminating algorithm to be run by the robots such that they eventually reach a configuration where each node has at most one non-Byzantine robot on it. Previous work solved this problem for rings and tolerated up ton- 1 Byzantine robots. In this paper, we investigate the problem on more general graphs. We first develop an algorithm that tolerates up ton- 1 Byzantine robots and works for a more general class of graphs. We then develop an algorithm that works for any graph but tolerates a lesser number of Byzantine robots. We subsequently turn our focus to the strength of the Byzantine robots. Previous work considers only “weak” Byzantine robots that cannot fake their IDs. We develop an algorithm that solves the problem when Byzantine robots are not weak and can fake IDs. Finally, we study the situation where the number of the robots is not n but somek. We show that in such a scenario, the number of Byzantine robots that can be tolerated is severely restricted. Specifically, we show that it is impossible to deterministically solve Byzantine dispersion when ⌈k/n⌉ > ⌈(k-f)/n⌉.

Flooding is a fundamental concept in distributed computing. In flooding, typically, a node forwards a message to its neighbors for the first time when it receives a message. Later if the node receives the same message again, it simply ignores the message and does not forward it. The nodes store a “message record” to ensure that the same message is not forwarded again. Hussak and Trehan introduced amnesiac flooding where nodes do not require to keep the message record. They established a surprising result that the amnesic flooding of a single (k = 1) message starting from some source node always terminates in bipartite graphs in e rounds and in non-bipartite graphs in [e + 1, e + D + 1] rounds, where e is the eccentricity of the source node and D is the diameter of the graph. Recently, Hussak and Trehan introduced dynamic amnesiac flooding initiated in possibly multiple rounds with possibly multiple (k > 1) messages from possibly multiple source nodes. They showed that the partial-send case where a node only sends a message to neighbours from which it did not receive any message in the previous round and the ranked full-send case where a node sends some highest ranked message to all neighbors from which it did not receive that message in the previous round, both terminate. However, they showed that the unranked full-send case, where a node sends some random message (not necessarily the highest ranked message) to all the neighbors from which it did not receive that message in the previous round, does not terminate. In this paper, we show that the unranked full-send case also terminates, provided that diameter D is known to graph nodes. We further show that the termination time is D · (2k − 1) rounds in bipartite graphs and (2D + 1) · (2k − 1) rounds in non-bipartite graphs.

We will present the fundamentals of Byzantine agreement and leader election problems from a modern perspective. Byzantine fault tolerant protocols are at the heart of secure and robust protocols that can tolerate the presence of malicious nodes in a distributed system, such as a Peer-to-Peer (P2P) network, which allows a large number of peers to enter the network with little or no admission control. Such malicious peers acting alone or in collaboration can cause disruption of service in P2P systems.

This paper investigates on the message complexity of the two fundamental problems, namely, leader election and agreement in the crash-fault synchronous and fully-connected distributed network. We present randomized algorithms for both the problems and also develop non-trivial lower bounds on the message complexity. In the so-called implicit version of the two problems, our algorithms achieve sublinear message complexity while tolerating more than a constant fraction of faulty nodes. The algorithms work in anonymous networks, where nodes do not know each other. Specifically, our main results are: (1)A randomized leader election algorithm which elects a leader with high probability in a complete network with n nodes, in which at least ⌉ n⌈ nodes are non-faulty and the remaining can be faulty, where ≥ (log2 n)/n. The time complexity of the algorithm is O (log nα) rounds and message complexity is O((n0.5 log2.5 n)/2.5) with high probability (i.e., with probability ≥ 1-1/n). A non-trivial lower bound of Ω(n0.5 / α1.5) messages for any leader election algorithm that tolerates at most (1-α)-fraction faulty nodes and succeeds with high probability. (2)A randomized algorithm, tolerating at most ⌊(1-α)n⌋ faulty nodes, solves agreement in O (log n/α) rounds and with high probability uses only O((n0.5 log1.5n)/α1.5) messages. A matching lower bound (up to a polylog n factor) of Ω (n0.5 /α1.5) messages for any agreement algorithm that tolerates at most (1-α)-fraction faulty nodes and succeeds with high probability. A full version of the paper is available at [17].

Gathering is one of the fundamental and well-studied problems in the context of autonomous and oblivious mobile robots. The gathering problem requires the robots, initially distributed on the Euclidean plane, to coordinate their movements to gather at a single point, not known to them a priori. We study a constrained version of the gathering problem, called the min-max gathering, which requires the robots to achieve gathering by minimizing the maximum distance traversed by any robot. A solution to the problem provides energy efficiency for the robots to achieve the goal. We present a deterministic algorithm for the min-max gathering problem in the Euclidean plane under two of the strongest adversarial models, namely, the asynchronous scheduler and the non-rigid movements of the robots. Moreover, we establish a minimal set of necessary and sufficient conditions to solve the problem.

The dispersion problem on graphs asks k ≤n robots placed initially arbitrarily on the nodes of an n-node anonymous graph to reposition autonomously to reach a configuration in which each robot is on a distinct node of the graph. This problem is of significant interest due to its relationship to other fundamental robot coordination problems, such as exploration, scattering, load balancing, and relocation of self-driving electric cars (robots) to recharge stations (nodes). The objective is to simultaneously minimize (or provide trade-off between) two fundamental performance metrics: (i) time to achieve dispersion and (ii) memory requirement at each robot. This problem has been relatively well-studied on static graphs. In this paper, we investigate it for the very first time on dynamic graphs. Particularly, we show that, even with unlimited memory at each robot and 1-neighborhood knowledge, dispersion is impossible to solve on dynamic graphs in the local communication model, where a robot can only communicate with other robots that are present at the same node. We then show that, even with unlimited memory at each robot but without 1-neighborhood knowledge, dispersion is impossible to solve in the global communication model, where a robot can communicate with any other robot in the graph possibly at different nodes. We then consider the global communication model with 1-neighborhood knowledge and establish a tight bound of Θ(k) on the time complexity of solving dispersion in any n-node arbitrary anonymous dynamic graph with Θ(log k) bits memory at each robot. Finally, we extend the fault-free algorithm to solve dispersion for (crash) faulty robots under the global model with 1-neighborhood knowledge.

The K-nearest neighbors is a basic problem in machine learning with numerous applications. In this problem, given a (training) set of n data points with labels and a query point q, we want to assign a label to q based on the labels of the K-nearest points to the query. We study this problem in the k-machine model, a model for distributed large-scale data. In this model, we assume that the n points are distributed (in a balanced fashion) among the k machines and the goal is to compute an answer given a query point to a machine using a small number of communication rounds.

Motivated, in part, by the rise of permissionless systems such as Bitcoin where arbitrary nodes (whose identities are not known apriori) can join and leave at will, we extend established research in scalable Byzantine agreement to a more practical model where each node (initially) does not know the identity of other nodes. A node can send to new destinations only by sending to random (or arbitrary) nodes, or responding (if it chooses) to messages received from those destinations. We assume a synchronous and fully-connected network, with a full-information, but static Byzantine adversary. A general drawback of existing Byzantine protocols is that the communication cost incurred by the honest nodes may not be proportional to those incurred by the Byzantine nodes; in fact, they can be significantly higher. Our goal is to design Byzantine protocols for fundamental problems which are {\em resource competitive}, i.e., the number of bits sent by honest nodes is not much more than those sent by Byzantine nodes. We describe a randomized scalable algorithm to solve Byzantine agreement, leader election, and committee election in this model. Our algorithm sends an expected $O((T+n)\log n)$ bits and has latency $O(polylog(n))$, where $n$ is the number of nodes, and $T$ is the minimum of $n^2$ and the number of bits sent by adversarially controlled nodes. The algorithm is resilient to $(1/4-ε)n$ Byzantine nodes for any fixed $ε> 0$, and succeeds with high probability. Our work can be considered as a first application of resource-competitive analysis to fundamental Byzantine problems. To complement our algorithm we also show lower bounds for resource-competitive Byzantine agreement. We prove that, in general, one cannot hope to design Byzantine protocols that have communication cost that is significantly smaller than the cost of the Byzantine adversary.

We study the time complexity of single and multi token broadcast in adversarial dynamic radio networks. Initially, k tokens (which are k pieces of information) are distributed among the n nodes of a network and all the tokens need to be disseminated to all the nodes in the network. We first consider the single-token broadcast problem (i.e., the case k=1). By presenting upper and lower bounds, we show that the time complexity of single-token broadcast depends on the amount of stability and connectivity of the dynamic network topology and on the adaptiveness of the adversary providing the dynamic topology. Then, we give two generic algorithms which allow to transform generalized forms of single-token broadcast algorithms into multi-token broadcast (k-token broadcast) algorithms. Based on these generic algorithms, we obtain k-token broadcast algorithms for a number of different dynamic network settings. For one of the modeling assumptions, our algorithm is complemented by a lower bound which shows that the upper bound is close to optimal.

This paper investigates the message complexity of distributed information spreading in adversarial dynamic networks. While distributed computations in dynamic networks have been studied intensively over the last years, almost all of the existing work solely focuses on the time complexity of distributed algorithms. In information spreading, the goal is to spread k tokens of information to every node on an n-node network. We consider the amortized (average) message complexity of spreading a token, assuming that the number of tokens is large. In a static network, this basic problem can be solved using (asymptotically optimal) O(n) amortized messages per token. Our focus is on token-forwarding algorithms, which do not manipulate tokens in any way other than storing, copying, and forwarding them. We present two sets of results depending on how nodes send messages to their neighbors: 1. Local broadcast: We show a tight lower bound of Ω̃(n2) on the number of amortized local broadcasts, which is matched by the naive flooding algorithm. The lower bound holds for randomized algorithms against a strongly adaptive adversary. 2. Unicast: We study the message complexity as a function of the number of dynamic changes in the network. To facilitate this, we introduce adversary-competitive message complexity as a natural complexity measure for analyzing dynamic networks: The adversary pays a unit cost for every topological change and the message cost of an algorithm is determined as the actual number of messages sent minus the total cost of the adversary. Under this model, we give a deterministic algorithm that obtains an optimal amortized message complexity of O(n) if the number of tokens k is sufficiently large. We also present a randomized algorithm that achieves subquadratic amortized message complexity for much smaller k under an oblivious adversary.

Designing effective algorithms for community detection is an important and challenging problem in large-scale graphs, studied extensively in the literature. Various solutions have been proposed, but many of them are centralized with expensive procedures (requiring full knowledge of the input graph) and have a large running time. In this paper, we present a distributed algorithm for community detection in the stochastic block model (also called planted partition model), a widely-studied and canonical random graph model for community detection and clustering. Our algorithm called CDRW(Community Detection by Random Walks) is based on random walks, and is localized and lightweight, and easy to implement. A novel feature of the algorithm is that it uses the concept of local mixing time to identify the community around a given node. We present a rigorous theoretical analysis that shows that the algorithm can accurately identify the communities in the stochastic block model and characterize the model parameters where the algorithm works. We also present experimental results that validate our theoretical analysis. We also analyze the performance of our distributed algorithm under the CONGEST distributed model as well as the k-machine model, a model for large-scale distributed computations, and show that it can be efficiently implemented.

The mixing time of a graph is an important metric, which is not only useful in analyzing connectivity and expansion properties of the network, but also serves as a key parameter in designing efficient algorithms. We introduce a new notion of mixing of a random walk on a (undirected) graph, called local mixing. Informally, the local mixing with respect to a given node s, is the mixing of a random walk probability distribution restricted to a large enough subset of nodes - say, a subset of size at least n/β for a given parameter β - containing s. The time to mix over such a subset by a random walk starting from a source node s is called the local mixing time with respect to s. The local mixing time captures the local connectivity and expansion properties around a given source node and is a useful parameter that determines the running time of algorithms for partial information spreading, gossip etc. Our first contribution is formally defining the notion of local mixing time in an undirected graph. We then present an efficient distributed algorithm which computes a constant factor approximation the local mixing time with respect to a source node s in Õ(Ts) rounds1where Tsis the local mixing time w.r.t s in an n-node regular graph. This bound holds when Tsis significantly smaller than the conductance of the local mixing set (i.e., the set where the walk mixes locally); this is typically the interesting case where the local mixing time is significantly smaller than the mixing time (with respect to s). We also present a distributed algorithm that computes the exact local mixing time in Õ(TsD) rounds, where D = min{Ts, D} and D is the diameter of the graph (this bound holds unconditionally without any assumptions on Ts). Our algorithms work in the CONGEST model of distributed computing. Since the local mixing time can be significantly smaller than the mixing time (or even the diameter) in many graphs, it serves as a tighter measure of distributed complexity in certain algorithmic applications. In particular, we show that local mixing time tightly characterizes the complexity of partial information spreading which in turn is useful in solving other problems such as the maximum coverage problem, full information spreading, leader election etc.

The algorithmic small-world phenomenon, empirically established by Milgram's letter forwarding experiments from the 60s, was theoretically explained by Kleinberg in 2000. However, from today's perspective his model has several severe shortcomings that limit the applicability to real-world networks. In order to give a more convincing explanation of the algorithmic small-world phenomenon, we study decentralized greedy routing in a more flexible random graph model (geometric inhomogeneous random graphs) which overcomes all previous shortcomings. Apart from exhibiting good properties in theory, it has also been extensively experimentally validated that this model reasonably captures real-world networks. In this model, the greedy routing protocol is purely distributed as each vertex only needs to know information about its direct neighbors. We prove that it succeeds with constant probability, and in case of success almost surely finds an almost shortest path of length Θ(log log n), where our bound is tight including the leading constant. Moreover, we study natural local patching methods which augment greedy routing by backtracking and which do not require any global knowledge. We show that such methods can ensure success probability 1 in an asymptotically tight number of steps.

We study the problem of computing a sparse cut in an undirected network graph G=(V,E). We measure the sparsity of a cut (S,V\S) by its conductance phi(S), i.e., by the ratio of the number of edges crossing the cut and the sum of the degrees on the smaller of the two sides. We present an efficient distributed algorithm to compute a cut of low conductance. Specifically, given two parameters b and phi, if there exists a cut of balance at least b and conductance at most phi, our algorithm outputs a cut of balance at least b/2 and conductance at most ~O(sqrt{phi}), where ~O(.) hides polylogarithmic factors in the number of nodes n. Our distributed algorithm works in the \congest model, i.e., it only requires to send messages of size at most O(log(n)) bits. The time complexity of the algorithm is ~O(D + 1/b*phi), where D is the diameter of G. This is a significant improvement over a result by Das Sarma et al. [ICDCN 2015], where it is shown that a cut of the same quality can be computed in time ~O(n + 1/b*phi). The improved running time is in particular achieved by devising and applying an efficient distributed algorithm for the all-prefix-sums problem in a distributed search tree. This algorithm, which is based on the classic parallel all-prefix-sums algorithm, might be of independent interest.

We study robust and efficient distributed algorithms for searching, storing, and maintaining data in dynamic Peer-to-Peer (P2P) networks. P2P networks are highly dynamic networks that experience heavy node churn (i.e., nodes join and leave the network continuously over time). Our goal is to guarantee, despite high node churn rate, that a large number of nodes in the network can store, retrieve, and maintain a large number of data items. Our main contributions are fast randomized distributed algorithms that guarantee the above with high probability even under high adversarial churn. In particular, we present the following main results:

Performing random walks in networks is a fundamental primitive that has found numerous applications in communication networks such as token management, load balancing, network topology discovery and construction, search, and peer-to-peer membership management. While several such algorithms are ubiquitous, and use numerous random walk samples, the walks themselves have always been performed naively. In this paper, we focus on the problem of performing random walk sampling efficiently in a distributed network. Given bandwidth constraints, the goal is to minimize the number of rounds and messages required to obtain several random walk samples in a continuous online fashion. We present the first round and message optimal distributed algorithms that present a significant improvement on all previous approaches. The theoretical analysis and comprehensive experimental evaluation of our algorithms show that they perform very well in different types of networks of differing topologies. In particular, our results show how several random walks can be performed continuously (when source nodes are provided only at runtime, i.e., online), such that each walk of length ℓ can be performed exactly in just Õ(√ℓD) rounds (where D is the diameter of the network), and O(ℓ) messages. This significantly improves upon both, the naive technique that requires O(ℓ) rounds and O(ℓ) messages, and the sophisticated algorithm of [13] that has the same round complexity as this paper but requires Ω(m√ℓ) messages (where m is the number of edges in the network). Our theoretical results are corroborated through extensive experiments on various topological data sets. Our algorithms are fully decentralized, lightweight, and easily implementable, and can serve as building blocks in the design of topologically-aware networks.