We introduce GCAS, a natural generalization of the well-known compare-and-swap (CAS) object. Intuitively, GCAS just replaces the fixed equality test of CAS with a parametrized comparator chosen from {<, =, >}. To showcase the utility of GCAS, we present two space-efficient wait-free universal constructions for systems where the number of participating processes is unknown and may be infinite (the infinite-arrival model). The first has space-complexity linear in the number of processes that have participated so far, while the second has space-complexity linear in the point contention but assumes bounded concurrency. To the best of our knowledge, these are the first wait-free universal constructions that achieve this space complexity in the infinite-arrival model. To achieve space complexity linear in the point contention, our second universal construction uses a novel memory recycling scheme that works in the infinite-arrival model with bounded concurrency. The ideas behind this recycling scheme could be of more general use.
Population protocols are a model of distributed computing where $n$ agents, each a simple finite-state machine, interact in pairs to solve a common task against a (adversarial) interaction scheduler. This model was intensively studied in recent years; in particular, the problem of relative majority received much attention: Each agent starts with an input opinion (or color) out of $k$ possibilities, and the goal is for each agent to eventually output the color with the largest support in the population. Before our work, the state complexity (the minimum number of states required per agent) was only known to be between $Ω(k^2)$ and $O(k^{7})$. Our main contribution is a population protocol that solves the relative majority problem with $k^3$ states. We achieve this result with a new protocol called CIRCLES. While prior approaches in the literature relied on duels of agents to find the majority color -- an approach that proved effective for the case with two colors -- CIRCLES partitions the agents into circular linked lists of decreasing sizes, with the property that no two agents with the same initial color lie in the same circle. We show that CIRCLES always correctly computes the desired structure against the most adversarial of schedulers (weakly fair). We then show that a trivial extension of CIRCLES solves the relative majority problem. We extend our protocol to handle various tie-breaking mechanisms or to support the case where the agents do not share a prior ordering of the colors. Finally, we show that a modification of CIRCLES solves the ranking problem with $2 \cdot k^4$ states, where each agent must output the rank of its initial color in the population.
One of the central models in distributed computing is Linial's LOCAL model [SIAM J. Comp. 1992]. Over time, researchers have studied distributed graph problems in the LOCAL model under slightly different assumptions, such as whether nodes know the exact network size n, only a polynomial upper bound on n, or nothing at all. We ask whether these differences are merely technical or fundamentally affect the theory of Locally Checkable Labelings (LCLs), one of the most studied problem classes. LCLs are graph problems whose valid solutions can be characterized by a finite set of allowed constant-radius neighborhoods. Since their introduction by Naor and Stockmeyer [FOCS 1995], they have become central in distributed computing, and the last decade has seen major progress in understanding their complexity. For example, Chang, Kopelowitz, and Pettie [FOCS 2016] showed that the randomized complexity of any LCL on n-node graphs is at least its deterministic complexity on √(log n)-node graphs. Later, Chang and Pettie [FOCS 2017] showed that any randomized n^o(1)-round algorithm for LCLs on bounded-degree trees can be turned into a deterministic O(log n)-round algorithm. Then, Balliu et al. [STOC 2018] showed that such automatic speedups are impossible for general bounded-degree graphs. However, these results fundamentally rely on nodes knowing n. How much does this assumption affect the theory of LCLs? Our work shows that if nodes are oblivious to n, or know only a polynomial upper bound on it, then even on trees, the theory of LCLs changes significantly. While the fundamental classification of problems remains the same, we show the landscape becomes much more complex: for example, for LCLs, randomness helps in more cases; some problems have very unnatural complexities; and some have a lower bound that depends on which definition of Ω we use!
This paper advances the state of the art in girth approximation within the CONGEST model. Manoharan and Ramachandran [PODC '24] provided the first significant improvement in girth approximation in over a decade. We build on this momentum and make progress on all fronts: we provide a unified family of algorithms yielding girth approximation-round tradeoffs for undirected networks; we obtain improved bounds for directed networks; and we establish better lower bounds for directed and undirected weighted networks. Together, these results substantially narrow the remaining complexity gaps across all settings. Specifically, for networks with n nodes and hop-diameter D, we show that one can compute, with high probability: (1) An f-approximation for unweighted undirected girth in Õ(n^1/f+D) rounds, for every constant integer f>2, (2) A (2k-1+o(1))-approximation for weighted undirected girth in Õ(n^(k+1)/(2k+1)+D) rounds, for every constant integer k>1, and (3) A 2-approximation for directed unweighted girth, and a (2+ε)-approximation for directed weighted girth, both in Õ(n^2/3+D) rounds. We also prove new lower bounds for directed networks and for undirected weighted networks: for every integer k > 2 and ε>0, assuming the Erdős-Simonovits' even cycle conjecture (and unconditionally for k∈{3,4,6}), any (k-ε)-approximation for the girth requires (n^k/(2k-1)) rounds, even when D = O(log n).
The Dolev-Reischuk lower bound establishes that any deterministic Byzantine Agreement (BA) protocol for n processors tolerating f faults requires Ω(f^2+n) messages. But what exactly does this quadratic cost pay for? Even the minimal requirement that every correct processor receive at least one message already necessitates Ω(f^2 + n) messages. This raises a fundamental question: is the Dolev-Reischuk bound about the difficulty of reaching univalency – the point at which the protocol's outcome is determined – or merely about disseminating the outcome to all processors afterward? We resolve this question by showing that reaching univalency does not require quadratic communication. Specifically, we introduce ε-BA, a relaxation allowing an ε-fraction of correct processors to output incorrectly, and prove it can be solved deterministically with O(n log n) communication complexity when f < n(1/3 - ε). Crucially, any ε-BA protocol can serve as the first phase of a full BA protocol: after ε-BA, a single all-to-all exchange and majority vote completes BA. Since the outcome is already determined after ε-BA, this demonstrates that the quadratic cost in Dolev-Reischuk stems entirely from dissemination, rather than from reaching univalency. We also define Extractable BA for authenticated settings, capturing when processors collectively hold enough signed messages to determine the agreed value, and show it can be solved with communication complexity O(f log f).
Very recently, Khoury and Schild [FOCS 2025] showed that any randomized LOCAL algorithm that solves maximal matching requires Ω(min{log Δ, log_Δn}) rounds, where n is the number of nodes in the graph and Δ is the maximum degree. This result is shown through a new technique, called round elimination via self-reduction. The lower bound proof is beautiful and presents very nice ideas. However, it spans more than 25 pages of technical details, and hence it is hard to digest and generalize to other problems. Historically, the simplification of proofs and techniques has marked an important turning point in our understanding of the complexity of graph problems. Our paper makes a step forward towards this direction, and provides the following contributions. 1. We present a short and simplified version of the round elimination via self-reduction technique. The simplification of this technique enables us to obtain the following two hardness results. 2. We show that any randomized LOCAL algorithm that solves the maximal b-matching problem requires Ω(min{log_1+bΔ, log_Δn}) and Ω(√(log_1+b n)) rounds. We recall that the b-matching problem is a generalization of the matching problem where each vertex can have up to b incident edges in the matching. As a corollary, for b=1, we obtain a short proof for the maximal matching lower bound shown by Khoury and Schild. 3. Finally, we show that any randomized LOCAL algorithm that properly colors the edges of a graph with Δ+ k colors requires Ω(min{log Δ, log_Δn}) and Ω(√(log n)) rounds, for any k≤ Δ^1-ε and any constant ε > 0.
In this work, we present a fast distributed algorithm for local potential problems: these are graph problems where the task is to find a locally optimal solution where no node can unilaterally improve the utility in its local neighborhood by changing its own label. A simple example of such a problem is the task of finding a locally optimal cut, i.e., a cut where for each node at least half of its incident edges are cut edges. The distributed round complexity of the locally optimal cut problem has been wide open; the problem is known to require Ω(log n) rounds in the deterministic LOCAL model and Ω(loglog n) rounds in the randomized LOCAL model, but the only known upper bound is the trivial brute-force solution of O(n) rounds. Locally optimal cut in constant-degree graphs is perhaps the simplest example of a locally checkable labeling problem for which there is still such a large gap between current upper and lower bounds. We show that in constant-degree graphs, all local potential problems, including locally optimal cut, can be solved in log^O(1) n rounds, both in the deterministic and randomized LOCAL models. In particular, the deterministic round complexity of the locally optimal cut problem is now settled to log^Θ(1) n. Our algorithms also apply to the general case of graphs of maximum degree Δ. For the special case of locally optimal cut, we obtain a randomized algorithm that runs in O(Δ^2log^6 n) rounds, which can be derandomized at polylogarithmic cost with standard techniques. Furthermore, we show that a dependence in Δ is necessary: we prove a lower bound of Ω(min{Δ,√(n)}) rounds, even in the quantum-LOCAL model; in particular, there is no polylogarithmic-round algorithm for the general case.
Achieving agreement among distributed parties is a fundamental task in modern systems, underpinning applications such as consensus in blockchains, coordination in cloud infrastructure, and fault tolerance in critical services. However, this task can be intensive, often requiring a large number of messages to be exchanged as well as many rounds of communication, especially in the presence of Byzantine faults. This makes efficiency a central challenge in the design of practical agreement protocols. In this paper, we study the problem of Binary Agreement and give protocols that are simultaneously optimal in both message and round complexity, parameterized by the actual number of Byzantine faults. In contrast to previous works, we demonstrate that optimal message complexity can be achieved without sacrificing latency. Concretely, for a system of n parties tolerating up to t Byzantine faults, out of which only f ≤ t are actually faulty, we give the following results: When t = Ω(n), in the synchronous (resp. partially synchronous) setting, with optimal resiliency t < n/2 (resp. t < n/3), we describe a deterministic protocol with optimal communication complexity O(n · (f+1)) and optimal round complexity O(f + 1). Building upon this previous result, when t = o(n), for both the synchronous and partially synchronous setting, we describe a deterministic protocol with near-optimal communication complexity O(n + t· f) and near-optimal round complexity O(f+1). Our approach relies on a novel use of dispersers to efficiently disseminate a value. For the asynchronous setting, we show a Ω(n + t^2) lower bound in expectation and provide a randomized protocol with near-optimal O(n + t^2) communication complexity and O(1) round complexity in expectation.
Approximate Agreement (AA) is a key consensus primitive that allows honest parties to achieve close but not necessarily identical outputs, even in the presence of Byzantine faults. While optimal round complexity for synchronous AA on real values is well understood, its extension to other input spaces remains an open problem. We present a protocol achieving AA on trees in the synchronous model, with round complexity O (log |V(T)/log log | V (T) |, where V(T) is the set of vertices in the input space tree... Our protocol non-trivially reduces the problem of AA on trees to AA on real values. Additionally, we extend the impossibility result regarding the round complexity of AA protocols on real values to trees: we prove a lower bound of Omega (log D (T)/log log D(T)) rounds, where D(T) denotes the diameter of the input space tree. This establishes the asymptotic optimality of our protocol for trees of large diameter D(T) epsilon Theta(|V(T)|).
Broadcast is a central problem in distributed computing. Recently, Hussak and Trehan [PODC'19/DC'23] proposed a stateless broadcasting protocol (Amnesiac Flooding), which was surprisingly proven to terminate in asymptotically optimal time (linear in the diameter of the network). However, it remains unclear: (i) Are there other stateless terminating broadcast algorithms with the desirable properties of Amnesiac Flooding, (ii) How robust is Amnesiac Flooding with respect to faults? In this paper we make progress on both of these fronts. Under a reasonable restriction (obliviousness to message content) additional to the fault-free synchronous model, we prove that Amnesiac Flooding is the only strictly stateless deterministic protocol that can achieve terminating broadcast. We identify four natural properties of a terminating broadcast protocol that Amnesiac Flooding uniquely satisfies. In contrast, we prove that even minor relaxations of any of these four criteria allow the construction of other terminating broadcast protocols. On the other hand, we prove that Amnesiac Flooding can become non-terminating or non-broadcasting, even if we allow just one node to drop a single message on a single edge in a single round. As a tool for proving this, we focus on the set of all configurations of transmissions between nodes in the network, and obtain a dichotomy characterizing the configurations, starting from which, Amnesiac Flooding terminates. Additionally, we characterise the structure of sets of Byzantine agents capable of forcing non-termination or non-broadcast of the protocol on arbitrary networks.
In the renaming problem, a set of n nodes, each with a unique identity from a large namespace [N], needs to obtain new unique identities in a smaller namespace [M]. A renaming algorithm is strong if M = n. There exist many time-efficient solutions for fault-tolerant renaming in synchronous message-passing systems. However, all previous algorithms send Omega(n(2)) messages, and many of them also send large messages each containing Omega(n) bits. Moreover, most algorithms' performance do not scale with the actual number of failures. These limitations restrict their practical performance. We develop two new strong renaming algorithms, one tolerates up to n - 1 crash failures, and the other tolerates up to (1/3 - is an element of(0))n Byzantine failures for an arbitrarily small constant is an element of(0) > 0. The crash-resilient algorithm is always correct and always finishes within O(log n) rounds. It sends O((f + 1) . n) messages with high probability, where f is the actual number of crashes. This implies that it sends subquadratic messages as long as f = o(n/log n). The Byzantine-resilient algorithm trades time for communication cost: it finishes within O(max{f, 1}) rounds and sends only O(f + n) messages, with high probability. Here, f is the actual number of Byzantine nodes. Both algorithms only send messages of size O(log N) bits. Therefore, our crash-resilient algorithm incurs o(n(2)) communication cost as long as f = o(n/(log n log N)); and our Byzantine resilient algorithm incurs almost-linear communication cost. By deriving a lower bound, we conclude that our algorithms achieve near-optimal communication cost in many cases.
We design an algorithm that allows processes to click snapshots of the application's state, and store these snapshots in a shared archive for later retrieval. Such an archive of snapshots is useful for debugging complex multi-process applications. Traditional algorithms are designed for snapshotting an array of memory words, but modern applications employ pointer-based and dynamically growing objects, such as linked-lists, trees, and hash tables. Our algorithm is designed to snapshot such dynamic structures, which are composed of a dynamically changing set of memory words that are not necessarily consecutive. Our algorithm implements the abstraction of an RMWable, dynamic set S of shared memory words, supporting CreateComponent, Click, Search, Update, and DeleteComponent operations. CreateComponent() adds a new component c to S and returns it. Click() takes a new snapshot of S, stores it in the archive, and returns an integer (the ith click returns i). Search(c, i) returns the value of component c in the ith snapshot. Update(c, op(args)) updates component c by applying op(args) and returns the corresponding response. DeleteComponent(c) removes component c from S. Our algorithm is linearizable and wait-free. Two significant features of the algorithm are: (1) A component can be updated with any operation that the hardware supports, including read, write, and RMW operations, such as compare&swap, fetch&add, fetch & store; and (2) The algorithm supports an arbitrary and unknown number of processes of arbitrary names, and any process can access any archived snapshot, regardless of which process clicked which snapshot. In our algorithm, clicks and updates are fast, completing in a small constant number of steps. The time to search for an archived snapshot depends on how old the snapshot is, but it is guaranteed to be at most linear in the difference between the index of the latest snapshot and the index of the archived snapshot being searched for. The space complexity is optimal at O(mn), where m is the number of components and n is the number of snapshots taken so far. To the best of our knowledge, this is the first work on designing a wait-free shared snapshot-archive of RMWable memory.
Local Computation Algorithms (LCA), as introduced by Rubinfeld, Tamir, Vardi, and Xie (2011), are a type of ultra-efficient algorithms which, given access to a (large) input for a given computational task, are required to provide fast query access to a consistent output solution, without maintaining a state between queries. This paradigm of computation in particular allows for hugely distributed algorithms, where independent instances of a given LCA provide consistent access to a common output solution. We study the Knapsack Problem under LCA model. We first establish strong impossibility results, ruling out the existence of any non-trivial LCA for Knapsack as several of its relaxations. We then show how equipping the LCA with additional access to the Knapsack instance, namely, weighted item sampling, allows one to circumvent these impossibility results, and obtain sublinear-time and query LCAs. Our positive result draws on a connection to the recent notion of reproducibility for learning algorithms (Impagliazzo, Lei, Pitassi, and Sorrell, 2022), a connection we believe to be of independent interest for the design of LCAs.
The YOSO (You Only Speak Once) model, introduced by Gentry et al. (CRYPTO 2021), helps to achieve strong security guarantees in cryptographic protocols for large-scale distributed settings. In this work, we consider the problem of secure multi-party computation (MPC), a fundamental problem in cryptography and distributed computing. We assume honest majority among the committee members, and work in the online-offline, i.e., preprocessing, setting. We present the first YOSO MPC protocol where efficiencymeasured as communication complexity- improves as the number of parties increases. Specifically, for 0 < epsilon < 1/2 and an adversary corrupting t < n (1/2 - epsilon) out of n parties, our MPC protocol exhibits enhanced scalability as.. increases, where the online phase communication becomes independent of... Prior YOSO MPC protocols considered t as large as (n - 1)/2, but a significant hurdle persisted in obtaining YOSO MPC with communication that does not scale linearly with the number of committee members, a challenge that is exagerbated when the committee size was large per YOSO's requirements. We show that, by considering a small "gap" of epsilon > 0, the sizes of the committees are only marginally increased, while online communication is significantly reduced. We further explicitly consider fail-stop adversaries, i.e., honest participants who may inadvertently fail due to reasons such as denial of service or software/hardware errors. In prior YOSO work, these adversaries were grouped with fully malicious parties. Adding explicit support for them allows us to achieve even better scalability.
We establish that for every first-order logic (FO) formula phi, which captures a vast number of computational problems on graphs, and every graph class G of bounded expansion, there exists a deterministic distributed algorithm that, for any n-node graph G is an element of G with diameter D, determines whether G satisfies phi within O(D+log n) rounds in the standard CONGEST model. Graph classes of bounded expansion encompass many well-known families of sparse graphs, including planar graphs, bounded-genus graphs, bounded-treedepth graphs, bounded-treewidth graphs, bounded-degree graphs, graphs that exclude a fixed graph H as a minor or topological minor, random graphs with constant average degree (a.a.s.), and many network models (e.g., stochastic block models) for some ranges of parameters. Our algorithmic meta-theorem is "tight" in several ways. First, the bound on the number of rounds, up to a logarithmic additive term, is optimal, as even a simple FO formula such as "there are two vertices of degree 3" requires Omega(D) rounds in CONGEST even in trees. Second, deciding FO formulas requires significantly more rounds for more general classes of sparse graphs. In particular, we show that even the simple FO formula expressing C-6-freeness requires Omega(root n) rounds to be checked in graphs of degeneracy 2 with constant diameter. Finally, our theorem cannot be extended to monadic second order logic (MSO). For instance, we prove that checking non-3-colorability requires Omega(n) rounds in bounded-degree graphs with logarithmic diameter. Besides establishing the first generic result on the tractability of FO over a large class of sparse graphs, our meta-theorem and the techniques developed to prove it yield several important consequences. We demonstrate how to extend our algorithmic metatheorem to various distributed optimization, counting, and certification problems.
In this paper, we describe an algorithm implementing the uniqueid abstraction from bounded-storage registers maintaining read, write, and FAI operations. Given.. registers, storing.. bits each, our implementation generates up to (kappa - 1) center dot 2(w) unique identifiers, assuming that kappa <= 2(w) + 1. We show that this is asymptotically optimal: no unique-id implementation can produce more than kappa center dot 2(w) + kappa + 1 identifiers.
Emerging hardware technologies bring exciting new capabilities and challenges to our research menu. One such technology is disaggregated memory. While its roots date back to the early 1990s, it is only now that this technology is getting rolled out. Disaggregated memory allows servers in a data center to share a memory that is externally connected. This form of sharing differs conceptually from traditional shared memory in many ways: performance, fault model, coherence, and the ability to communicate with other mechanisms. These differences open up new applications and research questions on how to best use this memory effectively. In this talk, we explore some recent and ongoing work in this area.
