eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
1
702
10.4230/LIPIcs.OPODIS.2023
article
LIPIcs, Volume 286, OPODIS 2023, Complete Volume
Bessani, Alysson
1
https://orcid.org/0000-0002-8386-1628
Défago, Xavier
2
https://orcid.org/0000-0002-2377-205X
Nakamura, Junya
3
https://orcid.org/0000-0002-1363-4358
Wada, Koichi
4
https://orcid.org/0000-0002-5351-1459
Yamauchi, Yukiko
5
https://orcid.org/0009-0009-8459-6676
University of Lisbon, Portugal
Tokyo Institute of Technology, Japan
Toyohashi University of Technology, Japan
Hosei University, Japan
Kyushu University, Japan
LIPIcs, Volume 286, OPODIS 2023, Complete Volume
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023/LIPIcs.OPODIS.2023.pdf
LIPIcs, Volume 286, OPODIS 2023, Complete Volume
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
0:i
0:xvi
10.4230/LIPIcs.OPODIS.2023.0
article
Front Matter, Table of Contents, Preface, Conference Organization
Bessani, Alysson
1
https://orcid.org/0000-0002-8386-1628
Défago, Xavier
2
https://orcid.org/0000-0002-2377-205X
Nakamura, Junya
3
https://orcid.org/0000-0002-1363-4358
Wada, Koichi
4
https://orcid.org/0000-0002-5351-1459
Yamauchi, Yukiko
5
https://orcid.org/0009-0009-8459-6676
University of Lisbon, Portugal
Tokyo Institute of Technology, Japan
Toyohashi University of Technology, Japan
Hosei University, Japan
Kyushu University, Japan
Front Matter, Table of Contents, Preface, Conference Organization
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.0/LIPIcs.OPODIS.2023.0.pdf
Front Matter
Table of Contents
Preface
Conference Organization
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
1:1
1:2
10.4230/LIPIcs.OPODIS.2023.1
article
From Consensus Research to Redbelly Network Pty Ltd (Invited Talk)
Gramoli, Vincent
1
2
https://orcid.org/0000-0001-5632-8572
University of Sydney, Australia
Redbelly Network, Sydney, Australia
Designing and implementing correctly a blockchain system requires collaborations across places and research fields. Redbelly, a company across Australia, India and USA, illustrates well this idea.
It started in 2005 at OPODIS, where we published the Reconfigurable Distributed Storage to replace distributed participants offering a service without disrupting its availability. This line of work [V. Gramoli et al., 2021] was instrumental to reconfigure blockchains without introducing hard forks. The research on the consensus problem we initiated at IRISA [V. Gramoli, 2022] led to rethinking PBFT-like algorithms for the context of blockchain by getting rid of the leader that can act as the bottleneck of large networks [V. Gramoli and Q. Tang, 2023]. Our work on security led to disclosing vulnerabilities in Ethereum [Parinya Ekparinya et al., 2020] and then motivated us to formally verify blockchain consensus [Nathalie Bertrand et al., 2022]. Our work at the frontier of economics [Michael Spain et al., 2019] led us to prevent front-running attacks [Pouriya Zarbafian and Vincent Gramoli, 2023] and to incentivize rational players to behave [Alejandro Ranchal-Pedrosa and Vincent Gramoli, 2022]. Our system work at Cornell and then at EPFL was foundational in experimenting blockchains across the globe [Vincent Gramoli et al., 2023].
Although not anticipated at the time, this series of work progressively led the University of Sydney and CSIRO, and later Redbelly Network Pty Ltd, to design the Redbelly Blockchain [Tyler Crain et al., 2021; Deepal Tennakoon et al., 2023], the platform of choice for compliant asset tokenisation.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.1/LIPIcs.OPODIS.2023.1.pdf
Innovations
Commercialisation
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
2:1
2:1
10.4230/LIPIcs.OPODIS.2023.2
article
Quantum Distributed Computing: Potential and Limitations (Invited Talk)
Le Gall, François
1
https://orcid.org/0000-0003-3721-6553
Graduate School of Mathematics, Nagoya University, Japan
The subject of this talk is quantum distributed computing, i.e., distributed computing where the processors of the network can exchange quantum messages. In the first part of the talk I survey recent results [Taisuke Izumi and François Le Gall, 2019; Taisuke Izumi et al., 2020; François Le Gall and Frédéric Magniez, 2018; François Le Gall et al., 2019; Xudong Wu and Penghui Yao, 2022] and some older results [Michael Ben-Or and Avinatan Hassidim, 2005; Seiichiro Tani et al., 2012] that show the potential of quantum distributed algorithms. In the second part I present our recent work [Xavier Coiteux-Roy et al., 2023] showing the limitations of quantum distributed algorithms for approximate graph coloring. Finally, I mention interesting and important open questions in quantum distributed computing.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.2/LIPIcs.OPODIS.2023.2.pdf
Quantum computing
distributed algorithms
CONGEST model
LOCAL model
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
3:1
3:1
10.4230/LIPIcs.OPODIS.2023.3
article
Distributed Algorithms as a Gateway To Deductive Learning (Invited Talk)
Wattenhofer, Roger
1
https://orcid.org/0000-0002-6339-3134
ETH Zurich, Switzerland
With the book Thinking Fast and Slow, Daniel Kahneman popularized the idea that the human brain can think in two different modes. The fast mode is instinctive and automatic, while the slow mode is deliberative and logical. As of 2023, one can argue that machine learning understands how to think fast. Deep neural networks are remarkably successful in rapidly classifying and regressing data. Thinking slow on the other hand is still a mystery. Large language models may provide an illusion of being able to think slow. However, prompts that need multiple deductive steps are generally beyond the capabilities of large language models. Distributed algorithms have the potential to help understanding deductive reasoning. Distributed algorithms usually consist of several little steps, iteratively applied, each step being easily learnable. As such distributed computing may provide an interesting bridge towards understanding deduction, extrapolation, reasoning, and everything else needed to think slow. In the talk, we will discuss some exciting case studies from graph generation to origami folding.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.3/LIPIcs.OPODIS.2023.3.pdf
abstract visual reasoning
agent-based reasoning
classic algorithm benchmarks
differentiable status registers
explainable graphs
graph generation algorithms
integer sequences
neural combinatorial circuits
recurrent network algorithms
origami folding
Tatham’s puzzles
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
4:1
4:23
10.4230/LIPIcs.OPODIS.2023.4
article
The Synchronization Power of Auditable Registers
Attiya, Hagit
1
https://orcid.org/0000-0002-8017-6457
Del Pozzo, Antonella
2
Milani, Alessia
3
Pavloff, Ulysse
2
https://orcid.org/0000-0003-4125-3306
Rapetti, Alexandre
4
https://orcid.org/0009-0008-3151-6495
Technion, Haifa, Israel
Université Paris-Saclay, CEA, List, F-91120, Palaiseau, France
Laboratoire d’Informatique et Systèmes, Aix-Marseille Université and CNRS, Marseille, France
Aix-Marseille Université, Université Paris-Saclay, CEA, List, F-91120, Palaiseau, France
Auditability allows to track all the read operations performed on a register. It abstracts the need of data owners to control access to their data, tracking who read which information. This work considers possible formalizations of auditing and their ramification for the possibility of providing it.
The natural definition is to require a linearization of all write, read and audit operations together (atomic auditing). The paper shows that atomic auditing is a powerful tool, as it can be used to solve consensus. The number of processes that can solve consensus using atomic audit depends on the number of processes that can read or audit the register. If there is a single reader or a single auditor (the writer), then consensus can be solved among two processes. If multiple readers and auditors are possible, then consensus can be solved among the same number of processes. This means that strong synchronization primitives are needed to support atomic auditing.
We give implementations of atomic audit when there are either multiple readers or multiple auditors (but not both) using primitives with consensus number 2 (swap and fetch&add). When there are multiple readers and multiple auditors, the implementation uses compare&swap.
These findings motivate a weaker definition, in which audit operations are not linearized together with read and write operations (regular auditing). We prove that regular auditing can be implemented from ordinary reads and writes on atomic registers.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.4/LIPIcs.OPODIS.2023.4.pdf
Auditability
atomic register
fault tolerance
consensus number
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
5:1
5:21
10.4230/LIPIcs.OPODIS.2023.5
article
𝒪(log{n})-Time Uniform Circle Formation for Asynchronous Opaque Luminous Robots
Feletti, Caterina
1
https://orcid.org/0009-0004-1813-8056
Mereghetti, Carlo
1
https://orcid.org/0000-0002-7778-7257
Palano, Beatrice
1
https://orcid.org/0000-0003-3948-4658
Dipartimento di Informatica, Università degli Studi di Milano, Italy
We study the Uniform Circle Formation (UCF) problem for a distributed system of n robots which are required to displace on the vertices of a regular n-gon. We consider a well-studied model of autonomous, anonymous, mobile robots that act on the plane through Look-Compute-Move cycles. Moreover, robots are unaware of the cardinality of the system, they are punctiform, completely disoriented, opaque, and luminous. Collisions among robots are not tolerated.
In the literature, the UCF problem has been solved for such a model by a deterministic algorithm in the asynchronous mode, using a constant amount of light colors and 𝒪(n) epochs in the worst case. In this paper, we provide an improved algorithm for solving the UCF problem for asynchronous robots, which uses 𝒪(log n) epochs still maintaining a constant amount of colors.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.5/LIPIcs.OPODIS.2023.5.pdf
Autonomous mobile robots
Opaque robots
Luminous robots
Pattern formation
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
6:1
6:23
10.4230/LIPIcs.OPODIS.2023.6
article
Multi-Valued Connected Consensus: A New Perspective on Crusader Agreement and Adopt-Commit
Attiya, Hagit
1
https://orcid.org/0000-0002-8017-6457
Welch, Jennifer L.
2
https://orcid.org/0000-0003-2725-9875
Department of Computer Science, Technion, Haifa, Israel
Department of Computer Science and Engineering, Texas A&M University, College Station, TX, USA
Algorithms to solve fault-tolerant consensus in asynchronous systems often rely on primitives such as crusader agreement, adopt-commit, and graded broadcast, which provide weaker agreement properties than consensus. Although these primitives have a similar flavor, they have been defined and implemented separately in ad hoc ways. We propose a new problem called connected consensus that has as special cases crusader agreement, adopt-commit, and graded broadcast, and generalizes them to handle multi-valued inputs. The generalization is accomplished by relating the problem to approximate agreement on graphs.
We present three algorithms for multi-valued connected consensus in asynchronous message-passing systems, one tolerating crash failures and two tolerating malicious (unauthenticated Byzantine) failures. We extend the definition of binding, a desirable property recently identified as supporting binary consensus algorithms that are correct against adaptive adversaries, to the multi-valued input case and show that all our algorithms satisfy the property. Our crash-resilient algorithm has failure-resilience and time complexity that we show are optimal. When restricted to the case of binary inputs, the algorithm has improved time complexity over prior algorithms. Our two algorithms for malicious failures trade off failure resilience and time complexity. The first algorithm has time complexity that we prove is optimal but worse failure-resilience, while the second has failure-resilience that we prove is optimal but worse time complexity. When restricted to the case of binary inputs, the time complexity (as well as resilience) of the second algorithm matches that of prior algorithms.
The contributions of the paper are first, a deeper insight into the connections between primitives commonly used to solve the fundamental problem of fault-tolerant consensus, and second, implementations of these primitives that can contribute to improved consensus algorithms.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.6/LIPIcs.OPODIS.2023.6.pdf
graded broadcast
gradecast
binding
approximate agreement
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
7:1
7:21
10.4230/LIPIcs.OPODIS.2023.7
article
Energy-Constrained Programmable Matter Under Unfair Adversaries
Weber, Jamison W.
1
https://orcid.org/0000-0002-9573-1783
Chhabra, Tishya
1
https://orcid.org/0000-0002-3555-1078
Richa, Andréa W.
2
https://orcid.org/0000-0003-3592-3756
Daymude, Joshua J.
2
https://orcid.org/0000-0001-7294-5626
School of Computing and Augmented Intelligence, Arizona State University, Tempe, AZ, USA
School of Computing and Augmented Intelligence & Biodesign Center for Biocomputing, Security and Society, Arizona State University, Tempe, AZ, USA
Individual modules of programmable matter participate in their system’s collective behavior by expending energy to perform actions. However, not all modules may have access to the external energy source powering the system, necessitating a local and distributed strategy for supplying energy to modules. In this work, we present a general energy distribution framework for the canonical amoebot model of programmable matter that transforms energy-agnostic algorithms into energy-constrained ones with equivalent behavior and an 𝒪(n²)-round runtime overhead - even under an unfair adversary - provided the original algorithms satisfy certain conventions. We then prove that existing amoebot algorithms for leader election (ICDCN 2023) and shape formation (Distributed Computing, 2023) are compatible with this framework and show simulations of their energy-constrained counterparts, demonstrating how other unfair algorithms can be generalized to the energy-constrained setting with relatively little effort. Finally, we show that our energy distribution framework can be composed with the concurrency control framework for amoebot algorithms (Distributed Computing, 2023), allowing algorithm designers to focus on the simpler energy-agnostic, sequential setting but gain the general applicability of energy-constrained, asynchronous correctness.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.7/LIPIcs.OPODIS.2023.7.pdf
Programmable matter
amoebot model
energy distribution
concurrency
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
8:1
8:20
10.4230/LIPIcs.OPODIS.2023.8
article
A Fair and Resilient Decentralized Clock Network for Transaction Ordering
Constantinescu, Andrei
1
https://orcid.org/0009-0005-1708-9376
Ghinea, Diana
1
https://orcid.org/0000-0002-5294-9459
Heimbach, Lioba
1
https://orcid.org/0000-0002-8258-1712
Wang, Zilin
1
Wattenhofer, Roger
1
https://orcid.org/0000-0002-6339-3134
ETH Zürich, Switzerland
Traditional blockchain design gives miners or validators full control over transaction ordering, i.e., they can freely choose which transactions to include or exclude, as well as in which order. While not an issue initially, the emergence of decentralized finance has introduced new transaction order dependencies allowing parties in control of the ordering to make a profit by front-running others' transactions. In this work, we present the Decentralized Clock Network, a new approach for achieving fair transaction ordering. Users submit their transactions to the network’s clocks, which run an agreement protocol that provides each transaction with a timestamp of receipt which is then used to define the transactions' order. By separating agreement from ordering, our protocol is efficient and has a simpler design compared to other available solutions. Moreover, our protocol brings to the blockchain world the paradigm of asynchronous fallback, where the algorithm operates with stronger fairness guarantees during periods of synchronous use, switching to an asynchronous mode only during times of increased network delay.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.8/LIPIcs.OPODIS.2023.8.pdf
Median Validity
Blockchain
Fair Ordering
Front-running Prevention
Miner Extractable Value
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
9:1
9:16
10.4230/LIPIcs.OPODIS.2023.9
article
Byzantine Consensus in Abstract MAC Layer
Tseng, Lewis
1
https://orcid.org/0000-0002-4717-4038
Sardina, Callie
2
https://orcid.org/0000-0002-7498-2778
Clark University, Worcester, MA, USA
University of California at Santa Barbara, CA, USA
This paper studies the design of Byzantine consensus algorithms in an asynchronous single-hop network equipped with the "abstract MAC layer" [DISC09], which captures core properties of modern wireless MAC protocols. Newport [PODC14], Newport and Robinson [DISC18], and Tseng and Zhang [PODC22] study crash-tolerant consensus in the model. In our setting, a Byzantine faulty node may behave arbitrarily, but it cannot break the guarantees provided by the underlying abstract MAC layer. To our knowledge, we are the first to study Byzantine faults in this model.
We harness the power of the abstract MAC layer to develop a Byzantine approximate consensus algorithm and a Byzantine randomized binary consensus algorithm. Both of our algorithms require only the knowledge of the upper bound on the number of faulty nodes f, and do not require the knowledge of the number of nodes n. This demonstrates the "power" of the abstract MAC layer, as consensus algorithms in traditional message-passing models require the knowledge of both n and f. Additionally, we show that it is necessary to know f in order to reach consensus. Hence, from this perspective, our algorithms require the minimal knowledge.
The lack of knowledge of n brings the challenge of identifying a quorum explicitly, which is a common technique in traditional message-passing algorithms. A key technical novelty of our algorithms is to identify "implicit quorums" which have the necessary information for reaching consensus. The quorums are implicit because nodes do not know the identity of the quorums - such notion is only used in the analysis.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.9/LIPIcs.OPODIS.2023.9.pdf
Byzantine
Randomized Consensus
Approximate Consensus
Abstract MAC
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
10:1
10:22
10.4230/LIPIcs.OPODIS.2023.10
article
Discrete Incremental Voting
Cooper, Colin
1
Radzik, Tomasz
1
https://orcid.org/0000-0002-7776-5461
Shiraga, Takeharu
2
https://orcid.org/0000-0003-1236-9756
Department of Informatics, King’s College, University of London, UK
Department of Information and System Engineering, Faculty of Science and Engineering, Chuo University, Tokyo, Japan
We consider a type of pull voting suitable for discrete numeric opinions which can be compared on a linear scale, for example, 1 ("disagree strongly"), 2 ("disagree"), …, 5 ("agree strongly"). On observing the opinion of a random neighbour, a vertex changes its opinion incrementally towards the value of the neighbour’s opinion, if different. For opinions drawn from a set {1,2,…,k}, the opinion of the vertex would change by +1 if the opinion of the neighbour is larger, or by -1, if it is smaller.
It is not clear how to predict the outcome of this process, but we observe that the total weight of the system, that is, the sum of the individual opinions of all vertices, is a martingale. This allows us analyse the outcome of the process on some classes of dense expanders such as complete graphs K_n and random graphs G_{n,p} for suitably large p. If the average of the original opinions satisfies i ≤ c ≤ i+1 for some integer i, then the asymptotic probability that opinion i wins is i+1-c, and the probability that opinion i+1 wins is c-i. With high probability, the winning opinion cannot be other than i or i+1.
To contrast this, we show that for a path and opinions 0,1,2 arranged initially in non-decreasing order along the path, the outcome is very different. Any of the opinions can win with constant probability, provided that each of the two extreme opinions 0 and 2 is initially supported by a constant fraction of vertices.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.10/LIPIcs.OPODIS.2023.10.pdf
Random distributed processes
Pull voting
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
11:1
11:24
10.4230/LIPIcs.OPODIS.2023.11
article
On the Convergence Time in Graphical Games: A Locality-Sensitive Approach
Hirvonen, Juho
1
2
https://orcid.org/0000-0001-8268-1070
Schmid, Laura
3
Chatterjee, Krishnendu
4
Schmid, Stefan
5
6
Aalto University, Finland
Helsinki Institute for Information Technology (HIIT), Espoo, Finland
Kim Jaechul Graduate School of AI, KAIST, Seoul, Republic of Korea
IST Austria, Klosterneuburg, Austria
TU Berlin, Germany
Weizenbaum Institute, Berlin, Germany
Graphical games are a useful framework for modeling the interactions of (selfish) agents who are connected via an underlying topology and whose behaviors influence each other. They have wide applications ranging from computer science to economics and biology. Yet, even though an agent’s payoff only depends on the actions of their direct neighbors in graphical games, computing the Nash equilibria and making statements about the convergence time of "natural" local dynamics in particular can be highly challenging. In this work, we present a novel approach for classifying complexity of Nash equilibria in graphical games by establishing a connection to local graph algorithms, a subfield of distributed computing. In particular, we make the observation that the equilibria of graphical games are equivalent to locally verifiable labelings (LVL) in graphs; vertex labelings which are verifiable with constant-round local algorithms. This connection allows us to derive novel lower bounds on the convergence time to equilibrium of best-response dynamics in graphical games. Since we establish that distributed convergence can sometimes be provably slow, we also introduce and give bounds on an intuitive notion of "time-constrained" inefficiency of best responses. We exemplify how our results can be used in the implementation of mechanisms that ensure convergence of best responses to a Nash equilibrium. Our results thus also give insight into the convergence of strategy-proof algorithms for graphical games, which is still not well understood.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.11/LIPIcs.OPODIS.2023.11.pdf
distributed computing
Nash equilibria
mechanism design
best-response dynamics
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
12:1
12:22
10.4230/LIPIcs.OPODIS.2023.12
article
Eating Sandwiches: Modular and Lightweight Elimination of Transaction Reordering Attacks
Alpos, Orestis
1
https://orcid.org/0000-0001-5477-3736
Amores-Sesar, Ignacio
1
https://orcid.org/0000-0002-1751-1515
Cachin, Christian
1
https://orcid.org/0000-0001-8967-9213
Yeo, Michelle
2
https://orcid.org/0009-0001-3676-4809
Institute of Computer Science, University of Bern, Switzerland
IST Austria, Klosterneuburg, Austria
Traditional blockchains grant the miner of a block full control not only over which transactions but also their order. This constitutes a major flaw discovered with the introduction of decentralized finance and allows miners to perform MEV attacks. In this paper, we address the issue of sandwich attacks by providing a construction that takes as input a blockchain protocol and outputs a new blockchain protocol with the same security but in which sandwich attacks are not profitable. Furthermore, our protocol is fully decentralized with no trusted third parties or heavy cryptography primitives and carries a linear increase in latency and minimum computation overhead.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.12/LIPIcs.OPODIS.2023.12.pdf
Consensus
MEV
Byzantine behavior
Rational behavior
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
13:1
13:18
10.4230/LIPIcs.OPODIS.2023.13
article
Improved Distributed Algorithms for Random Colorings
Carlson, Charlie
1
Frishberg, Daniel
2
Vigoda, Eric
1
Department of Computer Science, University of California, Santa Barbara, CA, USA
Department of Computer Science and Software Engineering, California Polytechnic State University, San Luis Obispo, CA, USA
Markov Chain Monte Carlo (MCMC) algorithms are a widely-used algorithmic tool for sampling from high-dimensional distributions, a notable example is the equilibirum distribution of graphical models. The Glauber dynamics, also known as the Gibbs sampler, is the simplest example of an MCMC algorithm; the transitions of the chain update the configuration at a randomly chosen coordinate at each step. Several works have studied distributed versions of the Glauber dynamics and we extend these efforts to a more general family of Markov chains. An important combinatorial problem in the study of MCMC algorithms is random colorings. Given a graph G of maximum degree Δ and an integer k ≥ Δ+1, the goal is to generate a random proper vertex k-coloring of G.
Jerrum (1995) proved that the Glauber dynamics has O(nlog{n}) mixing time when k > 2Δ. Fischer and Ghaffari (2018), and independently Feng, Hayes, and Yin (2018), presented a parallel and distributed version of the Glauber dynamics which converges in O(log{n}) rounds for k > (2+ε)Δ for any ε > 0. We improve this result to k > (11/6-δ)Δ for a fixed δ > 0. This matches the state of the art for randomly sampling colorings of general graphs in the sequential setting. Whereas previous works focused on distributed variants of the Glauber dynamics, our work presents a parallel and distributed version of the more general flip dynamics presented by Vigoda (2000) (and refined by Chen, Delcourt, Moitra, Perarnau, and Postle (2019)), which recolors local maximal two-colored components in each step.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.13/LIPIcs.OPODIS.2023.13.pdf
Distributed Graph Algorithms
Local Algorithms
Coloring
Glauber Dynamics
Sampling
Markov Chains
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
14:1
14:16
10.4230/LIPIcs.OPODIS.2023.14
article
Fever: Optimal Responsive View Synchronisation
Lewis-Pye, Andrew
1
Abraham, Ittai
2
London School of Economics, UK
VMWare Research, Herzliya, Israel
View synchronisation is an important component of many modern Byzantine Fault Tolerant State Machine Replication (SMR) systems in the partial synchrony model. Roughly, the efficiency of view synchronisation is measured as the word complexity and latency required for moving from being synchronised in a view of one correct leader to being synchronised in the view of the next correct leader. The efficiency of view synchronisation has emerged as a major bottleneck in the efficiency of SMR systems as a whole. A key question remained open: Do there exist view synchronisation protocols with asymptotically optimal quadratic worst-case word complexity that also obtain linear complexity and responsiveness when moving between consecutive correct leaders?
We answer this question affirmatively with a new view synchronisation protocol for partial synchrony assuming partial initial clock synchronisation, called Fever. If n is the number of processors and t is the largest integer < n/3, then Fever has resilience t, and in all executions with at most 0 ≤ f ≤ t Byzantine parties and network delays of at most δ ≤ Δ after GST (where f and δ are unknown), Fever has worst-case word complexity O(fn+n) and worst-case latency O(Δ f + δ).
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.14/LIPIcs.OPODIS.2023.14.pdf
Distributed Systems
State Machine Replication
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
15:1
15:20
10.4230/LIPIcs.OPODIS.2023.15
article
Nova: Safe Off-Heap Memory Allocation and Reclamation
Fakhoury, Ramy
1
Braginsky, Anastasia
2
Keidar, Idit
1
Zuriel, Yoav
1
Technion, Haifa, Israel
Red Hat Research, Ra'anana, Israel
In recent years, we begin to see Java-based systems embrace off-heap allocation for their big data demands. As of today, these system rely on simple ad-hoc garbage-collection solutions, which restrict the usage of off-heap data. This paper introduces the abstraction of safe off-heap memory allocation and reclamation (SOMAR), a thread-safe memory allocation and reclamation scheme for off-heap data in otherwise managed environments. SOMAR allows multi-threaded Java programs to use off-heap memory seamlessly. To realize this abstraction, we present Nova, Novel Off-heap Versioned Allocator, a lock-free SOMAR implementation. Our experiments show that Nova can be used to store off-heap data in Java data structures with better performance than ones managed by Java’s automatic GC. We further integrate Nova into the open-source Oak concurrent map library, which allows Oak to reclaim keys while the data structure is being accessed.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.15/LIPIcs.OPODIS.2023.15.pdf
memory reclamation
concurrency
performance
off-heap allocation
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
16:1
16:20
10.4230/LIPIcs.OPODIS.2023.16
article
Improved Deterministic Distributed Maximum Weight Independent Set Approximation in Sparse Graphs
Gil, Yuval
1
https://orcid.org/0009-0007-7762-3029
Technion - Israel Institute of Technology, Haifa, Israel
We design new deterministic CONGEST approximation algorithms for maximum weight independent set (MWIS) in sparse graphs. As our main results, we obtain new Δ(1+ε)-approximation algorithms as well as algorithms whose approximation ratio depend strictly on α, in graphs with maximum degree Δ and arboricity α. For (deterministic) Δ(1+ε)-approximation, the current state-of-the-art is due to a recent breakthrough by Faour et al. [SODA 2023] that showed an O(log² (Δ W)⋅ log (1/ε)+log ^{*}n)-round algorithm, where W is the largest node-weight (this bound translates to O(log² n⋅log (1/ε)) under the common assumption that W = poly(n)). As for α-dependent approximations, a deterministic CONGEST (8(1+ε)⋅α)-approximation algorithm with runtime O(log³ n⋅log (1/ε)) can be derived by combining the aforementioned algorithm of Faour et al. with a method presented by Kawarabayashi et al. [DISC 2020]. As our main results, we show the following.
- A deterministic CONGEST algorithm that computes an α^{1+τ}-approximation for MWIS in O(log nlog α) rounds for any constant τ > 0. To the best of our knowledge, this is the fastest runtime of any deterministic non-trivial approximation algorithm for MWIS to date. Furthermore, for the large class of graphs where α = Δ^{1-Θ(1)}, it implies a deterministic Δ^{1-Θ(1)}-approximation algorithm with a runtime of O(log nlog α) which improves upon the result of Faour et al. in both approximation ratio (by a Δ^{Θ(1)} factor) and runtime (by an O(log n/log α) factor).
- A deterministic CONGEST algorithm that computes an O(α)-approximation for MWIS in O(α^{τ}log n) rounds for any (desirably small) constant τ > 0. This improves the runtime of the best known deterministic O(α)-approximation algorithm in the case that α = O(polylog n). This also leads to a deterministic Δ(1+ε)-approximation algorithm with a runtime of O(α^{τ}log nlog (1/ε)) which improves upon the runtime of Faour et al. in the case that α = O(polylog n).
- A deterministic CONGEST algorithm that computes a (⌊(2+ε)α⌋)-approximation for MWIS in O(αlog n) rounds. This improves upon the best known α-dependent approximation ratio by a constant factor.
- A deterministic CONGEST algorithm that computes a 2d²-approximation for MWIS in time O(d²+log ^{*}n) in a directed graph with out-degree at most d. The dependency on n is (asymptotically) optimal due to a lower bound by Czygrinow et al. [DISC 2008] and Lenzen and Wattenhofer [DISC 2008]. We note that a key ingredient to all of our algorithms is a novel deterministic method that computes a high-weight subset of nodes whose induced subgraph is sparse.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.16/LIPIcs.OPODIS.2023.16.pdf
Approximation algorithms
Sparse graphs
The CONGEST model
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
17:1
17:22
10.4230/LIPIcs.OPODIS.2023.17
article
A Wait-Free Deque With Polylogarithmic Step Complexity
Asbell, Shalom M.
1
https://orcid.org/0009-0008-7031-8766
Ruppert, Eric
1
https://orcid.org/0000-0001-5613-8701
Department of Electrical Engineering and Computer Science, York University, Toronto, Canada
The amortized step complexity of operations on all previous lock-free implementations of double-ended queues is linear in the number of processes. This paper presents the first concurrent double-ended queue where the amortized step complexity of each operation is polylogarithmic. Since a stack is a special case of a double-ended queue, this is also the first concurrent stack with polylogarithmic step complexity. The implementation is wait-free and the amortized step complexity is O(log² p + log q) per operation, where p is the number of processes and q is the size of the double-ended queue.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.17/LIPIcs.OPODIS.2023.17.pdf
Lock-Free
Wait-Free
Double-Ended Queue
Deque
Stack
Space-Bounded
Polylogarithmic
Linearizable
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
18:1
18:23
10.4230/LIPIcs.OPODIS.2023.18
article
Reliable Broadcast Despite Mobile Byzantine Faults
Bonomi, Silvia
1
https://orcid.org/0000-0001-9928-5357
Farina, Giovanni
1
https://orcid.org/0000-0002-4792-5305
Tixeuil, Sébastien
2
https://orcid.org/0000-0002-0948-7172
Sapienza University of Rome, Italy
Sorbonne Université, CNRS, LIP6, Institut Universitaire de France, Paris, France
We investigate the solvability of the Byzantine Reliable Broadcast and Byzantine Broadcast Channel problems in distributed systems affected by Mobile Byzantine Faults. We show that both problems are not solvable even in one of the most constrained system models for mobile Byzantine faults defined so far. By endowing processes with an additional local failure oracle, we provide a solution to the Byzantine Broadcast Channel problem.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.18/LIPIcs.OPODIS.2023.18.pdf
Byzantine fault-tolerance
Reliable Broadcast
Mobile Byzantine Faults
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
19:1
19:21
10.4230/LIPIcs.OPODIS.2023.19
article
Probable Approximate Coordination
Livshits, Ariel
1
https://orcid.org/0000-0003-2721-5928
Moses, Yoram
2
https://orcid.org/0000-0001-5549-1781
Yahoo! Research, Haifa, Israel
Technion, Haifa, Israel
We study the problem of how to coordinate the actions of independent agents in a distributed system where message arrival times are unbounded, but are determined by an exponential probability distribution. Asynchronous protocols executed in such a model are guaranteed to succeed with probability 1. We demonstrate a case in which the best asynchronous protocol can be improved on significantly. Specifically, we focus on the task of performing actions by different agents in a linear temporal order - a problem known in the literature as Ordered Response. In asynchronous systems, ensuring such an ordering requires the construction of a message chain that passes through each acting agent, in order. Solving Ordered Response in this way in our model will terminate in time that grows linearly in the number of participating agents n, in expectation. We show that relaxing the specification slightly allows for a significant saving in time. Namely, if Ordered Response should be guaranteed with high probability (arbitrarily close to 1), it is possible to significantly shorten the expected execution time of the protocol. We present two protocols that adhere to the relaxed specification. One of our protocols executes exponentially faster than a message chain, when the number of participating agents n is large, while the other is roughly quadratically faster. For small values of n, it is also possible to achieve similar results by using a hybrid protocol.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.19/LIPIcs.OPODIS.2023.19.pdf
Distributed coordination
ordered response
exponentially distributed delay
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
20:1
20:25
10.4230/LIPIcs.OPODIS.2023.20
article
Flooding with Absorption: An Efficient Protocol for Heterogeneous Bandits over Complex Networks
Lee, Junghyun
1
https://orcid.org/0000-0002-3898-6464
Schmid, Laura
1
https://orcid.org/0000-0002-6978-7329
Yun, Se-Young
1
https://orcid.org/0000-0001-6675-5113
Kim Jaechul Graduate School of AI, KAIST, Seoul, Republic of Korea
Multi-armed bandits are extensively used to model sequential decision-making, making them ubiquitous in many real-life applications such as online recommender systems and wireless networking. We consider a multi-agent setting where each agent solves their own bandit instance endowed with a different set of arms. Their goal is to minimize their group regret while collaborating via some communication protocol over a given network. Previous literature on this problem only considered arm heterogeneity and networked agents separately. In this work, we introduce a setting that encompasses both features. For this novel setting, we first provide a rigorous regret analysis for a standard flooding protocol combined with the classic UCB policy. Then, to mitigate the issue of high communication costs incurred by flooding in complex networks, we propose a new protocol called Flooding with Absorption (FwA). We provide a theoretical analysis of the resulting regret bound and discuss the advantages of using FwA over flooding. Lastly, we experimentally verify on various scenarios, including dynamic networks, that FwA leads to significantly lower communication costs despite minimal regret performance loss compared to other network protocols.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.20/LIPIcs.OPODIS.2023.20.pdf
multi-armed bandits
multi-agent systems
collaborative learning
network protocol
flooding
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
21:1
21:21
10.4230/LIPIcs.OPODIS.2023.21
article
Fault-Tolerant Computing with Unreliable Channels
Naser-Pastoriza, Alejandro
1
2
Chockler, Gregory
3
Gotsman, Alexey
1
IMDEA Software Institute, Madrid, Spain
Universidad Politécnica de Madrid, Spain
University of Surrey, Guildford, UK
We study implementations of basic fault-tolerant primitives, such as consensus and registers, in message-passing systems subject to process crashes and a broad range of communication failures. Our results characterize the necessary and sufficient conditions for implementing these primitives as a function of the connectivity constraints and synchrony assumptions. Our main contribution is a new algorithm for partially synchronous consensus that is resilient to process crashes and channel failures and is optimal in its connectivity requirements. In contrast to prior work, our algorithm assumes the most general model of message loss where faulty channels are flaky, i.e., can lose messages without any guarantee of fairness. This failure model is particularly challenging for consensus algorithms, as it rules out standard solutions based on leader oracles and failure detectors. To circumvent this limitation, we construct our solution using a new variant of the recently proposed view synchronizer abstraction, which we adapt to the crash-prone setting with flaky channels.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.21/LIPIcs.OPODIS.2023.21.pdf
Consensus
network partitions
liveness
synchronizers
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
22:1
22:19
10.4230/LIPIcs.OPODIS.2023.22
article
Local Recurrent Problems in the SUPPORTED Model
Agrawal, Akanksha
1
https://orcid.org/0000-0002-0656-7572
Augustine, John
1
https://orcid.org/0000-0003-0948-3961
Peleg, David
2
https://orcid.org/0000-0003-1590-0506
Ramachandran, Srikkanth
1
https://orcid.org/0000-0003-2392-1999
Indian Institute of Technology Madras, India
Weizmann Institute of Science, Rehovot, Israel
We study the SUPPORTED model of distributed computing introduced by Schmid and Suomela [Schmid and Suomela, 2013], which generalizes the LOCAL and CONGEST models. In this framework, multiple instances of the same problem, differing from each other by the subnetwork to which they apply. recur over time, and need to be solved efficiently online. To do that, one may rely on an initial preprocessing phase for computing some useful information. This preprocessing phase makes it possible, in some cases, to obtain improved distributed algorithms, overcoming locality-based time lower bounds.
Our main contribution is to expand the class of problems to which the SUPPORTED model applies, by handling also multiple recurring instances of the same problem that differ from each other by some problem specific input, and not only the subnetwork to which they apply. We illustrate this by considering two extended problem classes. The first class, denoted PCS, concerns problems where client nodes of the network need to be served, and each recurring instance applies to some Partial Client Set. The second class, denoted PFO, concerns situations where each recurrent instance of the problem includes a partially fixed output, which needs to be completed to a full consistent solution.
Specifically, we propose some natural recurrent variants of the dominating set problem and the coloring problem that are of interest particularly in the distributed setting. For these problems, we show that information about the topology can be used to overcome locality-based lower bounds. We also categorize the round complexity of Locally Checkable Labellings in the SUPPORTED model for the simple case of paths. Finally we present some interesting open problems and some partial results towards resolving them.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.22/LIPIcs.OPODIS.2023.22.pdf
Distributed Algorithms
LOCAL Model
SUPPORTED Model
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
23:1
23:23
10.4230/LIPIcs.OPODIS.2023.23
article
A Holistic Approach for Trustworthy Distributed Systems with WebAssembly and TEEs
Ménétrey, Jämes
1
https://orcid.org/0000-0003-2470-2827
Grüter, Aeneas
2
https://orcid.org/0009-0009-2299-3393
Yuhala, Peterson
1
https://orcid.org/0000-0002-3371-9228
Oeftiger, Julius
2
https://orcid.org/0009-0002-3416-1198
Felber, Pascal
1
https://orcid.org/0000-0003-1574-6721
Pasin, Marcelo
1
https://orcid.org/0000-0002-3064-5315
Schiavoni, Valerio
1
https://orcid.org/0000-0003-1493-6603
University of Neuchâtel, Switzerland
University of Bern, Switzerland
Publish/subscribe systems play a key role in enabling communication between numerous devices in distributed and large-scale architectures. While widely adopted, securing such systems often trades portability for additional integrity and attestation guarantees. Trusted Execution Environments (TEEs) offer a potential solution with enclaves to enhance security and trust. However, application development for TEEs is complex, and many existing solutions are tied to specific TEE architectures, limiting adaptability. Current communication protocols also inadequately manage attestation proofs or expose essential attestation information. This paper introduces a novel approach using WebAssembly to address these issues, a key enabling technology nowadays capturing academia and industry attention. We present the design of a portable and fully attested publish/subscribe middleware system as a holistic approach for trustworthy and distributed communication between various systems. Based on this proposal, we have implemented and evaluated in-depth a fully-fledged publish/subscribe broker running within Intel SGX, compiled in WebAssembly, and built on top of industry-battled frameworks and standards, i.e., MQTT and TLS protocols. Our extended TLS protocol preserves the privacy of attestation information, among other benefits. Our experimental results showcase most overheads, revealing a 1.55× decrease in message throughput when using a trusted broker. We open-source the contributions of this work to the research community to facilitate experimental reproducibility.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.23/LIPIcs.OPODIS.2023.23.pdf
Publish/Subscribe
WebAssembly
Attestation
TLS
Trusted Execution Environment
Cloud-Edge Continuum
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
24:1
24:22
10.4230/LIPIcs.OPODIS.2023.24
article
Recoverable and Detectable Self-Implementations of Swap
Lev Lehman, Tomer
1
Attiya, Hagit
2
https://orcid.org/0000-0002-8017-6457
Hendler, Danny
1
https://orcid.org/0000-0001-7152-7828
Department of Computer Science, Ben Gurion University, Beer Sheva, Israel
Department of Computer Science, Technion, Haifa, Israel
Recoverable algorithms tolerate failures and recoveries of processes by using non-volatile memory. Of particular interest are self-implementations of key operations, in which a recoverable operation is implemented from its non-recoverable counterpart (in addition to reads and writes).
This paper presents two self-implementations of the swap operation. One works in the system-wide failures model, where all processes fail and recover together, and the other in the independent failures model, where each process crashes and recovers independently of the other processes.
Both algorithms are wait-free in crash-free executions, but their recovery code is blocking. We prove that this is inherent for the independent failures model. The impossibility result is proved for implementations of distinguishable operations using interfering functions, and in particular, it applies to a recoverable self-implementation of swap.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.24/LIPIcs.OPODIS.2023.24.pdf
Multi-core algorithms
persistent memory
non-volatile memory
recoverable objects
detectablitly
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
25:1
25:17
10.4230/LIPIcs.OPODIS.2023.25
article
Silent Programmable Matter: Coating
Navarra, Alfredo
1
https://orcid.org/0000-0001-8547-5934
Piselli, Francesco
1
https://orcid.org/0009-0001-0313-1431
Department of Mathematics and Computer Science, University of Perugia, Italy
By Programmable Matter (PM) is usually meant a system of weak and self-organizing computational entities, called particles, which can be programmed via distributed algorithms to collectively achieve some global tasks. We consider the SILBOT model where particles are modeled as finite state automata, living and operating in the cells of a hexagonal grid. Particles are all identical, executing the same deterministic algorithm which is based on local observation of the surroundings, up to two hops. Particles are asynchronous, without any direct means of communication and disoriented but sharing a common handedness, i.e., chirality is assumed. Within such a basic model, we consider a foundational primitive for PM, that is Coating: a set of n particles must move so as to ensure the closed surrounding of an object occupying some connected cells of the grid. We present an optimal deterministic distributed algorithm - along with the correctness proof, that in Θ(n²) rounds solves the Coating problem, where a round concerns the minimal time window within which each particle is activated at least once.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.25/LIPIcs.OPODIS.2023.25.pdf
Programmable Matter
Coating
Asynchrony
Stigmergy
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
26:1
26:22
10.4230/LIPIcs.OPODIS.2023.26
article
Tight Bounds on the Message Complexity of Distributed Tree Verification
Kutten, Shay
1
https://orcid.org/0000-0003-2062-6855
Robinson, Peter
2
https://orcid.org/0000-0002-7442-7002
Tan, Ming Ming
2
https://orcid.org/0000-0002-5279-5314
Technion - Israel Institute of Technology, Haifa, Israel
Augusta University, GA, USA
We consider the message complexity of verifying whether a given subgraph of the communication network forms a tree with specific properties both in the KT_ρ (nodes know their ρ-hop neighborhood, including node ids) and the KT₀ (nodes do not have this knowledge) models. We develop a rather general framework that helps in establishing tight lower bounds for various tree verification problems. We also consider two different verification requirements: namely that every node detects in the case the input is incorrect, as well as the requirement that at least one node detects. The results are stronger than previous ones in the sense that we assume that each node knows the number n of nodes in the graph (in some cases) or an α approximation of n (in other cases). For spanning tree verification, we show that the message complexity inherently depends on the quality of the given approximation of n: We show a tight lower bound of Ω(n²) for the case α ≥ √2 and a much better upper bound (i.e., O(n log n)) when nodes are given a tighter approximation. On the other hand, our framework also yields an Ω(n²) lower bound on the message complexity of verifying a minimum spanning tree (MST), which reveals a polynomial separation between ST verification and MST verification. This result holds for randomized algorithms with perfect knowledge of the network size, and even when just one node detects illegal inputs, thus improving over the work of Kor, Korman, and Peleg (2013). For verifying a d-approximate BFS tree, we show that the same lower bound holds even if nodes know n exactly, however, the lower bounds is sensitive to d, which is the stretch parameter. First, under the KT₀ assumption, we show a tight message complexity lower bound of Ω(n²) in the LOCAL model, when d ≤ n/(2+Ω(1)). For the KT_ρ assumption, we obtain an upper bound on the message complexity of O(nlog n) in the CONGEST model, when d ≥ (n-1)/max{2,ρ+1}, and use a novel charging argument to show that Ω((1/ρ)(n/ρ)^{1+c/ρ}) messages are required even in the LOCAL model for comparison-based algorithms. For the well-studied special case of KT₁, we obtain a tight lower bound of Ω(n²).
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.26/LIPIcs.OPODIS.2023.26.pdf
Distributed Graph Algorithm
Lower Bound
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
27:1
27:17
10.4230/LIPIcs.OPODIS.2023.27
article
On Polynomial Time Local Decision
Aldema Tshuva, Eden
1
https://orcid.org/0009-0003-0701-6603
Oshman, Rotem
1
https://orcid.org/0009-0007-5065-5557
Tel Aviv University, Israel
The field of distributed local decision studies the power of local network algorithms, where each network can see only its own local neighborhood, and must act based on this restricted information. Traditionally, the nodes of the network are assumed to have unbounded local computation power, and this makes the model incomparable with centralized notions of efficiency, namely, the classes 𝖯 and NP. In this work we seek to bridge this gap by studying local algorithms where the nodes are required to be computationally efficient: we introduce the classes PLD and NPLD of polynomial-time local decision and non-deterministic polynomial-time local decision, respectively, and compare them to the centralized complexity classes 𝖯 and NP, and to the distributed classes LD and NLD, which correspond to local deterministic and non-deterministic decision, respectively.
We show that for deterministic algorithms, requiring both computational and distributed efficiency is likely to be more restrictive than either requirement alone: if the nodes do not know the network size, then PLD ⊊ LD ∩ 𝖯 holds unconditionally; if the network size is known to all nodes, then the same separation holds under a widely believed complexity assumption (UP ∩ coUP ≠ 𝖯). However, when nondeterminism is introduced, this distinction vanishes, and NPLD = NLD ∩ NP. To complete the picture, we extend the classes PLD and NPLD into a hierarchy akin to the centralized polynomial hierarchy, and we characterize its connections to the centralized polynomial hierarchy and to the distributed local decision hierarchy of Balliu, D'Angelo, Fraigniaud, and Olivetti.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.27/LIPIcs.OPODIS.2023.27.pdf
Local Decision
Polynomial-Time
LD
NLD
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
28:1
28:23
10.4230/LIPIcs.OPODIS.2023.28
article
On Asynchrony, Memory, and Communication: Separations and Landscapes
Flocchini, Paola
1
https://orcid.org/0000-0003-3584-5727
Santoro, Nicola
2
https://orcid.org/0000-0001-6437-4173
Sudo, Yuichi
3
https://orcid.org/0000-0002-4442-1750
Wada, Koichi
4
https://orcid.org/0000-0002-5351-1459
EECS, University of Ottawa, Canada
School of Computer Science, Carleton University, Ottawa, Canada
Faculty of Computer and Information Sciences, Hosei University, Tokyo, Japan
Faculty of Science and Engineering, Hosei University, Tokyo, Japan
Research on distributed computing by a team of identical mobile computational entities, called robots, operating in a Euclidean space in Look-Compute-Move (LCM) cycles, has recently focused on better understanding how the computational power of robots depends on the interplay between their internal capabilities (i.e., persistent memory, communication), captured by the four standard computational models (OBLOT, LUMI, FSTA, and FCOM) and the conditions imposed by the external environment, controlling the activation of the robots and their synchronization of their activities, perceived and modeled as an adversarial scheduler.
We consider a set of adversarial asynchronous schedulers ranging from the classical semi-synchronous (Ssynch) and fully asynchronous (Asynch) settings, including schedulers (emerging when studying the atomicity of the combination of operations in the LCM cycles) whose adversarial power is in between those two. We ask the question: what is the computational relationship between a model M₁ under adversarial scheduler K₁ (M₁(K₁)) and a model M₂ under scheduler K₂ (M₂(K₂))? For example, are the robots in M₁(K₁) more powerful (i.e., they can solve more problems) than those in M₂(K₂)?
We answer all these questions by providing, through cross-model analysis, a complete characterization of the computational relationship between the power of the four models of robots under the considered asynchronous schedulers. In this process, we also provide qualified answers to several open questions, including the outstanding one on the proper dominance of Ssynch over Asynch in the case of unrestricted visibility.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.28/LIPIcs.OPODIS.2023.28.pdf
Look-Compute-Move
Oblivious mobile robots
Robots with lights
Memory versus Communication
Moving and Computing
Asynchrony
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
29:1
29:21
10.4230/LIPIcs.OPODIS.2023.29
article
On the Round Complexity of Asynchronous Crusader Agreement
Abraham, Ittai
1
Ben-David, Naama
2
Stern, Gilad
3
Yandamuri, Sravya
4
Intel Labs, Petah Tikva, Israel
Technion, Haifa, Israel
The Hebrew University of Jerusalem, Israel
Duke University, Durham, NC, USA
We present new lower and upper bounds on the number of communication rounds required for asynchronous Crusader Agreement (CA) and Binding Crusader Agreement (BCA), two primitives that are used for solving binary consensus. We show results for the information theoretic and authenticated settings. In doing so, we present a generic model for proving round complexity lower bounds in the asynchronous setting. In some settings, our attempts to prove lower bounds on round complexity fail. Instead, we show new, tight, rather surprising round complexity upper bounds for Byzantine fault tolerant BCA with and without a PKI setup.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.29/LIPIcs.OPODIS.2023.29.pdf
lower bounds
asynchronous protocols
round complexity
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
30:1
30:22
10.4230/LIPIcs.OPODIS.2023.30
article
Distributed Partial Coloring via Gradual Rounding
Das, Avinandan
1
Fraigniaud, Pierre
1
https://orcid.org/0000-0003-4534-4803
Rosén, Adi
1
Institut de Recherche en Informatique Fondamentale (IRIF), CNRS and Université Paris Cité, France
For k ≥ 0, k-partial (k+1)-coloring asks to color the nodes of an n-node graph using a palette of k+1 colors such that every node v has at least min{k,deg(v)} neighbors colored with colors different from its own color. Hence, proper (Δ+1)-coloring is the special case of k-partial (k+1)-coloring when k = Δ. Ghaffari and Kuhn [FOCS 2021] recently proved that there exists a deterministic distributed algorithm that solves proper (Δ+1)-coloring of n-node graphs with maximum degree Δ in O(log n ⋅ log²Δ) rounds under the LOCAL model of distributed computing. This breakthrough result is achieved via an original iterated rounding approach. Using the same technique, Ghaffari and Kuhn also showed that there exists a deterministic algorithm that solves proper O(a)-coloring of n-node graphs with arboricity a in O(log n ⋅ log³a) rounds. It directly follows from this latter result that k-partial O(k)-coloring can be solved deterministically in O(log n ⋅ log³k) rounds.
We develop an extension of the Ghaffari and Kuhn algorithm for proper (Δ+1)-coloring, and show that it solves k-partial (k+1)-coloring, thus generalizing their main result. Our algorithm runs in O(log n ⋅ log³k) rounds, like the algorithm that follows from Ghaffari and Kuhn’s algorithm for graphs with bounded arboricity, but uses only k+1 color, i.e., the smallest number c of colors such that every graph has a k-partial c-coloring. Like all the previously mentioned algorithms, our algorithm actually solves the general list-coloring version of the problem. Specifically, every node v receives as input an integer demand d(v) ≤ deg(v), and a list of at least d(v)+1 colors. Every node must then output a color from its list such that the resulting coloring satisfies that every node v has at least d(v) neighbors with colors different from its own. Our algorithm solves this problem in O(log n ⋅ log³k) rounds where k = max_v d(v). Moreover, in the specific case where all lists of colors given to the nodes as input share a common colors c^* known to all nodes, one can save one log k factor. In particular, for standard k-partial (k+1)-coloring, which corresponds to the case where all nodes are given the same list {1,… ,k+1}, one can modify our algorithm so that it runs in O(log n ⋅ log²k) rounds, and thus matches the complexity of Ghaffari and Kuhn’s algorithm for (Δ+1)-coloring for k = Δ.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.30/LIPIcs.OPODIS.2023.30.pdf
Distributed graph coloring
partial coloring
weak coloring
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
31:1
31:19
10.4230/LIPIcs.OPODIS.2023.31
article
A Tight Bound on Multiple Spending in Decentralized Cryptocurrencies
Bezerra, João Paulo
1
https://orcid.org/0000-0003-3620-899X
Kuznetsov, Petr
1
https://orcid.org/0000-0003-1148-1228
Télécom Paris, Institut Polytechnique de Paris, France
The last decade has seen a variety of Asset-Transfer systems designed for decentralized environments. The major problem these systems address is double-spending, and solving it inherently imposes strong trust assumptions on the system participants. In this paper, we take a non-orthodox approach to the double-spending problem that might suit better realistic environments in which these systems are to be deployed. We consider the decentralized trust setting, where each user may independently choose who to trust by forming their local quorums. In this setting, we define k-Spending Asset Transfer, a relaxed version of asset transfer which bounds the number of times a system participant may spend an asset it received. We establish a precise relationship between the decentralized trust assumptions and k, the optimal spending number of the system.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.31/LIPIcs.OPODIS.2023.31.pdf
Quorum systems
decentralized trust
consistency measure
asset transfer
accountability
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
32:1
32:22
10.4230/LIPIcs.OPODIS.2023.32
article
Bounds on Worst-Case Responsiveness for Agreement Algorithms
Attiya, Hagit
1
https://orcid.org/0000-0002-8017-6457
Welch, Jennifer L.
2
https://orcid.org/0000-0003-2725-9875
Department of Computer Science, Technion, Haifa, Israel
Department of Computer Science and Engineering, Texas A&M University, College Station, TX, USA
We study the worst-case time complexity of solving two agreement problems, consensus and broadcast, in systems with n processes subject to no more than t process failures. In both problems, correct processes must decide on a common value; in the consensus problem, each process has an input and if the inputs of correct processes are all the same, then that must be the common decision, whereas in the broadcast problem, only one process (the sender) has an input and if the sender is correct, then its input must be the common decision. We focus on systems where there is an upper bound Δ on the message delivery time but it is expected that typically, messages arrive much faster, say within some time d. While Δ may or may not be known in advance, d is inherently unknown and specific to each execution. The goal is to design deterministic algorithms whose running times have minimal to no dependence on Δ, a property called responsiveness.
We present a generic algorithm transformation that, when applied to appropriate eventually-synchronous consensus (or broadcast) algorithms, results in consensus (or broadcast) algorithms for send omission failures, authenticated Byzantine failures, and unauthenticated Byzantine failures whose running times have no dependence on Δ; their worst-case time complexities are all O(td), which is asymptotically optimal. The algorithm for send omission failures requires n > 2t, while those for Byzantine failures, both authenticated and unauthenticated, require n > 3t. The failure-resilience of the unauthenticated Byzantine algorithm is optimal.
For authenticated Byzantine failures, existing agreement algorithms provide worst-case time complexity O(t Δ) when n is at most 3t. (When n ≤ 2t, broadcast is solvable while consensus is not.) We prove a lower bound on the worst-case time complexity of ⌊(3t-n)/2⌋ d + Δ when n is at most 3t. Although lower bounds of Δ and (t+1)d were already known, our new lower bound indicates that, at least when n ≤ 2t, it is impossible for an algorithm to pay these bounds in parallel.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.32/LIPIcs.OPODIS.2023.32.pdf
bounded-delay model
basic round model
omission failures
Byzantine failures
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
33:1
33:18
10.4230/LIPIcs.OPODIS.2023.33
article
Black Hole Search in Dynamic Rings: The Scattered Case
Di Luna, Giuseppe A.
1
Flocchini, Paola
2
Prencipe, Giuseppe
3
Santoro, Nicola
4
DIAG, Sapienza University of Rome, Italy
School of Electrical Engineering and Computer Science, University of Ottawa, Canada
Department of Computer Science, University of Pisa, Italy
School of Computer Science, Carleton University, Ottawa, Canada
In this paper we investigate the problem of searching for a black hole in a dynamic graph by a set of scattered agents (i.e., the agents start from arbitrary locations of the graph). The black hole is a node that silently destroys any agent visiting it. This kind of malicious node nicely models network failures such as a crashed host or a virus that erases the visiting agents. The black hole search problem is solved when at least one agent survives, and it has the entire map of the graph with the location of the black hole. We consider the case in which the underlining graph is a dynamic 1-interval connected ring: a ring graph in which at each round at most one edge can be missing. We first show that the problem cannot be solved if the agents can only communicate by using a face-to-face mechanism: this holds for any set of agents of constant size, with respect to the size n of the ring.
To circumvent this impossibility we consider agents equipped with movable pebbles that can be left on nodes as a form of communication with other agents. When pebbles are available, three agents can localize the black hole in O(n²) moves. We show that such a number of agents is optimal. We also show that the complexity is tight, that is Ω(n²) moves are required for any algorithm solving the problem with three agents, even with stronger communication mechanisms (e.g., a whiteboard on each node on which agents can write messages of unlimited size). To the best of our knowledge this is the first paper examining the problem of searching a black hole in a dynamic environment with scattered agents.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.33/LIPIcs.OPODIS.2023.33.pdf
Black hole search
mobile agents
dynamic graph
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
34:1
34:21
10.4230/LIPIcs.OPODIS.2023.34
article
Sketching the Path to Efficiency: Lightweight Learned Cache Replacement
Shahout, Rana
1
https://orcid.org/0000-0002-9254-8529
Friedman, Roy
2
https://orcid.org/0000-0001-6460-9665
Harvard University, Cambrdige, MA, USA
Technion, Haifa, Israel
Cache management policies are responsible for selecting the items that should be kept in the cache, and are therefore a fundamental design choice for obtaining an effective caching solution. Heuristic approaches have been used to identify access patterns that affect cache management decisions. However, their behavior is inconsistent, as they can perform well for certain access patterns and poorly for others. Given machine learning’s (ML) remarkable achievements in predicting diverse problems, ML techniques can be applied to create a cache management policy. Yet a significant challenge arises from the memory overhead associated with ML components. These components retain per item information and must be invoked on each access, contradicting the goal of minimizing the cache’s resource signature.
In this work, we propose ALPS, a light-weight cache management policy that takes into account the cost of the ML component. ALPS combines ML with traditional heuristic-based approaches and facilitates learning by identifying several statistical features derived from space-efficient sketches. ALPS’s ML process derives its features from these sketches, resulting in a lightweight and highly effective meta-policy for cache management. We evaluate our approach over real-world workloads run against five popular heuristic cache management policies as well as a state-of-the-art ML-based policy. In our experiments, ALPS always obtained the best hit ratio. Specifically, ALPS improves the hit ratio compared to LRU by up to 20%, Hyperbolic by up to 31%, ARC by up to 9% and W-TinyLFU by up to 26% on various real-world workloads. Its resource requirements are orders of magnitude lower than previous ML-based approaches.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.34/LIPIcs.OPODIS.2023.34.pdf
Data streams
Memory Management
Cache Policy
ML
eng
Schloss Dagstuhl – Leibniz-Zentrum für Informatik
Leibniz International Proceedings in Informatics
1868-8969
2024-01-18
286
35:1
35:20
10.4230/LIPIcs.OPODIS.2023.35
article
Atomic Register Abstractions for Byzantine-Prone Distributed Systems
Kowalski, Vincent
1
https://orcid.org/0009-0002-5689-1079
Mostéfaoui, Achour
1
https://orcid.org/0000-0001-7208-4635
Perrin, Matthieu
1
https://orcid.org/0000-0002-8019-0830
LS2N, Nantes Université, France
The construction of the atomic register abstraction over crash-prone asynchronous message-passing systems has been extensively studied since the founding work of Attiya, Bar-Noy, and Dolev. It has been shown that t < n/2 (where t is the maximal number of processes that may be faulty) is a necessary and sufficient requirement to build an atomic register. However, little attention has been paid to systems where faulty processes may exhibit a Byzantine behavior. This paper studies three definitions of linearizable single-writer multi-reader registers encountered in the state of the art: Read/Write registers whose read perations return the last written value, Read/Write-Increment registers whose read perations return both the last written value and the number of previously written values, and Read/Append registers whose read perations return the sequence of all previously written values. More specifically, it compares their computing power and the necessary and sufficient conditions on the maximum ratio t/n which makes it possible to build reductions from one register to another. Namely, we prove that t < n/3 is necessary and sufficient to implement a Read/Write-Increment register from Read/Write registers whereas this bound is only t < n/2 for a reduction from a Read/Append register to Read/Write-Increment registers. Reduction algorithms meeting these bounds are also provided.
https://drops.dagstuhl.de/storage/00lipics/lipics-vol286-opodis2023/LIPIcs.OPODIS.2023.35/LIPIcs.OPODIS.2023.35.pdf
Byzantine processes
Concurrent Object
Linearizability
Shared Register