Universal Finite-State and Self-Stabilizing Computation in Anonymous Dynamic Networks

2024-09-01

International Conference on Principles of Distributed Systems

AI Summary

This paper addresses distributed function computation in anonymous dynamic networks without global knowledge (e.g., network size $n$), requiring algorithms to be self-stabilizing, finite-state, and resilient to memory corruption—without relying on unbounded memory. To handle frequent link changes and arbitrary initial states, we propose the first general-purpose algorithm simultaneously satisfying both finite-state and self-stabilizing paradigms. Our approach innovatively adapts the history-tree mechanism to enable incremental synchronization and reconstruction of corrupted states; introduces a dynamic connectivity abstraction (the “always-connected” assumption); and models protocols via finite-state machines. We formally prove that the self-stabilizing variant converges within $max{4n-2h, 2h}$ rounds, while the finite-state variant converges within $3n^2$ rounds, both using constant memory. The solution supports computing arbitrary frequency-class functions and guarantees eventual consistent and correct output.

Technology Category

• Search and Optimization: Distributed Search
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization
• Reasoning under Uncertainty: Stochastic Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Economics, Online Markets and Human Computation: Incentives in network design for Web infrastructures and ecosystems
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments

Abstract

A network is said to be"anonymous"if its agents are indistinguishable from each other; it is"dynamic"if its communication links may appear or disappear unpredictably over time. Assuming that an anonymous dynamic network is always connected and each of its $n$ agents is initially given an input, it takes $2n$ communication rounds for the agents to compute an arbitrary (frequency-based) function of such inputs (Di Luna-Viglietta, DISC 2023). It is known that, without making additional assumptions on the network and without knowing the number of agents $n$, it is impossible to compute most functions and explicitly terminate. In fact, current state-of-the-art algorithms only achieve stabilization, i.e., allow each agent to return an output after every communication round; outputs can be changed, and are guaranteed to be all correct after $2n$ rounds. Such algorithms rely on the incremental construction of a data structure called"history tree", which is augmented at every round. Thus, they end up consuming an unlimited amount of memory, and are also prone to errors in case of memory loss or corruption. In this paper, we provide a general self-stabilizing algorithm for anonymous dynamic networks that stabilizes in $max{4n-2h, 2h}$ rounds (where $h$ measures the amount of corrupted data initially present in the memory of each agent), as well as a general finite-state algorithm that stabilizes in $3n^2$ rounds. Our work improves upon previously known methods that only apply to static networks (Boldi-Vigna, Dist. Comp. 2002). In addition, we develop new fundamental techniques and operations involving history trees, which are of independent interest.

Problem

• Computing functions in anonymous dynamic networks with limited memory
• Achieving self-stabilization despite agent memory corruption
• Enabling finite-state computation without knowing network size

Innovation

• Self-stabilizing algorithm for anonymous dynamic networks
• Finite-state computation with bounded memory consumption
• History tree techniques enabling fault-tolerant distributed computation