Early-Stabilizing Counting

2026-05-18

AI Summary

This work addresses the problem of self-stabilizing synchronous counting in a synchronous system with up to $t$ Byzantine faults, where all non-faulty nodes must rapidly agree on a common round counter following the cessation of transient faults. Inspired by early stopping in consensus protocols, the paper introduces, for the first time, an “early stabilization” mechanism that ensures the stabilization time depends only on the actual number of faults $f \leq t$. Through a modular design that integrates self-stabilization with fault-adaptive strategies and leverages a lightweight consensus reduction, the proposed algorithm stabilizes in $O(f+1)$ rounds, uses messages of size $O(\log^2 n + \log C)$, and achieves an amortized bit complexity of $O(n(f \log C + \log^2 n))$, which is asymptotically optimal.

Abstract

Synchronous Counting is the task of reaching agreement on a common round counter in a synchronous system of $n$ nodes with up to $t$ Byzantine faults in a self-stabilizing manner. That is, after transient faults may have arbitrarily corrupted the system state and ceased, the at least $n-t$ non-faulty nodes need to (re-)establish that (i) their local outputs are identical and (ii) increase by $1$ modulo $C$ in each round. An overhead-free reduction from consensus shows that all known lower bounds and impossibilities for consensus carry over to the counting problem. In the other direction, prior work has established that a consensus algorithm $\mathcal{A}$ can be turned into a counting algorithm at small overhead relative to the running time and bit complexity of $\mathcal{A}$, without losing resilience. Taking inspiration from early-stopping consensus protocols, in this work we introduce the concept of early stabilization. That is, if there are $0\le f\le t$ (persistent) faults in an execution, the algorithm should stabilize in a number of rounds that depends on $f$ only. Likewise, we seek to achieve an amortized bit complexity that is adaptive in the number of actual faults $f$. By developing a number of modular building blocks suitable to these goals, we develop a $C$-counting algorithm that stabilizes within asymptotically optimal $O(f+1)$ rounds, has message size $O(\log^2 n + \log C)$, and has amortized bit complexity $O(n(f\log C +\log^2 n))$.

Problem

• Synchronous Counting
• Byzantine faults
• Self-stabilization
• Early stabilization
• Fault tolerance

Innovation

• early-stabilizing
• synchronous counting
• Byzantine faults
• adaptive complexity
• self-stabilization