Volume
LIPIcs, Volume 319
38th International Symposium on Distributed Computing (DISC 2024)
-
Part of:
Series:
Leibniz International Proceedings in Informatics (LIPIcs)
Conference: International Symposium on Distributed Computing (DISC)
Publication Details
- published at: 2024-10-24
- Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik
- ISBN: 978-3-95977-352-2
Access Numbers
- Detailed Access Statistics available here
-
Total Document Accesses (updated on a weekly basis):
0PDF Downloads
Documents
No documents found matching your filter selection.
Document
Complete Volume
LIPIcs, Volume 319, DISC 2024, Complete Volume
Abstract
LIPIcs, Volume 319, DISC 2024, Complete Volume
Cite as
38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 1-952, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@Proceedings{alistarh:LIPIcs.DISC.2024,
title = {{LIPIcs, Volume 319, DISC 2024, Complete Volume}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {1--952},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024},
URN = {urn:nbn:de:0030-drops-220706},
doi = {10.4230/LIPIcs.DISC.2024},
annote = {Keywords: LIPIcs, Volume 319, DISC 2024, Complete Volume}
}
Document
Front Matter
Front Matter, Table of Contents, Preface, Conference Organization
Abstract
Front Matter, Table of Contents, Preface, Conference Organization
Cite as
38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 0:i-0:xx, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{alistarh:LIPIcs.DISC.2024.0,
author = {Alistarh, Dan},
title = {{Front Matter, Table of Contents, Preface, Conference Organization}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {0:i--0:xx},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.0},
URN = {urn:nbn:de:0030-drops-220693},
doi = {10.4230/LIPIcs.DISC.2024.0},
annote = {Keywords: Front Matter, Table of Contents, Preface, Conference Organization}
}
Document
Fully Local Succinct Distributed Arguments
Abstract
Distributed certification is a proof system for detecting illegal network states or improper execution of distributed algorithms. A certification scheme consists of a proving algorithm, which assigns a certificate to each node, and a verification algorithm where nodes use these certificates to decide whether to accept or reject. The system must ensure that all nodes accept if and only if the network is in a legal state, adhering to the principles of completeness and soundness. The main goal is to design a scheme where the verification process is local and the certificates are succinct, while using as efficient as possible proving algorithm.
In cryptographic proof systems, the soundness requirement is often relaxed to computational soundness, where soundness is guaranteed only against computationally bounded adversaries. Computationally sound proof systems are called arguments. Recently, Aldema Tshuva, Boyle, Cohen, Moran, and Oshman (TCC 2023) showed that succinct distributed arguments can be used to enable any polynomially bounded distributed algorithm to certify its execution with polylogarithmic-length certificates. However, their approach required a global communication phase, adding O(D) communication rounds in networks of diameter D, which limits its applicability to local algorithms.
In this work, we give the first construction of a fully local succinct distributed argument system, where the prover and the verifier are both local. We show that a distributed algorithm that runs in R rounds, has polynomial local computation, and messages of B bits each can be compiled into a self-certifying algorithm that runs in R + polylog(n) rounds and sends messages of size B + polylog(n), with certificates of length polylog(n). This construction has several applications, including self-certification for local algorithms, ongoing certification of long-lived algorithms, and efficient local mending of the certificates when the network changes.
Cite as
Eden Aldema Tshuva and Rotem Oshman. Fully Local Succinct Distributed Arguments. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 1:1-1:24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{aldematshuva_et_al:LIPIcs.DISC.2024.1,
author = {Aldema Tshuva, Eden and Oshman, Rotem},
title = {{Fully Local Succinct Distributed Arguments}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {1:1--1:24},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.1},
URN = {urn:nbn:de:0030-drops-212662},
doi = {10.4230/LIPIcs.DISC.2024.1},
annote = {Keywords: distributed certification, proof labeling schemes, SNARG}
}
Document
A Knowledge-Based Analysis of Intersection Protocols
Abstract
The increasing wireless communication capabilities of vehicles creates opportunities for more efficient intersection management strategies. One promising approach is the replacement of traffic lights with a system wherein vehicles run protocols among themselves to determine right of way. In this paper, we define the intersection problem to model this scenario abstractly, without any assumptions on the specific structure of the intersection or a bound on the number of vehicles. Protocols solving the intersection problem must guarantee safety (no collisions) and liveness (every vehicle eventually goes through). In addition, we would like these protocols to satisfy various optimality criteria, some of which turn out to be achievable only in a subset of the contexts. In particular, we show a partial equivalence between eliminating unnecessary waiting, a criterion of interest in the distributed mutual-exclusion literature, and a notion of optimality that we define called lexicographical optimality. We then introduce a framework to design protocols for the intersection problem by converting an intersection policy, which is based on a global view of the intersection, to a protocol that can be run by the vehicles through the use of knowledge-based programs. Our protocols are shown to guarantee safety and liveness while also being optimal under sufficient conditions on the context. Finally, we investigate protocols in the presence of faulty vehicles that experience communication failures and older vehicles with limited communication capabilities. We show that intersection protocols can be made safe, live and optimal even in the presence of faulty behavior.
Cite as
Kaya Alpturer, Joseph Y. Halpern, and Ron van der Meyden. A Knowledge-Based Analysis of Intersection Protocols. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 2:1-2:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{alpturer_et_al:LIPIcs.DISC.2024.2,
author = {Alpturer, Kaya and Halpern, Joseph Y. and van der Meyden, Ron},
title = {{A Knowledge-Based Analysis of Intersection Protocols}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {2:1--2:17},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.2},
URN = {urn:nbn:de:0030-drops-212291},
doi = {10.4230/LIPIcs.DISC.2024.2},
annote = {Keywords: Intersection management, Autonomous vehicles, Distributed algorithms, Epistemic logic, Fault tolerance}
}
Document
Byzantine Resilient Distributed Computing on External Data
Abstract
We study a class of problems we call retrieval problems in which a distributed network has read-only access to a trusted external data source through queries, and each peer is required to output some computable function of the data. To formalize this, we propose the Data Retrieval Model comprising two parts: (1) a congested clique network with k peers, up to β k of which can be Byzantine in every execution (for suitable values of β ∈ [0,1)); (2) a trusted source of data with no computational abilities, called the External Data Source (or just source for short). This source stores an array 𝒳 of n bits (n ≫ k), providing every peer in the congested clique read-only access to 𝒳 through queries. It is assumed that a query to the source is significantly more expensive than a message between two peers in the network. Hence, we prioritize minimizing the number of queries a peer performs over the number of messages it sends. Retrieval problems are easily solved by having each peer query all of 𝒳, so we focus on designing non-trivial query-efficient protocols for retrieval problems in the DR network that achieve low query performance per peer. Specifically, to initiate this study, we present deterministic and randomized upper and lower bounds for two fundamental problems. The first is the Download problem that requires every peer to output an array of n bits identical to 𝒳. The second problem of focus, Disjunction, requires nodes to learn if some bit in 𝒳 is set to 1.
Cite as
John Augustine, Jeffin Biju, Shachar Meir, David Peleg, Srikkanth Ramachandran, and Aishwarya Thiruvengadam. Byzantine Resilient Distributed Computing on External Data. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 3:1-3:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{augustine_et_al:LIPIcs.DISC.2024.3,
author = {Augustine, John and Biju, Jeffin and Meir, Shachar and Peleg, David and Ramachandran, Srikkanth and Thiruvengadam, Aishwarya},
title = {{Byzantine Resilient Distributed Computing on External Data}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {3:1--3:23},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.3},
URN = {urn:nbn:de:0030-drops-212304},
doi = {10.4230/LIPIcs.DISC.2024.3},
annote = {Keywords: Byzantine Fault Tolerance, Blockchain Oracle, Congested Clique, Data Retrieval Model}
}
Document
Almost Optimal Algorithms for Token Collision in Anonymous Networks
Abstract
In distributed systems, situations often arise where some nodes each holds a collection of tokens, and all nodes collectively need to determine whether all tokens are distinct. For example, if each token represents a logged-in user, the problem corresponds to checking whether there are duplicate logins. Similarly, if each token represents a data object or a timestamp, the problem corresponds to checking whether there are conflicting operations in distributed databases. In distributed computing theory, unique identifiers generation is also related to this problem: each node generates one token, which is its identifier, then a verification phase is needed to ensure that all identifiers are unique.
In this paper, we formalize and initiate the study of token collision. In this problem, a collection of k tokens, each represented by some length-L bit string, are distributed to n nodes of an anonymous CONGEST network in an arbitrary manner. The nodes need to determine whether there are tokens with an identical value. We present near optimal deterministic algorithms for the token collision problem with Õ(D+k⋅L/log n) round complexity, where D denotes the network diameter. Besides high efficiency, the prior knowledge required by our algorithms is also limited. For completeness, we further present a near optimal randomized algorithm for token collision.
Cite as
Sirui Bai, Xinyu Fu, Xudong Wu, Penghui Yao, and Chaodong Zheng. Almost Optimal Algorithms for Token Collision in Anonymous Networks. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 4:1-4:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{bai_et_al:LIPIcs.DISC.2024.4,
author = {Bai, Sirui and Fu, Xinyu and Wu, Xudong and Yao, Penghui and Zheng, Chaodong},
title = {{Almost Optimal Algorithms for Token Collision in Anonymous Networks}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {4:1--4:20},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.4},
URN = {urn:nbn:de:0030-drops-212319},
doi = {10.4230/LIPIcs.DISC.2024.4},
annote = {Keywords: Token collision, anonymous networks, deterministic algorithms}
}
Document
Asynchronous Fault-Tolerant Distributed Proper Coloring of Graphs
Abstract
We revisit asynchronous computing in networks of crash-prone processes, under the asynchronous variant of the standard LOCAL model, recently introduced by Fraigniaud et al. [DISC 2022]. We focus on the vertex coloring problem, and our contributions concern both lower and upper bounds for this problem.
On the upper bound side, we design an algorithm tolerating an arbitrarily large number of crash failures that computes an O(Δ²)-coloring of any n-node graph of maximum degree Δ, in O(log^⋆ n) rounds. This extends Linial’s seminal result from the (synchronous failure-free) LOCAL model to its asynchronous crash-prone variant. Then, by allowing a dependency on Δ on the runtime, we show that we can reduce the colors to ((1/2)(Δ+1)(Δ+2)-1). For cycles (i.e., for Δ = 2), our algorithm achieves a 5-coloring of any n-node cycle, in O(log^⋆ n) rounds. This improves the known 6-coloring algorithm by Fraigniaud et al., and fixes a bug in their algorithm, which was erroneously claimed to produce a 5-coloring.
On the lower bound side, we show that, for k < 5, and for every prime integer n, no algorithm can k-color the n-node cycle in the asynchronous crash-prone variant of LOCAL, independently from the round-complexities of the algorithms. This lower bound is obtained by reduction from an original extension of the impossibility of solving weak symmetry-breaking in the wait-free shared-memory model. We show that this impossibility still holds even if the processes are provided with inputs susceptible to help breaking symmetry.
Cite as
Alkida Balliu, Pierre Fraigniaud, Patrick Lambein-Monette, Dennis Olivetti, and Mikaël Rabie. Asynchronous Fault-Tolerant Distributed Proper Coloring of Graphs. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 5:1-5:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{balliu_et_al:LIPIcs.DISC.2024.5,
author = {Balliu, Alkida and Fraigniaud, Pierre and Lambein-Monette, Patrick and Olivetti, Dennis and Rabie, Mika\"{e}l},
title = {{Asynchronous Fault-Tolerant Distributed Proper Coloring of Graphs}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {5:1--5:20},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.5},
URN = {urn:nbn:de:0030-drops-212328},
doi = {10.4230/LIPIcs.DISC.2024.5},
annote = {Keywords: LOCAL model, Graph Coloring, Renaming, Weak Symmetry-Breaking, Fault-Tolerance, Wait-Free Computing}
}
Document
Speedup of Distributed Algorithms for Power Graphs in the CONGEST Model
Abstract
We obtain improved distributed algorithms in the CONGEST message-passing setting for problems on power graphs of an input graph G. This includes Coloring, Maximal Independent Set, and related problems. For R = f(Δ^k,n), we develop a general deterministic technique that transforms R-round LOCAL model algorithms for G^k with certain properties into O(R ⋅ Δ^{k/2-1})-round CONGEST algorithms for G^k. This improves the previously-known running time for such transformation, which was O(R⋅Δ^{k-1}). Consequently, for problems that can be solved by algorithms with the required properties and within polylogarithmic number of rounds, we obtain quadratic improvement for G^k and exponential improvement for G². We also obtain significant improvements for problems with larger number of rounds in G. Notable implications of our technique are the following deterministic distributed algorithms:
- We devise a distributed algorithm for O(Δ⁴)-coloring of G² whose number of rounds is O(log Δ + log^* n). This improves exponentially (in terms of Δ) the best previously-known deterministic result of Halldorsson, Kuhn and Maus.[M. M. Halldorson et al., 2020] that required O(Δ + log^{*}n) rounds, and the standard simulation of Linial [N. Linial, 1992] algorithm in G^k that required O(Δ ⋅ log^* n) rounds.
- We devise an algorithm for O(Δ²)-coloring of G² with O(Δ ⋅ log Δ + log^*n) rounds, and (Δ²+1)-coloring with O(Δ^{1.5} ⋅ log Δ + log^*n) rounds. This improves quadratically, and by a power of 4/3, respectively, the best previously-known results of Halldorsson, Khun and Maus. [M. M. Halldorson et al., 2020].
- For k > 2, our running time for O(Δ^{2k})-coloring of G^k is O(k⋅Δ^{k/2-1}⋅log Δ⋅log^* n). Our running time for O(Δ^k)-coloring of G^k is Õ(k⋅Δ^{k-1}⋅log^* n). This improves best previously-known results quadratically, and by a power of 3/2, respectively.
- For constant k > 2, our upper bound for O(Δ^{2k})-coloring of G^k nearly matches the lower bound of Fraigniaud, Halldorsson and Nolin. [P. Fraigniaud et al., 2020] for checking the correctness of a coloring in G^k.
Cite as
Leonid Barenboim and Uri Goldenberg. Speedup of Distributed Algorithms for Power Graphs in the CONGEST Model. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 6:1-6:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{barenboim_et_al:LIPIcs.DISC.2024.6,
author = {Barenboim, Leonid and Goldenberg, Uri},
title = {{Speedup of Distributed Algorithms for Power Graphs in the CONGEST Model}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {6:1--6:23},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.6},
URN = {urn:nbn:de:0030-drops-212337},
doi = {10.4230/LIPIcs.DISC.2024.6},
annote = {Keywords: Distributed Algorithms, Graph Coloring, Power Graph, CONGEST}
}
Document
A Fully Concurrent Adaptive Snapshot Object for RMWable Shared-Memory
Abstract
An adaptive RMWable snapshot object maintains an array A[0..m-1] of m readable shared memory objects that support an arbitrary set of read-modify-write (RMW) operations, in addition to Read(). Each array entry A[i] can be accessed by any process using an operation Invoke(i,op), which simply applies a supported RMW operation op to A[i] and returns the response of op. In addition, processes can record the state of the array by calling Click(). While Click() does not return anything, a process p can call Observe(i) to determine the value of A[i] at the point of p’s latest Click().
Recently, Jayanti, Jayanti, and Jayanti [Prasad Jayanti et al., 2024] presented an RMWable adaptive snapshot object, where all operations have constant step complexity. Their algorithm is single-scanner, meaning that Click() operations cannot be executed concurrently. We present the first fully concurrent RMWable adaptive snapshot object, where all operations can be executed concurrently, assuming the the system provides atomic Fetch-And-Increment and Compare-And-Swap operations. Click() and Invoke() operations have constant step complexity, and Observe() has step complexity O(log n). The total number of base objects needed is O(mnlog n).
Cite as
Benyamin Bashari, David Yu Cheng Chan, and Philipp Woelfel. A Fully Concurrent Adaptive Snapshot Object for RMWable Shared-Memory. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 7:1-7:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{bashari_et_al:LIPIcs.DISC.2024.7,
author = {Bashari, Benyamin and Chan, David Yu Cheng and Woelfel, Philipp},
title = {{A Fully Concurrent Adaptive Snapshot Object for RMWable Shared-Memory}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {7:1--7:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.7},
URN = {urn:nbn:de:0030-drops-212342},
doi = {10.4230/LIPIcs.DISC.2024.7},
annote = {Keywords: Shared memory, snapshot, camera object, RMW, distributed computing}
}
Document
Hyperproperty-Preserving Register Specifications
Abstract
Reasoning about hyperproperties of concurrent implementations, such as the guarantees these implementations provide to randomized client programs, has been a long-standing challenge. Standard linearizability enables the use of atomic specifications for reasoning about standard properties, but not about hyperproperties. A stronger correctness criterion, called strong linearizability, enables such reasoning, but is rarely achievable, leaving various useful implementations with no means for reasoning about their hyperproperties. In this paper, we focus on registers and devise non-atomic specifications that capture a wide-range of well-studied register implementations and enable reasoning about their hyperproperties. First, we consider the class of write strong-linearizable implementations, a recently proposed useful weakening of strong linearizability, which allows more implementations, such as the well-studied single-writer ABD distributed implementation. We introduce a simple shared-memory register specification that can be used for reasoning about hyperproperties of programs that use write strongly-linearizable implementations. Second, we introduce a new linearizability class, which we call decisive linearizability, that is weaker than write strong-linearizability and includes multi-writer ABD, and develop a second shared-memory register specification for reasoning about hyperproperties of programs that use register implementations of this class. These results shed light on the hyperproperties guaranteed when simulating shared memory in a crash-resilient message-passing system.
Cite as
Yoav Ben Shimon, Ori Lahav, and Sharon Shoham. Hyperproperty-Preserving Register Specifications. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 8:1-8:19, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{benshimon_et_al:LIPIcs.DISC.2024.8,
author = {Ben Shimon, Yoav and Lahav, Ori and Shoham, Sharon},
title = {{Hyperproperty-Preserving Register Specifications}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {8:1--8:19},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.8},
URN = {urn:nbn:de:0030-drops-212630},
doi = {10.4230/LIPIcs.DISC.2024.8},
annote = {Keywords: Hyperproperties, Concurrent objects, Distributed objects, Linearizability, Strong linearizability, Simulation}
}
Document
Freeze-Tag in L₁ Has Wake-Up Time Five with Linear Complexity
Abstract
The Freeze-Tag Problem, introduced in Arkin et al. (SODA'02) consists of waking up a swarm of n robots, starting from a single active robot. In the basic geometric version, every robot is given coordinates in the plane. As soon as a robot is awakened, it can move towards inactive robots to wake them up. The goal is to minimize the makespan of the last robot, the makespan.
Despite significant progress on the computational complexity of this problem and on approximation algorithms, the characterization of exact bounds on the makespan remains one of the main open questions. In this paper, we settle this question for the 𝓁₁-norm, showing that a makespan of at most 5r can always be achieved, where r is the maximum distance between the initial active robot and any sleeping robot. Moreover, a schedule achieving a makespan of at most 5r can be computed in time O(n). Both bounds, the time and the makespan are optimal. Our results also imply for the 𝓁₂-norm a new upper bound of 5√2r ≈ 7.07r on the makespan, improving the best known bound of (5+2√2+√5)r ≈ 10.06r.
Along the way, we introduce new linear time wake-up strategies, that apply to any norm and show that an optimal bound on the makespan can always be achieved by a schedule computable in linear time.
Cite as
Nicolas Bonichon, Arnaud Casteigts, Cyril Gavoille, and Nicolas Hanusse. Freeze-Tag in L₁ Has Wake-Up Time Five with Linear Complexity. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 9:1-9:16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{bonichon_et_al:LIPIcs.DISC.2024.9,
author = {Bonichon, Nicolas and Casteigts, Arnaud and Gavoille, Cyril and Hanusse, Nicolas},
title = {{Freeze-Tag in L₁ Has Wake-Up Time Five with Linear Complexity}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {9:1--9:16},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.9},
URN = {urn:nbn:de:0030-drops-212356},
doi = {10.4230/LIPIcs.DISC.2024.9},
annote = {Keywords: freeze-tag problem, metric, algorithm}
}
Document
Vertical Atomic Broadcast and Passive Replication
Abstract
Atomic broadcast is a reliable communication abstraction ensuring that all processes deliver the same set of messages in a common global order. It is a fundamental building block for implementing fault-tolerant services using either active (aka state-machine) or passive (aka primary-backup) replication. We consider the problem of implementing reconfigurable atomic broadcast, which further allows users to dynamically alter the set of participating processes, e.g., in response to failures or changes in the load. We give a complete safety and liveness specification of this communication abstraction and propose a new protocol implementing it, called Vertical Atomic Broadcast, which uses an auxiliary service to facilitate reconfiguration. In contrast to prior proposals, our protocol significantly reduces system downtime when reconfiguring from a functional configuration by allowing it to continue processing messages while agreement on the next configuration is in progress. Furthermore, we show that this advantage can be maintained even when our protocol is modified to support a stronger variant of atomic broadcast required for passive replication.
Cite as
Manuel Bravo, Gregory Chockler, Alexey Gotsman, Alejandro Naser-Pastoriza, and Christian Roldán. Vertical Atomic Broadcast and Passive Replication. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 10:1-10:19, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{bravo_et_al:LIPIcs.DISC.2024.10,
author = {Bravo, Manuel and Chockler, Gregory and Gotsman, Alexey and Naser-Pastoriza, Alejandro and Rold\'{a}n, Christian},
title = {{Vertical Atomic Broadcast and Passive Replication}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {10:1--10:19},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.10},
URN = {urn:nbn:de:0030-drops-212363},
doi = {10.4230/LIPIcs.DISC.2024.10},
annote = {Keywords: Reconfiguration, consensus, replication}
}
Document
What Cannot Be Implemented on Weak Memory?
Abstract
We present a general methodology for establishing the impossibility of implementing certain concurrent objects on different (weak) memory models. The key idea behind our approach lies in characterizing memory models by their mergeability properties, identifying restrictions under which independent memory traces can be merged into a single valid memory trace. In turn, we show that the mergeability properties of the underlying memory model entail similar mergeability requirements on the specifications of objects that can be implemented on that memory model. We demonstrate the applicability of our approach to establish the impossibility of implementing standard distributed objects with different restrictions on memory traces on three memory models: strictly consistent memory, total store order, and release-acquire. These impossibility results allow us to identify tight and almost tight bounds for some objects, as well as new separation results between weak memory models, and between well-studied objects based on their implementability on weak memory models.
Cite as
Armando Castañeda, Gregory Chockler, Brijesh Dongol, and Ori Lahav. What Cannot Be Implemented on Weak Memory?. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 11:1-11:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{castaneda_et_al:LIPIcs.DISC.2024.11,
author = {Casta\~{n}eda, Armando and Chockler, Gregory and Dongol, Brijesh and Lahav, Ori},
title = {{What Cannot Be Implemented on Weak Memory?}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {11:1--11:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.11},
URN = {urn:nbn:de:0030-drops-212371},
doi = {10.4230/LIPIcs.DISC.2024.11},
annote = {Keywords: Impossibility, Weak Memory Models, Total-Store Order, Release-Acquire}
}
Document
Faster Cycle Detection in the Congested Clique
Abstract
We provide a fast distributed algorithm for detecting h-cycles in the Congested Clique model, whose running time decreases as the number of h-cycles in the graph increases. In undirected graphs, constant-round algorithms are known for cycles of even length. Our algorithm greatly improves upon the state of the art for odd values of h. Moreover, our running time applies also to directed graphs, in which case the improvement is for all values of h. Further, our techniques allow us to obtain a triangle detection algorithm in the quantum variant of this model, which is faster than prior work.
A key technical contribution we develop to obtain our fast cycle detection algorithm is a new algorithm for computing the product of many pairs of small matrices in parallel, which may be of independent interest.
Cite as
Keren Censor-Hillel, Tomer Even, and Virginia Vassilevska Williams. Faster Cycle Detection in the Congested Clique. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 12:1-12:18, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{censorhillel_et_al:LIPIcs.DISC.2024.12,
author = {Censor-Hillel, Keren and Even, Tomer and Vassilevska Williams, Virginia},
title = {{Faster Cycle Detection in the Congested Clique}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {12:1--12:18},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.12},
URN = {urn:nbn:de:0030-drops-212382},
doi = {10.4230/LIPIcs.DISC.2024.12},
annote = {Keywords: triangle detection, cycle detection, distributed computing, Congested Clique, quantum computing, Fast matrix multiplication, Fast rectangular matrix multiplication}
}
Document
Deterministic Self-Stabilising Leader Election for Programmable Matter with Constant Memory
Abstract
The problem of electing a unique leader is central to all distributed systems, including programmable matter systems where particles have constant size memory. In this paper, we present a silent self-stabilising, deterministic, stationary, election algorithm for particles having constant memory, assuming that the system is simply connected. Our algorithm is elegant and simple, and requires constant memory per particle. We prove that our algorithm always stabilises to a configuration with a unique leader, under a daemon satisfying some fairness guarantees (Gouda fairness [Mohamed G. Gouda, 2001]). We use the special geometric properties of programmable matter in 2D triangular grids to obtain the first self-stabilising algorithm for such systems. This result is surprising since it is known that silent self-stabilising algorithms for election in general distributed networks require Ω(log n) bits of memory per node, even for ring topologies [Shlomi Dolev et al., 1999].
Cite as
Jérémie Chalopin, Shantanu Das, and Maria Kokkou. Deterministic Self-Stabilising Leader Election for Programmable Matter with Constant Memory. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 13:1-13:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{chalopin_et_al:LIPIcs.DISC.2024.13,
author = {Chalopin, J\'{e}r\'{e}mie and Das, Shantanu and Kokkou, Maria},
title = {{Deterministic Self-Stabilising Leader Election for Programmable Matter with Constant Memory}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {13:1--13:17},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.13},
URN = {urn:nbn:de:0030-drops-212395},
doi = {10.4230/LIPIcs.DISC.2024.13},
annote = {Keywords: Leader Election, Programmable Matter, Self-Stabilisation, Silent, Deterministic, Unique Leader, Simply Connected, Gouda fair Daemon, Constant Memory}
}
Document
Efficient Signature-Free Validated Agreement
Abstract
Byzantine agreement enables n processes to agree on a common L-bit value, despite up to t > 0 arbitrary failures. A long line of work has been dedicated to improving the bit complexity of Byzantine agreement in synchrony. This has culminated in COOL, an error-free (deterministically secure against a computationally unbounded adversary) solution that achieves O(nL + n² log n) worst-case bit complexity (which is optimal for L ≥ n log n according to the Dolev-Reischuk lower bound). COOL satisfies strong unanimity: if all correct processes propose the same value, only that value can be decided. Whenever correct processes do not agree a priori (there is no unanimity), they may decide a default value ⊥ from COOL.
Strong unanimity is, however, not sufficient for today’s state machine replication (SMR) and blockchain protocols. These systems value progress and require a decided value to always be valid (according to a predetermined predicate), excluding default decisions (such as ⊥) even in cases where there is no unanimity a priori. Validated Byzantine agreement satisfies this property (called external validity). Yet, the best error-free (or even signature-free) validated agreement solutions achieve only O(n²L) bit complexity, a far cry from the Ω(nL+n²) Dolev-Reischuk lower bound. Is it possible to bridge this complexity gap?
We answer the question affirmatively. Namely, we present two new synchronous algorithms for validated Byzantine agreement, HashExt and ErrorFreeExt, with different trade-offs. Both algorithms are (1) signature-free, (2) optimally resilient (tolerate up to t < n / 3 failures), and (3) early-stopping (terminate in O(f+1) rounds, where f ≤ t denotes the actual number of failures). On the one hand, HashExt uses only hashes and achieves O(nL + n³κ) bit complexity, which is optimal for L ≥ n²κ (where κ is the size of a hash). On the other hand, ErrorFreeExt is error-free, using no cryptography whatsoever, and achieves O((nL + n²)log n) bit complexity, which is near-optimal for any L.
Cite as
Pierre Civit, Muhammad Ayaz Dzulfikar, Seth Gilbert, Rachid Guerraoui, Jovan Komatovic, Manuel Vidigueira, and Igor Zablotchi. Efficient Signature-Free Validated Agreement. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 14:1-14:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{civit_et_al:LIPIcs.DISC.2024.14,
author = {Civit, Pierre and Dzulfikar, Muhammad Ayaz and Gilbert, Seth and Guerraoui, Rachid and Komatovic, Jovan and Vidigueira, Manuel and Zablotchi, Igor},
title = {{Efficient Signature-Free Validated Agreement}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {14:1--14:23},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.14},
URN = {urn:nbn:de:0030-drops-212408},
doi = {10.4230/LIPIcs.DISC.2024.14},
annote = {Keywords: Validated Byzantine agreement, Bit complexity, Round complexity}
}
Document
Convex Consensus with Asynchronous Fallback
Abstract
Convex Consensus (CC) allows a set of parties to agree on a value v inside the convex hull of their inputs with respect to a predefined abstract convexity notion, even in the presence of byzantine parties. In this work, we focus on achieving CC in the best-of-both-worlds paradigm, i.e., simultaneously tolerating at most t_s corruptions if communication is synchronous, and at most t_a ≤ t_s corruptions if it is asynchronous. Our protocol is randomized, which is a requirement under asynchrony, and we prove that it achieves optimal resilience. In the process, we introduce communication primitives tailored to the network-agnostic model. These are a deterministic primitive allowing parties to obtain intersecting views (Gather), and a randomized primitive leading to identical views (Agreement on a Core-Set). Our primitives provide stronger guarantees than previous counterparts, making them of independent interest.
Cite as
Andrei Constantinescu, Diana Ghinea, Roger Wattenhofer, and Floris Westermann. Convex Consensus with Asynchronous Fallback. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 15:1-15:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{constantinescu_et_al:LIPIcs.DISC.2024.15,
author = {Constantinescu, Andrei and Ghinea, Diana and Wattenhofer, Roger and Westermann, Floris},
title = {{Convex Consensus with Asynchronous Fallback}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {15:1--15:23},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.15},
URN = {urn:nbn:de:0030-drops-212411},
doi = {10.4230/LIPIcs.DISC.2024.15},
annote = {Keywords: convex consensus, network-agnostic protocols, agreement on a core-set}
}
Document
A Simple Computability Theorem for Colorless Tasks in Submodels of the Iterated Immediate Snapshot
Abstract
The Iterated Immediate Snapshot model (IIS) is a central model in distributed computing. We present our work in the message adversary setting. We consider general message adversaries whose executions are arbitrary subsets of executions M of the IIS message adversary. We present a complete and explicit characterization of solvable colorless tasks given any submodel of IIS.
Based upon the geometrization mapping geo introduced in [Yannis Coutouly and Emmanuel Godard, 2023] to investigate set-agreement in general submodels, we give a simple necessary and sufficient condition for computability. The geometrization geo associates to any execution a point in R^N. A colorless task (I, O, Δ) is solvable under M if and only if there is a continuous function f : geo(skelⁿ(I) × M) ⟶ | O| carried by Δ.
This necessary and sufficient condition for colorless tasks was already known for full models like the Iterated Immediate Snapshot model [Maurice Herlihy et al., 2013] so our result is an extension of the characterization to any arbitrary submodels. It also shows the notion of continuity that is relevant for distributed computability of submodels is not the one from abstract simplicial complexes but the standard one from R^N. As an example of its effectiveness, we can now derive the characterization of the computability of set-agreement on submodels from [Yannis Coutouly and Emmanuel Godard, 2023] by a direct application of the No-Retraction theorem of standard topology textbook. We also give a new fully geometric proof of the known characterization of computable colorless tasks for t-resilient layered snapshot model by using cross-sections of fiber bundles, a standard tool in algebraic topology.
Cite as
Yannis Coutouly and Emmanuel Godard. A Simple Computability Theorem for Colorless Tasks in Submodels of the Iterated Immediate Snapshot. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 16:1-16:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{coutouly_et_al:LIPIcs.DISC.2024.16,
author = {Coutouly, Yannis and Godard, Emmanuel},
title = {{A Simple Computability Theorem for Colorless Tasks in Submodels of the Iterated Immediate Snapshot}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {16:1--16:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.16},
URN = {urn:nbn:de:0030-drops-212422},
doi = {10.4230/LIPIcs.DISC.2024.16},
annote = {Keywords: topological methods, geometric simplicial complex, set-agreement}
}
Document
Breaking Through the Ω(n)-Space Barrier: Population Protocols Decide Double-Exponential Thresholds
Abstract
Population protocols are a model of distributed computation in which finite-state agents interact randomly in pairs. A protocol decides for any initial configuration whether it satisfies a fixed property, specified as a predicate on the set of configurations. A family of protocols deciding predicates φ_n is succinct if it uses 𝒪(|φ_n|) states, where φ_n is encoded as quantifier-free Presburger formula with coefficients in binary. (All predicates decidable by population protocols can be encoded in this manner.) While it is known that succinct protocols exist for all predicates, it is open whether protocols with o(|φ_n|) states exist for any family of predicates φ_n. We answer this affirmatively, by constructing protocols with 𝒪(log|φ_n|) states for some family of threshold predicates φ_n(x) ⇔ x ≥ k_n, with k₁,k₂,... ∈ ℕ. (In other words, protocols with 𝒪(n) states that decide x ≥ k for a k ≥ 2^2ⁿ.) This matches a known lower bound. Moreover, our construction for threshold predicates is the first that is not 1-aware, and it is almost self-stabilising.
Cite as
Philipp Czerner. Breaking Through the Ω(n)-Space Barrier: Population Protocols Decide Double-Exponential Thresholds. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 17:1-17:18, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{czerner:LIPIcs.DISC.2024.17,
author = {Czerner, Philipp},
title = {{Breaking Through the \Omega(n)-Space Barrier: Population Protocols Decide Double-Exponential Thresholds}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {17:1--17:18},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.17},
URN = {urn:nbn:de:0030-drops-212438},
doi = {10.4230/LIPIcs.DISC.2024.17},
annote = {Keywords: Distributed computing, population protocols, state complexity}
}
Document
On the Limits of Information Spread by Memory-Less Agents
Abstract
We address the self-stabilizing bit-dissemination problem, designed to capture the challenges of spreading information and reaching consensus among entities with minimal cognitive and communication capacities. Specifically, a group of n agents is required to adopt the correct opinion, initially held by a single informed individual, choosing from two possible opinions. In order to make decisions, agents are restricted to observing the opinions of a few randomly sampled agents, and lack the ability to communicate further and to identify the informed individual. Additionally, agents cannot retain any information from one round to the next. According to a recent publication by Becchetti et al. in SODA (2024), a logarithmic convergence time without memory is achievable in the parallel setting (where agents are updated simultaneously), as long as the number of samples is at least Ω(√{n log n}). However, determining the minimal sample size for an efficient protocol to exist remains a challenging open question. As a preliminary step towards an answer, we establish the first lower bound for this problem in the parallel setting. Specifically, we demonstrate that it is impossible for any memory-less protocol with constant sample size, to converge with high probability in less than an almost-linear number of rounds. This lower bound holds even when agents are aware of both the exact value of n and their own opinion, and encompasses various simple existing dynamics designed to achieve consensus. Beyond the bit-dissemination problem, our result sheds light on the convergence time of the "minority" dynamics, the counterpart of the well-known majority rule, whose chaotic behavior is yet to be fully understood despite the apparent simplicity of the algorithm.
Cite as
Niccolò D'Archivio and Robin Vacus. On the Limits of Information Spread by Memory-Less Agents. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 18:1-18:21, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{darchivio_et_al:LIPIcs.DISC.2024.18,
author = {D'Archivio, Niccol\`{o} and Vacus, Robin},
title = {{On the Limits of Information Spread by Memory-Less Agents}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {18:1--18:21},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.18},
URN = {urn:nbn:de:0030-drops-212441},
doi = {10.4230/LIPIcs.DISC.2024.18},
annote = {Keywords: Opinion Dynamics, Consensus Protocols, Collective Animal Behavior, Lower Bound}
}
Document
Parallel Set Cover and Hypergraph Matching via Uniform Random Sampling
Abstract
The SetCover problem has been extensively studied in many different models of computation, including parallel and distributed settings. From an approximation point of view, there are two standard guarantees: an O(log Δ)-approximation (where Δ is the maximum set size) and an O(f)-approximation (where f is the maximum number of sets containing any given element).
In this paper, we introduce a new, surprisingly simple, model-independent approach to solving SetCover in unweighted graphs. We obtain multiple improved algorithms in the MPC and CRCW PRAM models. First, in the MPC model with sublinear space per machine, our algorithms can compute an O(f) approximation to SetCover in Ô(√{log Δ} + log f) rounds and a O(log Δ) approximation in O(log^{3/2} n) rounds. Moreover, in the PRAM model, we give a O(f) approximate algorithm using linear work and O(log n) depth. All these bounds improve the existing round complexity/depth bounds by a log^{Ω(1)} n factor.
Moreover, our approach leads to many other new algorithms, including improved algorithms for the HypergraphMatching problem in the MPC model, as well as simpler SetCover algorithms that match the existing bounds.
Cite as
Laxman Dhulipala, Michael Dinitz, Jakub Łącki, and Slobodan Mitrović. Parallel Set Cover and Hypergraph Matching via Uniform Random Sampling. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 19:1-19:23, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{dhulipala_et_al:LIPIcs.DISC.2024.19,
author = {Dhulipala, Laxman and Dinitz, Michael and {\L}\k{a}cki, Jakub and Mitrovi\'{c}, Slobodan},
title = {{Parallel Set Cover and Hypergraph Matching via Uniform Random Sampling}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {19:1--19:23},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.19},
URN = {urn:nbn:de:0030-drops-212453},
doi = {10.4230/LIPIcs.DISC.2024.19},
annote = {Keywords: approximate maximum matching, set cover, hypergraph matching, PRAM, massively parallel computation}
}
Document
The Computational Power of Discrete Chemical Reaction Networks with Bounded Executions
Abstract
Chemical reaction networks (CRNs) model systems where molecules interact according to a finite set of reactions such as A + B → C, representing that if a molecule of A and B collide, they disappear and a molecule of C is produced. CRNs can compute Boolean-valued predicates ϕ:ℕ^d → {0,1} and integer-valued functions f:ℕ^d → ℕ; for instance X₁ + X₂ → Y computes the function min(x₁,x₂), since starting with x_i copies of X_i, eventually min(x₁,x₂) copies of Y are produced.
We study the computational power of execution bounded CRNs, in which only a finite number of reactions can occur from the initial configuration (e.g., ruling out reversible reactions such as A ⇌ B). The power and composability of such CRNs depend crucially on some other modeling choices that do not affect the computational power of CRNs with unbounded executions, namely whether an initial leader is present, and whether (for predicates) all species are required to "vote" for the Boolean output. If the CRN starts with an initial leader, and can allow only the leader to vote, then all semilinear predicates and functions can be stably computed in O(n log n) parallel time by execution bounded CRNs.
However, if no initial leader is allowed, all species vote, and the CRN is "non-collapsing" (does not shrink from initially large to final O(1) size configurations), then execution bounded CRNs are severely limited, able to compute only eventually constant predicates. A key tool is a characterization of execution bounded CRNs as precisely those with a nonnegative linear potential function that is strictly decreased by every reaction [Czerner et al., 2024].
Cite as
David Doty and Ben Heckmann. The Computational Power of Discrete Chemical Reaction Networks with Bounded Executions. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 20:1-20:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{doty_et_al:LIPIcs.DISC.2024.20,
author = {Doty, David and Heckmann, Ben},
title = {{The Computational Power of Discrete Chemical Reaction Networks with Bounded Executions}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {20:1--20:15},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.20},
URN = {urn:nbn:de:0030-drops-212469},
doi = {10.4230/LIPIcs.DISC.2024.20},
annote = {Keywords: chemical reaction networks, population protocols, stable computation}
}
Document
Broadcast and Consensus in Stochastic Dynamic Networks with Byzantine Nodes and Adversarial Edges
Abstract
Broadcast and Consensus are most fundamental tasks in distributed computing. These tasks are particularly challenging in dynamic networks where communication across the network links may be unreliable, e.g., due to mobility or failures. Over the last years, researchers have derived several impossibility results and high time complexity lower bounds for these tasks. Specifically for the setting where in each round of communication the adversary is allowed to choose one rooted tree along which the information is disseminated, there is a lower as well as an upper bound that is linear in the number n of nodes for Broadcast and for n ≥ 3 the adversary can guarantee that Consensus never happens. This setting is called the oblivious message adversary for rooted trees. Also note that if the adversary is allowed to choose a graph that does not contain a rooted tree, then it can guarantee that Broadcast and Consensus will never happen.
However, such deterministic adversarial models may be overly pessimistic, as many processes in real-world settings are stochastic in nature rather than worst-case.
This paper studies Broadcast on stochastic dynamic networks and shows that the situation is very different to the deterministic case. In particular, we show that if information dissemination occurs along random rooted trees and directed Erdős–Rényi graphs, Broadcast completes in O(log n) rounds of communication with high probability. The fundamental insight in our analysis is that key variables are mutually independent.
We then study two adversarial models, (a) one with Byzantine nodes and (b) one where an adversary controls the edges. (a) Our techniques without Byzantine nodes are general enough so that they can be extended to Byzantine nodes. (b) In the spirit of smoothed analysis, we introduce the notion of randomized oblivious message adversary, where in each round, an adversary picks k ≤ 2n/3 edges to appear in the communication network, and then a graph (e.g. rooted tree or directed Erdős–Rényi graph) is chosen uniformly at random among the set of all such graphs that include these edges. We show that Broadcast completes in a finite number of rounds, which is, e.g., O(k+log n) rounds in rooted trees.
We then extend these results to All-to-All Broadcast, and Consensus, and give lower bounds that show that most of our upper bounds are tight.
Cite as
Antoine El-Hayek, Monika Henzinger, and Stefan Schmid. Broadcast and Consensus in Stochastic Dynamic Networks with Byzantine Nodes and Adversarial Edges. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 21:1-21:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{elhayek_et_al:LIPIcs.DISC.2024.21,
author = {El-Hayek, Antoine and Henzinger, Monika and Schmid, Stefan},
title = {{Broadcast and Consensus in Stochastic Dynamic Networks with Byzantine Nodes and Adversarial Edges}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {21:1--21:15},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.21},
URN = {urn:nbn:de:0030-drops-212476},
doi = {10.4230/LIPIcs.DISC.2024.21},
annote = {Keywords: Broadcast, Smoothed Analysis, Stochastic Networks, Dynamic Networks}
}
Document
On the Power of Graphical Reconfigurable Circuits
Abstract
We introduce the graphical reconfigurable circuits (GRC) model as an abstraction for distributed graph algorithms whose communication scheme is based on local mechanisms that collectively construct long-range reconfigurable channels (this is an extension to general graphs of a distributed computational model recently introduced by Feldmann et al. (JCB 2022) for hexagonal grids). The crux of the GRC model lies in its modest assumptions: (1) the individual nodes are computationally weak, with state space bounded independently of any global graph parameter; and (2) the reconfigurable communication channels are highly restrictive, only carrying information-less signals (a.k.a. beeps). Despite these modest assumptions, we prove that GRC algorithms can solve many important distributed tasks efficiently, i.e., in polylogarithmic time. On the negative side, we establish various runtime lower bounds, proving that for other tasks, GRC algorithms (if they exist) are doomed to be slow.
Cite as
Yuval Emek, Yuval Gil, and Noga Harlev. On the Power of Graphical Reconfigurable Circuits. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 22:1-22:16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{emek_et_al:LIPIcs.DISC.2024.22,
author = {Emek, Yuval and Gil, Yuval and Harlev, Noga},
title = {{On the Power of Graphical Reconfigurable Circuits}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {22:1--22:16},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.22},
URN = {urn:nbn:de:0030-drops-212487},
doi = {10.4230/LIPIcs.DISC.2024.22},
annote = {Keywords: graphical reconfigurable circuits, bounded uniformity, beeping}
}
Document
Lock-Free Augmented Trees
Abstract
Augmenting an existing sequential data structure with extra information to support greater functionality is a widely used technique. For example, search trees are augmented to build sequential data structures like order-statistic trees, interval trees, tango trees, link/cut trees and many others. We study how to design concurrent augmented tree data structures. We present a new, general technique that can augment a lock-free tree to add any new fields to each tree node, provided the new fields' values can be computed from information in the node and its children. This enables the design of lock-free, linearizable analogues of a wide variety of classical augmented data structures.
As a first example, we give a wait-free trie that stores a set S of elements drawn from {0,…,N-1} and supports linearizable order-statistic queries such as finding the kth smallest element of S. Updates and queries take O(log N) steps. We also apply our technique to a lock-free binary search tree (BST), where changes to the structure of the tree make the linearization argument more challenging. Our augmented BST supports order statistic queries in O(h) steps on a tree of height h. The augmentation does not affect the asymptotic step complexity of the updates. As an added bonus, our technique supports arbitrary multi-point queries (such as range queries) with the same step complexity as they would have in the corresponding sequential data structure. For both our trie and BST, we give an alternative augmentation to improve searches and order-statistic queries to run in O(log |S|) steps (at the cost of increasing step complexity of updates by a factor of O(log|S|)).
Cite as
Panagiota Fatourou and Eric Ruppert. Lock-Free Augmented Trees. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 23:1-23:24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{fatourou_et_al:LIPIcs.DISC.2024.23,
author = {Fatourou, Panagiota and Ruppert, Eric},
title = {{Lock-Free Augmented Trees}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {23:1--23:24},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.23},
URN = {urn:nbn:de:0030-drops-212499},
doi = {10.4230/LIPIcs.DISC.2024.23},
annote = {Keywords: shared-memory, data structure, tree, binary search tree, augmentation, linearizable, lock-free, order statistic, snapshot}
}
Document
Decentralized Distributed Graph Coloring II: Degree+1-Coloring Virtual Graphs
Abstract
Graph coloring is fundamental to distributed computing. We give the first general treatment of the coloring of virtual graphs, where the graph H to be colored is locally embedded within the communication graph G. Besides generalizing classical distributed graph coloring (where H = G), this captures other previously studied settings, including cluster graphs and power graphs.
We find that the complexity of coloring a virtual graph depends linearly on the edge congestion of its embedding. The main question of interest is how fast we can color virtual graphs of constant congestion. We find that, surprisingly, these graphs can be colored nearly as fast as ordinary graphs. Namely, we give a O(log⁴log n)-round algorithm for the deg+1-coloring problem, where each node is assigned more colors than its degree.
This can be viewed as a case where a distributed graph problem can be solved even when the operation of each node is decentralized.
Cite as
Maxime Flin, Magnús M. Halldórsson, and Alexandre Nolin. Decentralized Distributed Graph Coloring II: Degree+1-Coloring Virtual Graphs. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 24:1-24:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{flin_et_al:LIPIcs.DISC.2024.24,
author = {Flin, Maxime and Halld\'{o}rsson, Magn\'{u}s M. and Nolin, Alexandre},
title = {{Decentralized Distributed Graph Coloring II: Degree+1-Coloring Virtual Graphs}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {24:1--24:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.24},
URN = {urn:nbn:de:0030-drops-212502},
doi = {10.4230/LIPIcs.DISC.2024.24},
annote = {Keywords: Graph Coloring, Distributed Algorithms, Virtual Graphs, Congestion, Dilation}
}
Document
Distributed Model Checking on Graphs of Bounded Treedepth
Abstract
We establish that every monadic second-order logic (MSO) formula on graphs with bounded treedepth is decidable in a constant number of rounds within the CONGEST model. To our knowledge, this marks the first meta-theorem regarding distributed model-checking. Various optimization problems on graphs are expressible in MSO. Examples include determining whether a graph G has a clique of size k, whether it admits a coloring with k colors, whether it contains a graph H as a subgraph or minor, or whether terminal vertices in G could be connected via vertex-disjoint paths. Our meta-theorem significantly enhances the work of Bousquet et al. [PODC 2022], which was focused on distributed certification of MSO on graphs with bounded treedepth. Moreover, our results can be extended to solving optimization and counting problems expressible in MSO, in graphs of bounded treedepth.
Cite as
Fedor V. Fomin, Pierre Fraigniaud, Pedro Montealegre, Ivan Rapaport, and Ioan Todinca. Distributed Model Checking on Graphs of Bounded Treedepth. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 25:1-25:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{fomin_et_al:LIPIcs.DISC.2024.25,
author = {Fomin, Fedor V. and Fraigniaud, Pierre and Montealegre, Pedro and Rapaport, Ivan and Todinca, Ioan},
title = {{Distributed Model Checking on Graphs of Bounded Treedepth}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {25:1--25:20},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.25},
URN = {urn:nbn:de:0030-drops-212513},
doi = {10.4230/LIPIcs.DISC.2024.25},
annote = {Keywords: proof-labeling schemes, local computing, CONGEST model}
}
Document
Content-Oblivious Leader Election on Rings
Abstract
In content-oblivious computation, n nodes wish to compute a given task over an asynchronous network that suffers from an extremely harsh type of noise, which corrupts the content of all messages across all channels. In a recent work, Censor-Hillel, Cohen, Gelles, and Sela (Distributed Computing, 2023) showed how to perform arbitrary computations in a content-oblivious way in 2-edge connected networks but only if the network has a distinguished node (called root) to initiate the computation.
Our goal is to remove this assumption, which was conjectured to be necessary. Achieving this goal essentially reduces to performing a content-oblivious leader election since an elected leader can then serve as the root required to perform arbitrary content-oblivious computations. We focus on ring networks, which are the simplest 2-edge connected graphs. On oriented rings, we obtain a leader election algorithm with message complexity O(n ⋅ ID_max), where ID_max is the maximal assigned ID. As it turns out, this dependency on ID_max is inherent: we show a lower bound of Ω(n log(ID_max/n)) messages for content-oblivious leader election algorithms. We also extend our results to non-oriented rings, where nodes cannot tell which channel leads to which neighbor. In this case, however, the algorithm does not terminate but only reaches quiescence.
Cite as
Fabian Frei, Ran Gelles, Ahmed Ghazy, and Alexandre Nolin. Content-Oblivious Leader Election on Rings. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 26:1-26:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{frei_et_al:LIPIcs.DISC.2024.26,
author = {Frei, Fabian and Gelles, Ran and Ghazy, Ahmed and Nolin, Alexandre},
title = {{Content-Oblivious Leader Election on Rings}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {26:1--26:20},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.26},
URN = {urn:nbn:de:0030-drops-212527},
doi = {10.4230/LIPIcs.DISC.2024.26},
annote = {Keywords: Content-Oblivious Computation, Faulty Communication, Leader Election, Ring Networks, Ring Orientation}
}
Document
Sorting in One and Two Rounds Using t-Comparators
Abstract
We examine sorting algorithms for n elements whose basic operation is comparing t elements simultaneously (a t-comparator). We focus on algorithms that use only a single round or two rounds - comparisons performed in the second round depend on the outcomes of the first round comparators. Algorithms with a small number of rounds are well-suited to distributed settings in which communication rounds are costly.
We design deterministic and randomized algorithms. In the deterministic case, we show an interesting relation to design theory (namely, to 2-Steiner systems), which yields a single-round optimal algorithm for n = t^{2^k} with any k ≥ 1 and a variety of possible values of t. For some values of t, however, no algorithm can reach the optimal (information-theoretic) bound on the number of comparators. For this case (and any other n and t), we show an algorithm that uses at most three times as many comparators as the theoretical bound.
We also design a randomized Las-Vegas two-round sorting algorithm for any n and t. Our algorithm uses an asymptotically optimal number of O(max(n^{3/2}/t²,n/t)) comparators, with high probability, i.e., with probability at least 1-1/n. The analysis of this algorithm involves the gradual unveiling of randomness, using a novel technique which we coin the binary tree of deferred randomness.
Cite as
Ran Gelles, Zvi Lotker, and Frederik Mallmann-Trenn. Sorting in One and Two Rounds Using t-Comparators. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 27:1-27:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{gelles_et_al:LIPIcs.DISC.2024.27,
author = {Gelles, Ran and Lotker, Zvi and Mallmann-Trenn, Frederik},
title = {{Sorting in One and Two Rounds Using t-Comparators}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {27:1--27:20},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.27},
URN = {urn:nbn:de:0030-drops-212539},
doi = {10.4230/LIPIcs.DISC.2024.27},
annote = {Keywords: Sorting, Steiner-System, Round Complexity, Deferred Randomness}
}
Document
Self-Stabilizing MIS Computation in the Beeping Model
Abstract
We consider self-stabilizing algorithms to compute a Maximal Independent Set (MIS) in the extremely weak beeping communication model. The model consists of an anonymous network with synchronous rounds. In each round, each vertex can optionally transmit a signal to all its neighbors (beep). After the transmission of a signal, each vertex can only differentiate between no signal received, or at least one signal received. We also consider an extension of this model where vertices can transmit signals through two distinguishable beeping channels. We assume that vertices have some knowledge about the topology of the network.
We revisit the not self-stabilizing algorithm proposed by Jeavons, Scott, and Xu (2013), which computes an MIS in the beeping model. We enhance this algorithm to be self-stabilizing, and explore three different variants, which differ in the knowledge about the topology available to the vertices and the number of beeping channels. In the first variant, every vertex knows an upper bound on the maximum degree Δ of the graph. For this case, we prove that the proposed self-stabilizing version maintains the same run-time as the original algorithm, i.e., it stabilizes after O(log n) rounds w.h.p. on any n-vertex graph. In the second variant, each vertex only knows an upper bound on its own degree. For this case, we prove that the algorithm stabilizes after O(log n⋅ log log n) rounds on any n-vertex graph, w.h.p. In the third variant, we consider the model with two beeping channels, where every vertex knows an upper bound of the maximum degree of the nodes in the 1-hop neighborhood. We prove that this variant stabilizes w.h.p. after O(log n) rounds.
Cite as
George Giakkoupis, Volker Turau, and Isabella Ziccardi. Self-Stabilizing MIS Computation in the Beeping Model. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 28:1-28:21, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{giakkoupis_et_al:LIPIcs.DISC.2024.28,
author = {Giakkoupis, George and Turau, Volker and Ziccardi, Isabella},
title = {{Self-Stabilizing MIS Computation in the Beeping Model}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {28:1--28:21},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.28},
URN = {urn:nbn:de:0030-drops-212540},
doi = {10.4230/LIPIcs.DISC.2024.28},
annote = {Keywords: Maximal Independent Set, Self-Stabilization, Beeping Model}
}
Document
Massively Parallel Ruling Set Made Deterministic
Abstract
We study the deterministic complexity of the 2-Ruling Set problem in the model of Massively Parallel Computation (MPC) with linear and strongly sublinear local memory.
- Linear MPC: We present a constant-round deterministic algorithm for the 2-Ruling Set problem that matches the randomized round complexity recently settled by Cambus, Kuhn, Pai, and Uitto [DISC'23], and improves upon the deterministic O(log log n)-round algorithm by Pai and Pemmaraju [PODC'22]. Our main ingredient is a simpler analysis of CKPU’s algorithm based solely on bounded independence, which makes its efficient derandomization possible.
- Sublinear MPC: We present a deterministic algorithm that computes a 2-Ruling Set in Õ(√{log n}) rounds deterministically. Notably, this is the first deterministic ruling set algorithm with sublogarithmic round complexity, improving on the O(log Δ + log log^* n)-round complexity that stems from the deterministic MIS algorithm of Czumaj, Davies, and Parter [TALG'21]. Our result is based on a simple and fast randomness-efficient construction that achieves the same sparsification as that of the randomized Õ(√{log n})-round LOCAL algorithm by Kothapalli and Pemmaraju [FSTTCS'12].
Cite as
Jeff Giliberti and Zahra Parsaeian. Massively Parallel Ruling Set Made Deterministic. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 29:1-29:21, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{giliberti_et_al:LIPIcs.DISC.2024.29,
author = {Giliberti, Jeff and Parsaeian, Zahra},
title = {{Massively Parallel Ruling Set Made Deterministic}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {29:1--29:21},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.29},
URN = {urn:nbn:de:0030-drops-212551},
doi = {10.4230/LIPIcs.DISC.2024.29},
annote = {Keywords: deterministic algorithms, distributed computing, massively parallel computation, graph algorithms, derandomization}
}
Document
Granular Synchrony
Abstract
Today’s mainstream network timing models for distributed computing are synchrony, partial synchrony, and asynchrony. These models are coarse-grained and often make either too strong or too weak assumptions about the network. This paper introduces a new timing model called granular synchrony that models the network as a mixture of synchronous, partially synchronous, and asynchronous communication links. The new model is not only theoretically interesting but also more representative of real-world networks. It also serves as a unifying framework where current mainstream models are its special cases. We present necessary and sufficient conditions for solving crash and Byzantine fault-tolerant consensus in granular synchrony. Interestingly, consensus among n parties can be achieved against f ≥ n/2 crash faults or f ≥ n/3 Byzantine faults without resorting to full synchrony.
Cite as
Neil Giridharan, Ittai Abraham, Natacha Crooks, Kartik Nayak, and Ling Ren. Granular Synchrony. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 30:1-30:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{giridharan_et_al:LIPIcs.DISC.2024.30,
author = {Giridharan, Neil and Abraham, Ittai and Crooks, Natacha and Nayak, Kartik and Ren, Ling},
title = {{Granular Synchrony}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {30:1--30:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.30},
URN = {urn:nbn:de:0030-drops-212566},
doi = {10.4230/LIPIcs.DISC.2024.30},
annote = {Keywords: Timing model, synchrony, asynchrony, consensus, blockchain, fault tolerance}
}
Document
Distributed Delta-Coloring Under Bandwidth Limitations
Abstract
We consider the problem of coloring graphs of maximum degree Δ with Δ colors in the distributed setting with limited bandwidth. Specifically, we give a polylog log n-round randomized algorithm in the CONGEST model. This is close to the lower bound of Ω(log log n) rounds from [Brandt et al., STOC '16], which holds also in the more powerful LOCAL model. The core of our algorithm is a reduction to several special instances of the constructive Lovász local lemma (LLL) and the deg+1-list coloring problem.
Cite as
Magnús M. Halldórsson and Yannic Maus. Distributed Delta-Coloring Under Bandwidth Limitations. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 31:1-31:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{halldorsson_et_al:LIPIcs.DISC.2024.31,
author = {Halld\'{o}rsson, Magn\'{u}s M. and Maus, Yannic},
title = {{Distributed Delta-Coloring Under Bandwidth Limitations}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {31:1--31:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.31},
URN = {urn:nbn:de:0030-drops-212572},
doi = {10.4230/LIPIcs.DISC.2024.31},
annote = {Keywords: Graph problems, Graph coloring, Lov\'{a}sz local lemma, LOCAL model, CONGEST model, Distributed computing}
}
Document
Quantum Byzantine Agreement Against Full-Information Adversary
Abstract
We exhibit that, when given a classical Byzantine agreement protocol designed in the private-channel model, it is feasible to construct a quantum agreement protocol that can effectively handle a full-information adversary. Notably, both protocols have equivalent levels of resilience, round complexity, and communication complexity. In the classical private-channel scenario, participating players are limited to exchanging classical bits, with the adversary lacking knowledge of the exchanged messages. In contrast, in the quantum full-information setting, participating players can exchange qubits, while the adversary possesses comprehensive and accurate visibility into the system’s state and messages. By showcasing the reduction from quantum to classical frameworks, this paper demonstrates the strength and flexibility of quantum protocols in addressing security challenges posed by adversaries with increased visibility. It underscores the potential of leveraging quantum principles to improve security measures without compromising on efficiency or resilience.
By applying our reduction, we demonstrate quantum advantages in the round complexity of asynchronous Byzantine agreement protocols in the full-information model. It is well known that in the full-information model, any classical protocol requires Ω(n) rounds to solve Byzantine agreement with probability one even against Fail-stop adversary when resilience t = Θ(n) [Attiya and Censor, 2008]. We show that quantum protocols can achieve O(1) rounds (i) with resilience t < n/2 against a Fail-stop adversary, and (ii) with resilience t < n/(3+ε) against a Byzantine adversary for any constant ε > 0, therefore surpassing the classical lower bound.
Cite as
Longcheng Li, Xiaoming Sun, and Jiadong Zhu. Quantum Byzantine Agreement Against Full-Information Adversary. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 32:1-32:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{li_et_al:LIPIcs.DISC.2024.32,
author = {Li, Longcheng and Sun, Xiaoming and Zhu, Jiadong},
title = {{Quantum Byzantine Agreement Against Full-Information Adversary}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {32:1--32:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.32},
URN = {urn:nbn:de:0030-drops-212582},
doi = {10.4230/LIPIcs.DISC.2024.32},
annote = {Keywords: Byzantine agreement, Quantum computation, Full-information model}
}
Document
Communication Requirements for Linearizable Registers
Abstract
While linearizability is a fundamental correctness condition for distributed systems, ensuring the linearizability of implementations can be quite complex. An essential aspect of linearizable implementations of concurrent objects is the need to preserve the real-time order of operations. In many settings, however, processes cannot determine the precise timing and relative real-time ordering of operations. Indeed, in an asynchronous system, the only ordering information available to them is based on the fact that sending a message precedes its delivery. We show that as a result, message chains must be used extensively to ensure linearizability. This paper studies the communication requirements of linearizable implementations of atomic registers in asynchronous message passing systems. We start by proving two general theorems that relate message chains to the ability to delay and reorder actions and operations in an execution of an asynchronous system, without the changes being noticeable to the processes. These are then used to prove that linearizable register implementations must create extensive message chains among operations of all types. In particular, our results imply that linearizable implementations in asynchronous systems are necessarily costly and nontrivial, and provide insight into their structure.
Cite as
Raïssa Nataf and Yoram Moses. Communication Requirements for Linearizable Registers. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 33:1-33:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{nataf_et_al:LIPIcs.DISC.2024.33,
author = {Nataf, Ra\"{i}ssa and Moses, Yoram},
title = {{Communication Requirements for Linearizable Registers}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {33:1--33:17},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.33},
URN = {urn:nbn:de:0030-drops-212593},
doi = {10.4230/LIPIcs.DISC.2024.33},
annote = {Keywords: linearizability, atomic registers, asynchrony, message chains, real time}
}
Document
Single Bridge Formation in Self-Organizing Particle Systems
Abstract
Local interactions of uncoordinated individuals produce the collective behaviors of many biological systems, inspiring much of the current research in programmable matter. A striking example is the spontaneous assembly of fire ants into "bridges" comprising their own bodies to traverse obstacles and reach sources of food. Experiments and simulations suggest that, remarkably, these ants always form one bridge - instead of multiple, competing bridges - despite a lack of central coordination. We argue that the reliable formation of a single bridge does not require sophistication on behalf of the individuals by provably reproducing this behavior in a self-organizing particle system. We show that the formation of a single bridge by the particles is a statistical inevitability of their preferences to move in a particular direction, such as toward a food source, and their preference for more neighbors. Two parameters, η and β, reflect the strengths of these preferences and determine the Gibbs stationary measure of the corresponding particle system’s Markov chain dynamics. We show that a single bridge almost certainly forms when η and β are sufficiently large. Our proof introduces an auxiliary Markov chain, called an "occupancy chain," that captures only the significant, global changes to the system. Through the occupancy chain, we abstract away information about the motion of individual particles, but we gain a more direct means of analyzing their collective behavior. Such abstractions provide a promising new direction for understanding many other systems of programmable matter.
Cite as
Shunhao Oh, Joseph L. Briones, Jacob Calvert, Noah Egan, Dana Randall, and Andréa W. Richa. Single Bridge Formation in Self-Organizing Particle Systems. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 34:1-34:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{oh_et_al:LIPIcs.DISC.2024.34,
author = {Oh, Shunhao and Briones, Joseph L. and Calvert, Jacob and Egan, Noah and Randall, Dana and Richa, Andr\'{e}a W.},
title = {{Single Bridge Formation in Self-Organizing Particle Systems}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {34:1--34:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.34},
URN = {urn:nbn:de:0030-drops-212606},
doi = {10.4230/LIPIcs.DISC.2024.34},
annote = {Keywords: Self-organizing particle systems, programmable matter, bridging, jump chain}
}
Document
Memory Lower Bounds and Impossibility Results for Anonymous Dynamic Broadcast
Abstract
Broadcast is a ubiquitous distributed computing problem that underpins many other system tasks. In static, connected networks, it was recently shown that broadcast is solvable without any node memory and only constant-size messages in worst-case asymptotically optimal time (Hussak and Trehan, PODC'19/STACS'20/DC'23). In the dynamic setting of adversarial topology changes, however, existing algorithms rely on identifiers, port labels, or polynomial memory to solve broadcast and compute functions over node inputs. We investigate space-efficient, terminating broadcast algorithms for anonymous, synchronous, 1-interval connected dynamic networks and introduce the first memory lower bounds in this setting. Specifically, we prove that broadcast with termination detection is impossible for idle-start algorithms (where only the broadcaster can initially send messages) and otherwise requires Ω(log n) memory per node, where n is the number of nodes in the network. Even if the termination condition is relaxed to stabilizing termination (eventually no additional messages are sent), we show that any idle-start algorithm must use ω(1) memory per node, separating the static and dynamic settings for anonymous broadcast. This lower bound is not far from optimal, as we present an algorithm that solves broadcast with stabilizing termination using 𝒪(log n) memory per node in worst-case asymptotically optimal time. In sum, these results reveal the necessity of non-constant memory for nontrivial terminating computation in anonymous dynamic networks.
Cite as
Garrett Parzych and Joshua J. Daymude. Memory Lower Bounds and Impossibility Results for Anonymous Dynamic Broadcast. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 35:1-35:18, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{parzych_et_al:LIPIcs.DISC.2024.35,
author = {Parzych, Garrett and Daymude, Joshua J.},
title = {{Memory Lower Bounds and Impossibility Results for Anonymous Dynamic Broadcast}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {35:1--35:18},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.35},
URN = {urn:nbn:de:0030-drops-212615},
doi = {10.4230/LIPIcs.DISC.2024.35},
annote = {Keywords: Dynamic networks, anonymity, broadcast, space complexity, lower bounds, termination detection, stabilizing termination}
}
Document
Connectivity Labeling in Faulty Colored Graphs
Abstract
Fault-tolerant connectivity labelings are schemes that, given an n-vertex graph G = (V,E) and a parameter f, produce succinct yet informative labels for the elements of the graph. Given only the labels of two vertices u,v and of the elements in a faulty-set F with |F| ≤ f, one can determine if u,v are connected in G-F, the surviving graph after removing F. For the edge or vertex faults models, i.e., F ⊆ E or F ⊆ V, a sequence of recent work established schemes with poly(f,log n)-bit labels for general graphs. This paper considers the color faults model, recently introduced in the context of spanners [Petruschka, Sapir and Tzalik, ITCS '24], which accounts for known correlations between failures. Here, the edges (or vertices) of the input G are arbitrarily colored, and the faulty elements in F are colors; a failing color causes all edges (vertices) of that color to crash. While treating color faults by naïvly applying solutions for many failing edges or vertices is inefficient, the known correlations could potentially be exploited to provide better solutions.
Our main contribution is settling the label length complexity for connectivity under one color fault (f = 1). The existing implicit solution, by black-box application of the state-of-the-art scheme for edge faults of [Dory and Parter, PODC '21], might yield labels of Ω(n) bits. We provide a deterministic scheme with labels of Õ(√n) bits in the worst case, and a matching lower bound. Moreover, our scheme is universally optimal: even schemes tailored to handle only colorings of one specific graph topology (i.e., may store the topology "for free") cannot produce asymptotically smaller labels. We characterize the optimal length by a new graph parameter bp(G) called the ball packing number. We further extend our labeling approach to yield a routing scheme avoiding a single forbidden color, with routing tables of size Õ(bp(G)) bits. We also consider the centralized setting, and show an Õ(n)-space oracle, answering connectivity queries under one color fault in Õ(1) time. Curiously, by our results, no oracle with such space can be evenly distributed as labels.
Turning to f ≥ 2 color faults, we give a randomized labeling scheme with Õ(n^{1-1/2^f})-bit labels, along with a lower bound of Ω(n^{1-1/(f+1)}) bits. For f = 2, we make partial improvement by providing labels of Õ(diam(G)√n) bits, and show that this scheme is (nearly) optimal when diam(G) = Õ(1).
Additionally, we present a general reduction from the above all-pairs formulation of fault-tolerant connectivity labeling (in any fault model) to the single-source variant, which could also be applicable for centralized oracles, streaming, or dynamic algorithms.
Cite as
Asaf Petruschka, Shay Spair, and Elad Tzalik. Connectivity Labeling in Faulty Colored Graphs. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 36:1-36:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{petruschka_et_al:LIPIcs.DISC.2024.36,
author = {Petruschka, Asaf and Spair, Shay and Tzalik, Elad},
title = {{Connectivity Labeling in Faulty Colored Graphs}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {36:1--36:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.36},
URN = {urn:nbn:de:0030-drops-212622},
doi = {10.4230/LIPIcs.DISC.2024.36},
annote = {Keywords: Labeling schemes, Fault-tolerance}
}
Document
Sing a Song of Simplex
Abstract
We flesh out some details of the recently proposed Simplex atomic broadcast protocol, and modify it so that leaders disperse blocks in a more communication-efficient fashion. The resulting protocol, called DispersedSimplex, maintains the simplicity and excellent - indeed, optimal - latency characteristics of the original Simplex protocol. We also present a variant that supports "stable leaders". We also suggest a number of practical optimizations and provide concrete performance estimates that take into account not just network latency but also network bandwidth limitations and computational costs.
Cite as
Victor Shoup. Sing a Song of Simplex. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 37:1-37:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{shoup:LIPIcs.DISC.2024.37,
author = {Shoup, Victor},
title = {{Sing a Song of Simplex}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {37:1--37:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.37},
URN = {urn:nbn:de:0030-drops-212649},
doi = {10.4230/LIPIcs.DISC.2024.37},
annote = {Keywords: Consensus, Atomic broadcast, Blockchain}
}
Document
Near-Linear Time Dispersion of Mobile Agents
Abstract
Consider that there are k ≤ n agents in a simple, connected, and undirected graph G = (V,E) with n nodes and m edges. The goal of the dispersion problem is to move these k agents to mutually distinct nodes. Agents can communicate only when they are at the same node, and no other communication means, such as whiteboards, are available. We assume that the agents operate synchronously. We consider two scenarios: when all agents are initially located at a single node (rooted setting) and when they are initially distributed over one or more nodes (general setting). Kshemkalyani and Sharma presented a dispersion algorithm for the general setting, which uses O(m_k) time and log(k + Δ) bits of memory per agent [OPODIS 2021], where m_k is the maximum number of edges in any induced subgraph of G with k nodes, and Δ is the maximum degree of G. This algorithm is currently the fastest in the literature, as no o(m_k)-time algorithm has been discovered, even for the rooted setting. In this paper, we present significantly faster algorithms for both the rooted and the general settings. First, we present an algorithm for the rooted setting that solves the dispersion problem in O(klog min(k,Δ)) = O(klog k) time using O(log (k+Δ)) bits of memory per agent. Next, we propose an algorithm for the general setting that achieves dispersion in O(k log k ⋅ log min(k,Δ)) = O(k log² k) time using O(log (k+Δ)) bits. Finally, for the rooted setting, we give a time-optimal (i.e., O(k)-time) algorithm with O(Δ+log k) bits of space per agent. All algorithms presented in this paper work only in the synchronous setting, while several algorithms in the literature, including the one given by Kshemkalyani and Sharma at OPODIS 2021, work in the asynchronous setting.
Cite as
Yuichi Sudo, Masahiro Shibata, Junya Nakamura, Yonghwan Kim, and Toshimitsu Masuzawa. Near-Linear Time Dispersion of Mobile Agents. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 38:1-38:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{sudo_et_al:LIPIcs.DISC.2024.38,
author = {Sudo, Yuichi and Shibata, Masahiro and Nakamura, Junya and Kim, Yonghwan and Masuzawa, Toshimitsu},
title = {{Near-Linear Time Dispersion of Mobile Agents}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {38:1--38:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.38},
URN = {urn:nbn:de:0030-drops-212658},
doi = {10.4230/LIPIcs.DISC.2024.38},
annote = {Keywords: mobile agents, autonomous robots, dispersion}
}
Document
The Power of Abstract MAC Layer: A Fault-Tolerance Perspective
Abstract
This paper studies the power of the "abstract MAC layer" model in a single-hop asynchronous network. The model captures primitive properties of modern wireless MAC protocols. In this model, Newport [PODC '14] proves that it is impossible to achieve deterministic consensus when nodes may crash. Subsequently, Newport and Robinson [DISC '18] present randomized consensus algorithms that terminate with O(n³ log n) expected broadcasts in a system of n nodes. We are not aware of any results on other fault-tolerant distributed tasks in this model.
We first study the computability aspect of the abstract MAC layer. We present a wait-free algorithm that implements an atomic register. Furthermore, we show that in general, k-set consensus is impossible. Second, we aim to minimize storage complexity. Existing algorithms require Ω(n log n) bits. We propose two wait-free approximate consensus and two wait-free randomized binary consensus algorithms that only need constant storage complexity (except for the phase index). One randomized algorithm terminates with O(n log n) expected broadcasts. All our algorithms are anonymous, meaning that at the algorithm level, nodes do not need to have a unique identifier.
Cite as
Qinzi Zhang and Lewis Tseng. The Power of Abstract MAC Layer: A Fault-Tolerance Perspective. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 39:1-39:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{zhang_et_al:LIPIcs.DISC.2024.39,
author = {Zhang, Qinzi and Tseng, Lewis},
title = {{The Power of Abstract MAC Layer: A Fault-Tolerance Perspective}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {39:1--39:22},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.39},
URN = {urn:nbn:de:0030-drops-212677},
doi = {10.4230/LIPIcs.DISC.2024.39},
annote = {Keywords: Abstract MAC Layer, Computation Power, Consensus}
}
Document
Brief Announcement
Brief Announcement: Distributed Maximum Flow in Planar Graphs
Abstract
The dual of a planar graph G is a planar graph G^* that has a vertex for each face of G and an edge for each pair of adjacent faces of G. The profound relationship between a planar graph and its dual has been the algorithmic basis for solving numerous (centralized) classical problems on planar graphs involving distances, flows, and cuts. In the distributed setting however, the only use of planar duality is for finding a recursive decomposition of G [DISC 2017, STOC 2019].
In this paper, we extend the distributed algorithmic toolkit (such as recursive decompositions and minor-aggregations) to work on the dual graph G^*. These tools can then facilitate various algorithms on G by solving a suitable dual problem on G^*. Given a directed planar graph G with hop-diameter D, our key result is an Õ(D²)-round algorithm for Single Source Shortest Paths on G^*, which then implies an Õ(D²)-round algorithm for Maximum st-Flow on G. Prior to our work, no Õ(Poly(D))-round algorithm was known for Maximum st-Flow. We further obtain a D⋅ n^o(1)-rounds (1+ε)-approximation algorithm for Maximum st-Flow on G when G is undirected and s and t lie on the same face. Finally, we give a near optimal Õ(D)-round algorithm for computing the weighted girth of G.
The main challenges in our work are that G^* is not the communication graph (e.g., a vertex of G is mapped to multiple vertices of G^*), and that the diameter of G^* can be much larger than D (i.e., possibly by a linear factor). We overcome these challenges by carefully defining and maintaining subgraphs of the dual graph G^* while applying the recursive decomposition on the primal graph G. The main technical difficulty, is that along the recursive decomposition, a face of G gets shattered into (disconnected) components yet we still need to treat it as a dual node.
Cite as
Yaseen Abd-Elhaleem, Michal Dory, Merav Parter, and Oren Weimann. Brief Announcement: Distributed Maximum Flow in Planar Graphs. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 40:1-40:8, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{abdelhaleem_et_al:LIPIcs.DISC.2024.40,
author = {Abd-Elhaleem, Yaseen and Dory, Michal and Parter, Merav and Weimann, Oren},
title = {{Brief Announcement: Distributed Maximum Flow in Planar Graphs}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {40:1--40:8},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.40},
URN = {urn:nbn:de:0030-drops-212687},
doi = {10.4230/LIPIcs.DISC.2024.40},
annote = {Keywords: Maximum flow, shortest paths, planar graphs, distributed computing}
}
Document
Brief Announcement
Brief Announcement: Towards Optimal Communication Byzantine Reliable Broadcast Under a Message Adversary
Abstract
We address the problem of Reliable Broadcast in asynchronous message-passing systems with n nodes, of which up to t are malicious (faulty), in addition to a message adversary that can drop some of the messages sent by correct (non-faulty) nodes. We present a Message-Adversary-Tolerant Byzantine Reliable Broadcast (MBRB) algorithm that communicates an almost optimal amount of O(|m|+n²κ) bits per node, where |m| represents the length of the application message and κ = Ω(log n) is a security parameter. This improves upon the state-of-the-art MBRB solution (Albouy, Frey, Raynal, and Taïani, TCS 2023), which incurs communication of O(n|m|+n²κ) bits per node. Our solution sends at most 4n² messages overall, which is asymptotically optimal. Reduced communication is achieved by employing coding techniques that replace the need for all nodes to (re-)broadcast the entire application message m. Instead, nodes forward authenticated fragments of the encoding of m using an erasure-correcting code. Under the cryptographic assumptions of PKI and collision-resistant hash, and assuming n > 3t+2d, where the adversary drops at most d messages per broadcast, our algorithm allows at least 𝓁 = n - t - (1 + ε)d (for any ε > 0) correct nodes to reconstruct m, despite missing fragments caused by the malicious nodes and the message adversary.
Cite as
Timothé Albouy, Davide Frey, Ran Gelles, Carmit Hazay, Michel Raynal, Elad Michael Schiller, François Taïani, and Vassilis Zikas. Brief Announcement: Towards Optimal Communication Byzantine Reliable Broadcast Under a Message Adversary. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 41:1-41:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{albouy_et_al:LIPIcs.DISC.2024.41,
author = {Albouy, Timoth\'{e} and Frey, Davide and Gelles, Ran and Hazay, Carmit and Raynal, Michel and Schiller, Elad Michael and Ta\"{i}ani, Fran\c{c}ois and Zikas, Vassilis},
title = {{Brief Announcement: Towards Optimal Communication Byzantine Reliable Broadcast Under a Message Adversary}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {41:1--41:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.41},
URN = {urn:nbn:de:0030-drops-212697},
doi = {10.4230/LIPIcs.DISC.2024.41},
annote = {Keywords: Asynchronous message-passing, Byzantine fault-tolerance, Message adversary, Reliable Broadcast}
}
Document
Brief Announcement
Brief Announcement: Solvability of Three-Process General Tasks
Abstract
The topological view on distributed computing represents a task T as a relation Δ between the complex ℐ of its inputs and the complex 𝒪 of its outputs. A cornerstone result in the field is an elegant computability characterization of the solvability of colorless tasks in terms of ℐ, 𝒪 and Δ. Essentially, a colorless task is wait-free solvable if and only if there is a continuous map from the geometric realization of ℐ to that of 𝒪 that respects Δ.
This paper makes headway towards providing an analogous characterization for general tasks, which are not necessarily colorless, by concentrating on the case of three-process inputless tasks. Our key contribution is identifying local articulation points as an obstacle for the solvability of general tasks, and defining a topological deformation on the output complex of a task T, which eliminates these points by splitting them, to obtain a new task T', with an adjusted relation Δ' between the input complex ℐ and an output complex 𝒪' without articulation points. We obtain a new characterization of wait-free solvability of three-process general tasks: T is wait-free solvable if and only if there is a continuous map from the geometric realization of ℐ to that of 𝒪' that respects Δ'.
Cite as
Hagit Attiya, Pierre Fraigniaud, Ami Paz, and Sergio Rajsbaum. Brief Announcement: Solvability of Three-Process General Tasks. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 42:1-42:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{attiya_et_al:LIPIcs.DISC.2024.42,
author = {Attiya, Hagit and Fraigniaud, Pierre and Paz, Ami and Rajsbaum, Sergio},
title = {{Brief Announcement: Solvability of Three-Process General Tasks}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {42:1--42:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.42},
URN = {urn:nbn:de:0030-drops-212700},
doi = {10.4230/LIPIcs.DISC.2024.42},
annote = {Keywords: Wait-free computing, lower bounds, topology}
}
Document
Brief Announcement
Brief Announcement: Unifying Partial Synchrony
Abstract
The distributed computing literature considers multiple options for modeling communication. Most simply, communication is categorized as either synchronous or asynchronous. Synchronous communication assumes that messages get delivered within a publicly known timeframe and that parties' clocks are synchronized. Asynchronous communication, on the other hand, only assumes that messages get delivered eventually. A more nuanced approach, or a middle ground between the two extremes, is given by the partially synchronous model, which is arguably the most realistic option. This model comes in two commonly considered flavors:
ii) The Global Stabilization Time (GST) model: after an (unknown) amount of time, the network becomes synchronous. This captures scenarios where network issues are transient.
iii) The Unknown Latency (UL) model: the network is, in fact, synchronous, but the message delay bound is unknown. This work formally establishes that any time-agnostic property that can be achieved by a protocol in the UL model can also be achieved by a (possibly different) protocol in the GST model. By time-agnostic, we mean properties that can depend on the order in which events happen but not on time as measured by the parties. Most properties considered in distributed computing are time-agnostic. The converse was already known, even without the time-agnostic requirement, so our result shows that the two network conditions are, under one sensible assumption, equally demanding.
Cite as
Andrei Constantinescu, Diana Ghinea, Jakub Sliwinski, and Roger Wattenhofer. Brief Announcement: Unifying Partial Synchrony. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 43:1-43:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{constantinescu_et_al:LIPIcs.DISC.2024.43,
author = {Constantinescu, Andrei and Ghinea, Diana and Sliwinski, Jakub and Wattenhofer, Roger},
title = {{Brief Announcement: Unifying Partial Synchrony}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {43:1--43:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.43},
URN = {urn:nbn:de:0030-drops-212717},
doi = {10.4230/LIPIcs.DISC.2024.43},
annote = {Keywords: partial synchrony, unknown latency, global stabilization time}
}
Document
Brief Announcement
Brief Announcement: The Expressive Power of Uniform Population Protocols with Logarithmic Space
Abstract
Population protocols are a model of computation in which indistinguishable mobile agents interact in pairs to decide a property of their initial configuration. Originally introduced by Angluin et. al. in 2004 with a constant number of states, research nowadays focuses on protocols where the space usage depends on the number of agents. The expressive power of population protocols has so far however only been determined for protocols using o(log n) states, which compute only semilinear predicates, and for Ω(n) states. This leaves a significant gap, particularly concerning protocols with Θ(log n) or Θ(polylog n) states, which are the most common constructions in the literature. In this paper we close the gap and prove that for any ε > 0 and f ∈ Ω(log n) ∩ 𝒪(n^{1-ε}), both uniform and non-uniform population protocols with Θ(f(n)) states can decide exactly NSPACE(f(n) log n).
Cite as
Philipp Czerner, Vincent Fischer, and Roland Guttenberg. Brief Announcement: The Expressive Power of Uniform Population Protocols with Logarithmic Space. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 44:1-44:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{czerner_et_al:LIPIcs.DISC.2024.44,
author = {Czerner, Philipp and Fischer, Vincent and Guttenberg, Roland},
title = {{Brief Announcement: The Expressive Power of Uniform Population Protocols with Logarithmic Space}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {44:1--44:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.44},
URN = {urn:nbn:de:0030-drops-212726},
doi = {10.4230/LIPIcs.DISC.2024.44},
annote = {Keywords: Population Protocols, Uniform, Expressive Power}
}
Document
Brief Announcement
Brief Announcement: Best-Possible Unpredictable Proof-Of-Stake
Abstract
The proof-of-stake (PoS) protocols aim to reduce the unnecessary computing power waste seen in Bitcoin. Various practical and provably secure designs have been proposed, like Ouroboros Praos (Eurocrypt 2018) and Snow White (FC 2019). However, the essential security property of unpredictability in these protocols remains insufficiently explored. This paper delves into this property in the cryptographic setting to achieve the "best possible" unpredictability for PoS.
We first present an impossibility result for all PoS protocols under the single-extension design framework, where each honest player extends one chain per round. The state-of-the-art permissionless PoS protocols (e.g., Praos, Snow White, and more), are all under this single-extension framework. Our impossibility result states that, if a single-extension PoS protocol achieves the best possible unpredictability, then this protocol cannot be proven secure unless more than 73% of stake is honest. To overcome this impossibility, we introduce a new design framework called multi-extension PoS, allowing each honest player to extend multiple chains using a greedy strategy in a round. This strategy allows us to construct a class of PoS protocols that achieve the best possible unpredictability. It is noteworthy that these protocols can be proven secure, assuming a much smaller fraction (e.g., 57%) of stake to be honest.
Cite as
Lei Fan, Jonathan Katz, Zhenghao Lu, Phuc Thai, and Hong-Sheng Zhou. Brief Announcement: Best-Possible Unpredictable Proof-Of-Stake. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 45:1-45:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{fan_et_al:LIPIcs.DISC.2024.45,
author = {Fan, Lei and Katz, Jonathan and Lu, Zhenghao and Thai, Phuc and Zhou, Hong-Sheng},
title = {{Brief Announcement: Best-Possible Unpredictable Proof-Of-Stake}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {45:1--45:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.45},
URN = {urn:nbn:de:0030-drops-212731},
doi = {10.4230/LIPIcs.DISC.2024.45},
annote = {Keywords: blockchain, consensus, proof-of-stake, unpredictability}
}
Document
Brief Announcement
Brief Announcement: Optimal Uniform Circle Formation by Asynchronous Luminous Robots
Abstract
We study the Uniform Circle Formation (UCF) problem for a swarm of n autonomous mobile robots operating in Look-Compute-Move (LCM) cycles on the Euclidean plane. We assume our robots are luminous, i.e. equipped with a persistent light that can assume a color chosen from a fixed palette, and opaque, i.e. not able to see beyond a collinear robot. Robots are said to collide if they share positions or their paths intersect within concurrent LCM cycles. To solve UCF, a swarm of n robots must autonomously arrange themselves so that each robot occupies a vertex of the same regular n-gon not fixed in advance. In terms of efficiency, the goal is to design an algorithm that optimizes (or provides a tradeoff between) two fundamental performance metrics: (i) the execution time and (ii) the size of the color palette.
In this paper, we develop a deterministic algorithm solving UCF avoiding collisions in O(1)-time with O(1) colors under the asynchronous scheduler, which is asymptotically optimal with respect to both time and number of colors used, the first such result. Furthermore, the algorithm proposed here minimizes for the first time what we call the computational SEC, i.e. the smallest circular area where robots operate throughout the whole algorithm.
Cite as
Caterina Feletti, Debasish Pattanayak, and Gokarna Sharma. Brief Announcement: Optimal Uniform Circle Formation by Asynchronous Luminous Robots. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 46:1-46:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{feletti_et_al:LIPIcs.DISC.2024.46,
author = {Feletti, Caterina and Pattanayak, Debasish and Sharma, Gokarna},
title = {{Brief Announcement: Optimal Uniform Circle Formation by Asynchronous Luminous Robots}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {46:1--46:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.46},
URN = {urn:nbn:de:0030-drops-212748},
doi = {10.4230/LIPIcs.DISC.2024.46},
annote = {Keywords: Uniform Circle Formation, Robots with Lights, Autonomous Robots, Rank Encoding, Time and Color Complexities, Computational SEC}
}
Document
Brief Announcement
Brief Announcement: Agreement Tasks in Fault-Prone Synchronous Networks of Arbitrary Structures
Abstract
Consensus is arguably the most studied problem in distributed computing as a whole, and particularly in distributed message-passing settings. Research on consensus has considered various failure types, memory constraints, and much more. Surprisingly, almost all of this work assumes that messages are passed in a complete network, i.e., each process has a direct link to every other process. Set agreement, a relaxed variant of consensus, has also been heavily studied in different settings, yet research on it has also been limited to complete networks. We address this situation by considering consensus and set agreement in general networks, i.e., that can have an arbitrary graph G as their communication graph. We focus on fault-prone networks, where up to t nodes may crash and irrevocably stop communicating, and present upper and lower bounds for such networks. We establish the following collection of results:
- The consensus algorithm by [Castañeda et al., 2023] is optimal for all graphs, and not only for symmetric graphs.
- This algorithm can be extended to a generic algorithm for k-set agreement, for every k ≥ 1. For k = 1, our generic algorithm coincides with the existing one for consensus.
- All these algorithms can be extended to the case where the number t of failures exceeds the connectivity κ of the graph, while the existing consensus algorithm assumed that t < κ.
Cite as
Pierre Fraigniaud, Minh Hang Nguyen, and Ami Paz. Brief Announcement: Agreement Tasks in Fault-Prone Synchronous Networks of Arbitrary Structures. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 47:1-47:5, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{fraigniaud_et_al:LIPIcs.DISC.2024.47,
author = {Fraigniaud, Pierre and Nguyen, Minh Hang and Paz, Ami},
title = {{Brief Announcement: Agreement Tasks in Fault-Prone Synchronous Networks of Arbitrary Structures}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {47:1--47:5},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.47},
URN = {urn:nbn:de:0030-drops-212755},
doi = {10.4230/LIPIcs.DISC.2024.47},
annote = {Keywords: Consensus, set-agreement, fault tolerance, crash failures}
}
Document
Brief Announcement
Brief Announcement: Distinct Gathering Under Round Robin
Abstract
We resolve one of the longest-standing questions about autonomous mobile robots in a surprising way.
Distinct Gathering is the fundamental cooperation task of letting robots, initially scattered across the plane in distinct locations, gather in an arbitrary single point. The scheduler Round Robin cyclically activates the robots one by one in a fixed order. When activated, a robot perceives all robot locations and moves wherever it wants based only on this information. For n = 2 robots, the task is trivial. What happens for n ≥ 3 has remained an open problem for decades by now. The established conjecture declares the task to be impossible in this case. We prove that it is indeed impossible for n = 3 but, to great surprise, possible again for any n ≥ 4. We go beyond the standard requirements by providing a very robust algorithm that does not require any consistency or self-consistency for the local Cartesian maps perceived by the robots and works even for non-rigid movement, that is, if robots may be unpredictably stopped and deactivated during a movement.
Cite as
Fabian Frei and Koichi Wada. Brief Announcement: Distinct Gathering Under Round Robin. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 48:1-48:8, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{frei_et_al:LIPIcs.DISC.2024.48,
author = {Frei, Fabian and Wada, Koichi},
title = {{Brief Announcement: Distinct Gathering Under Round Robin}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {48:1--48:8},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.48},
URN = {urn:nbn:de:0030-drops-212768},
doi = {10.4230/LIPIcs.DISC.2024.48},
annote = {Keywords: Autonomous mobile robots, Distinct Gathering, Round Robin}
}
Document
Brief Announcement
Brief Announcement: Decreasing Verification Radius in Local Certification
Abstract
This paper deals with local certification, specifically locally checkable proofs: given a graph property, the task is to certify whether a graph satisfies the property. The verification of this certification needs to be done locally without the knowledge of the whole graph.
We examine the trade-off between the visibility radius and the size of certificates. We describe a procedure that decreases the radius by encoding the neighbourhood of each vertex into its certificate. We also provide a corresponding lower bound on the required certificate size increase, showing that such an approach is close to optimal.
Cite as
Jan Matyáš Křišťan and Josef Erik Sedláček. Brief Announcement: Decreasing Verification Radius in Local Certification. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 49:1-49:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{kristan_et_al:LIPIcs.DISC.2024.49,
author = {K\v{r}i\v{s}\v{t}an, Jan Maty\'{a}\v{s} and Sedl\'{a}\v{c}ek, Josef Erik},
title = {{Brief Announcement: Decreasing Verification Radius in Local Certification}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {49:1--49:6},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.49},
URN = {urn:nbn:de:0030-drops-212773},
doi = {10.4230/LIPIcs.DISC.2024.49},
annote = {Keywords: Local certification, locally checkable proofs, proof-labeling schemes, graphs, distributed computing}
}
Document
Brief Announcement
Brief Announcement: Agent-Based Leader Election, MST, and Beyond
Abstract
Leader election is one of the fundamental and well-studied problems in distributed computing. In this paper, we initiate the study of leader election using mobile agents. Suppose n agents are positioned initially arbitrarily on the nodes of an arbitrary, anonymous, n-node, m-edge graph G. The agents relocate themselves autonomously on the nodes of G and elect an agent as a leader such that the leader agent knows it is a leader and the other agents know they are not leaders. The objective is to minimize time and memory requirements. Following the literature, we consider the synchronous setting in which each agent performs its operations synchronously with others and hence the time complexity can be measured in rounds. The quest in this paper is to provide solutions without agents knowing any graph parameter, such as n, a priori. We first establish that, without agents knowing any graph parameter a priori, there exists a deterministic algorithm to elect an agent as a leader in O(m) rounds with O(nlog n) bits at each agent. Using this leader election result, we develop a deterministic algorithm for agents to construct a minimum spanning tree of G in O(m+nlog n) rounds using O(n log n) bits memory at each agent, without agents knowing any graph parameter a priori. Finally, using the same leader election result, we provide improved time/memory results for other fundamental distributed graph problems, namely, gathering, maximal independent set, and minimal dominating sets, removing the assumptions on agents knowing graph parameters a priori.
Cite as
Ajay D. Kshemkalyani, Manish Kumar, Anisur Rahaman Molla, and Gokarna Sharma. Brief Announcement: Agent-Based Leader Election, MST, and Beyond. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 50:1-50:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{kshemkalyani_et_al:LIPIcs.DISC.2024.50,
author = {Kshemkalyani, Ajay D. and Kumar, Manish and Molla, Anisur Rahaman and Sharma, Gokarna},
title = {{Brief Announcement: Agent-Based Leader Election, MST, and Beyond}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {50:1--50:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.50},
URN = {urn:nbn:de:0030-drops-212782},
doi = {10.4230/LIPIcs.DISC.2024.50},
annote = {Keywords: Distributed algorithms, mobile agents, local communication, leader election, MST, MIS, gathering, minimal dominating sets, time and memory complexity, graph parameters}
}
Document
Brief Announcement
Brief Announcement: Clock Distribution with Gradient TRIX
Abstract
Gradient clock synchronisation (GCS) algorithms minimise the worst-case clock offset between the nodes in a distributed network of diameter D and size n. They achieve optimal offsets of Θ(log D) locally, i.e. between adjacent nodes [Lenzen et al., 2010], and Θ(D) globally [Biaz and Welch, 2001]. A key open problem in this area is to achieve fault tolerance at minimal overhead in terms of the number of edges.
In this work, we achieve this goal under the assumption of an average-case distribution of faults, i.e., nodes fail with independent probability p ∈ o(n^{-1/2}). In more detail, we present a self-stabilising GCS algorithm for a grid-like directed graph with in- and out-degrees of 3. Note that even for tolerating a single fault, this degree is necessary. Moreover, the failure probability p is the largest possible ensuring the necessary condition that for each node at most one in-neighbour fails with probability 1-o(1). Our algorithm achieves asymptotically optimal local skew of Θ(log D) with probability 1-o(1); this holds under general worst-case assumptions on link delay and clock speed variations, provided they change slowly relative to the speed of the system.
On the one hand, our results are of practical interest. As we discuss with care, the fault model is suitable for synchronously clocked hardware. Since our algorithm can simultaneously sustain a constant number of arbitrary changes due to faults in each clock cycle, it achieves sufficient robustness to dramatically increase the size of synchronously clocked Systems-on-Chip.
On the other hand, our result is of a theoretical and algorithmic nature. We show that for a worst-case distribution of f 1-local faulty nodes within our fault model’s locality constraints, our algorithm achieves a local skew of O(5^flog D), while for our model with probabilistic distribution of faults the algorithm achieves O(log D). Our work raises questions for further theoretical investigation on techniques for fault tolerance and trade-offs between fault distribution and edge density of graphs.
Cite as
Christoph Lenzen and Shreyas Srinivas. Brief Announcement: Clock Distribution with Gradient TRIX. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 51:1-51:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{lenzen_et_al:LIPIcs.DISC.2024.51,
author = {Lenzen, Christoph and Srinivas, Shreyas},
title = {{Brief Announcement: Clock Distribution with Gradient TRIX}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {51:1--51:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.51},
URN = {urn:nbn:de:0030-drops-212791},
doi = {10.4230/LIPIcs.DISC.2024.51},
annote = {Keywords: local skew, gradient clock synchronisation, average-case fault-tolerance, self-stabilisation, Systems-on-Chip}
}
Document
Brief Announcement
Brief Announcement: Reconfigurable Heterogeneous Quorum Systems
Abstract
In contrast to proof-of-work replication, Byzantine quorum systems maintain consistency across replicas with higher throughput, modest energy consumption, and deterministic liveness guarantees. If complemented with heterogeneous trust and open membership, they have the potential to serve as blockchains backbone. This paper presents a general model of heterogeneous quorum systems where each participant can declare its own quorums, and captures the consistency, availability and inclusion properties of these systems. In order to support open membership, it then presents reconfiguration protocols for heterogeneous quorum systems including joining and leaving of a process, and adding and removing of a quorum, and further, proves their correctness in the face of Byzantine attacks. The design of the protocols is informed by the trade-offs that the paper proves for the properties that reconfigurations can preserve. The paper further presents a graph characterization of heterogeneous quorum systems, and its application for reconfiguration optimization.
Cite as
Xiao Li and Mohsen Lesani. Brief Announcement: Reconfigurable Heterogeneous Quorum Systems. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 52:1-52:8, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{li_et_al:LIPIcs.DISC.2024.52,
author = {Li, Xiao and Lesani, Mohsen},
title = {{Brief Announcement: Reconfigurable Heterogeneous Quorum Systems}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {52:1--52:8},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.52},
URN = {urn:nbn:de:0030-drops-212804},
doi = {10.4230/LIPIcs.DISC.2024.52},
annote = {Keywords: Quorum Systems, Reconfiguration, Heterogeneity}
}
Document
Brief Announcement
Brief Announcement: Concurrent Aggregate Queries
Abstract
Concurrent data structures serve as fundamental building blocks for concurrent computing. Many concurrent counterparts have been designed for basic sequential algorithms; however, one notable omission is a concurrent tree that supports aggregate queries. Aggregate queries essentially compile succinct information about a range of data items. Such queries play an essential role in various applications and are commonly taught in undergraduate data structures courses. In this paper, we formalize a type of aggregate queries that can be efficiently supported by concurrent trees and present a design for implementing these queries on concurrent lock-based trees. We present two algorithms implementing this design, where one optimizes for tree update time, while the other optimizes for aggregate query time.
Cite as
Gal Sela and Erez Petrank. Brief Announcement: Concurrent Aggregate Queries. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 53:1-53:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{sela_et_al:LIPIcs.DISC.2024.53,
author = {Sela, Gal and Petrank, Erez},
title = {{Brief Announcement: Concurrent Aggregate Queries}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {53:1--53:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.53},
URN = {urn:nbn:de:0030-drops-212819},
doi = {10.4230/LIPIcs.DISC.2024.53},
annote = {Keywords: Concurrent Algorithms, Concurrent Data Structures, Aggregate queries, Range queries, Binary Search Tree, Linearizability}
}
Document
Brief Announcement
Brief Announcement: Colorless Tasks and Extension-Based Proofs
Abstract
The concept of extension-based proofs models the idea of a valency argument, which is widely used in distributed computing. Extension-based proofs are limited in power: it has been shown that there is no extension-based proof of the impossibility of a wait-free protocol for (n,k)-set agreement among n > k ≥ 2 processes. There are only a few tasks that have been proven to have no extension-based proof of the impossibility, since the techniques in these works are closely related to the specific task.
We give a necessary and sufficient condition for colorless tasks to have no extension-based proofs of the impossibility of wait-free protocols in the NIIS model. We introduce a general adversarial strategy decoupled from any concrete task specification. In this strategy, some properties of the chromatic subdivision that is widely used in distributed computing are proved.
Cite as
Yusong Shi and Weidong Liu. Brief Announcement: Colorless Tasks and Extension-Based Proofs. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 54:1-54:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{shi_et_al:LIPIcs.DISC.2024.54,
author = {Shi, Yusong and Liu, Weidong},
title = {{Brief Announcement: Colorless Tasks and Extension-Based Proofs}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {54:1--54:6},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.54},
URN = {urn:nbn:de:0030-drops-212821},
doi = {10.4230/LIPIcs.DISC.2024.54},
annote = {Keywords: Colorless tasks, Impossibility proofs, Extension-based proof}
}
Document
Brief Announcement
Brief Announcement: Self-Stabilizing Graph Exploration by a Single Agent
Abstract
In this paper, we present two self-stabilizing algorithms that enable a single (mobile) agent to explore graphs. The agent visits all nodes starting from any configuration, i.e., regardless of the initial state of the agent, the initial states of all nodes, and the initial location of the agent. We evaluate the algorithms using two metrics: cover time, which is the number of moves required to visit all nodes, and memory usage, which includes the storage needed for the state of the agent and the state of each node. The first algorithm is randomized. Given an integer c = Ω(n), the cover time of this algorithm is optimal, i.e., O(m) in expectation, and the memory requirements for the agent and each node v are O(log c) and O(log (c+δ_v)) bits, respectively, where n and m are the numbers of nodes and edges, respectively, and δ_v is the degree of v. The second algorithm is deterministic. It requires an input integer k ≥ max(D,δ_max), where D and δ_max are the diameter and the maximum degree of the graph, respectively. The cover time of this algorithm is O(m + nD), and it uses O(log k) bits both for agent memory and each node.
Cite as
Yuichi Sudo, Fukuhito Ooshita, and Sayaka Kamei. Brief Announcement: Self-Stabilizing Graph Exploration by a Single Agent. In 38th International Symposium on Distributed Computing (DISC 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 319, pp. 55:1-55:7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)
Copy BibTex To Clipboard
@InProceedings{sudo_et_al:LIPIcs.DISC.2024.55,
author = {Sudo, Yuichi and Ooshita, Fukuhito and Kamei, Sayaka},
title = {{Brief Announcement: Self-Stabilizing Graph Exploration by a Single Agent}},
booktitle = {38th International Symposium on Distributed Computing (DISC 2024)},
pages = {55:1--55:7},
series = {Leibniz International Proceedings in Informatics (LIPIcs)},
ISBN = {978-3-95977-352-2},
ISSN = {1868-8969},
year = {2024},
volume = {319},
editor = {Alistarh, Dan},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2024.55},
URN = {urn:nbn:de:0030-drops-212832},
doi = {10.4230/LIPIcs.DISC.2024.55},
annote = {Keywords: mobile agents, self-stabilization, graph exploration}
}