Results 1  10
of
17
Tight bounds for asynchronous randomized consensus
 In STOC ’07: Proceedings of the thirtyninth annual ACM symposium on Theory of computing
, 2007
"... A distributed consensus algorithm allows n processes to reach a common decision value starting from individual inputs. Waitfree consensus, in which a process always terminates within a finite number of its own steps, is impossible in an asynchronous sharedmemory system. However, consensus becomes ..."
Abstract

Cited by 19 (6 self)
 Add to MetaCart
A distributed consensus algorithm allows n processes to reach a common decision value starting from individual inputs. Waitfree consensus, in which a process always terminates within a finite number of its own steps, is impossible in an asynchronous sharedmemory system. However, consensus becomes solvable using randomization when a process only has to terminate with probability 1. Randomized consensus algorithms are typically evaluated by their total step complexity, which is the expected total number of steps taken by all processes. This work proves that the total step complexity of randomized consensus is Θ(n 2) in an asynchronous shared memory system using multiwriter multireader registers. The bound is achieved by improving both the lower and the upper bounds for this problem. In addition to improving upon the best previously known result by a factor of log 2 n, the lower bound features a greatly streamlined proof. Both goals are achieved through restricting attention to a set of layered executions and using an isoperimetric inequality for analyzing their behavior. The matching algorithm decreases the expected total step complexity by a log n factor, by leveraging the multiwriting capability of the shared registers. Its correctness proof is facilitated by viewing each execution of the algorithm as a stochastic process and applying Kolmogorov’s inequality.
Towards optimal and efficient perfectly secure message transmission
 In Proc. 4th Theory of Cryptography Conference (TCC ’07), Lecture Notes in Computer Science
, 2007
"... Abstract. Perfectly secure message transmission (PSMT), a problem formulated by Dolev, Dwork, Waarts and Yung, involves a sender S and a recipient R who are connected by n synchronous channels of which up to t may be corrupted by an active adversary. The goal is to transmit, with perfect security, a ..."
Abstract

Cited by 13 (4 self)
 Add to MetaCart
Abstract. Perfectly secure message transmission (PSMT), a problem formulated by Dolev, Dwork, Waarts and Yung, involves a sender S and a recipient R who are connected by n synchronous channels of which up to t may be corrupted by an active adversary. The goal is to transmit, with perfect security, a message from S to R. PSMT is achievable if and only if n>2t. For the case n>2t, the lower bound on the number of communication rounds between S and R required for PSMT is 2, and the only known efficient (i.e., polynomial in n) tworound protocol involves a communication complexity of O(n 3 ℓ)bits,whereℓ is the length of the message. A recent solution by Agarwal, Cramer and de Haan is provably communicationoptimal by achieving an asymptotic communication complexity of O(nℓ) bits; however, it requires the messages to be exponentially large, i.e., ℓ = Ω(2 n). In this paper we present an efficient communicationoptimal tworound PSMT protocol for messages of length polynomial in n that is almost optimally resilient in that it requires a number of channels n ≥ (2 + ε)t, for any arbitrarily small constant ε>0. In this case, optimal communication complexity is O(ℓ) bits. 1
Robust random number generation for peertopeer systems
 In In Proc. ACM OPODIS
, 2007
"... Abstract. We consider the problem of designing an efficient and robust distributed random number generator for peertopeer systems that is easy to implement and works even if all communication channels are public. A robust random number generator is crucial for avoiding adversarial joinleave attac ..."
Abstract

Cited by 11 (2 self)
 Add to MetaCart
Abstract. We consider the problem of designing an efficient and robust distributed random number generator for peertopeer systems that is easy to implement and works even if all communication channels are public. A robust random number generator is crucial for avoiding adversarial joinleave attacks on peertopeer overlay networks. We show that our new generator together with a lightweight rule recently proposed in [4] for keeping peers welldistributed can keep various structured overlay networks in a robust state even under a constant fraction of adversarial peers. 1
From almost everywhere to everywhere: Byzantine agreement with Õ(n 3/2) bits
"... Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information synchronous model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information synchronous model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round before sending out its own messages for that round. Furthermore, each corrupt processor may send an unlimited number of messages. The only constraint on the adversary is that it must choose its corrupt processors at the start, without knowledge of the processors’ private random bits. To the authors ’ best knowledge, there have been no protocols for such a model that compute Byzantine agreement without alltoall communication, even if private channels or cryptography are assumed, unless corrupt processors ’ messages are limited. In this paper, we give a polylogarithmic time algorithm to agree on a small representative committee of processors using only Õ(n3/2) total bits which succeeds with high probability. This representative set can
Transmissionline Theory
 30 [7] , Transmissionline Theory
, 1955
"... We describe an algorithm for Byzantine agreement that is scalable in the sense that each processor sends only Õ(√n) bits, where n is the total number of processors. Our algorithm succeeds with high probability against an adaptive adversary, which can take over processors at any time during the proto ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
We describe an algorithm for Byzantine agreement that is scalable in the sense that each processor sends only Õ(√n) bits, where n is the total number of processors. Our algorithm succeeds with high probability against an adaptive adversary, which can take over processors at any time during the protocol, up to the point of taking over arbitrarily close to a 1/3 fraction. We assume synchronous communication but a rushing adversary. Moreover, our algorithm works in the presence of flooding: processors controlled by the adversary can send out any number of messages. We assume the existence of private channels between all pairs of processors but make no other cryptographic assumptions. Finally, our algorithm has latency that is polylogarithmic in n. To the best of our knowledge, ours is the first algorithm to solve Byzantine agreement against an adaptive adversary, while requiring o(n 2) total bits of communication.
Fast asynchronous Byzantine agreement and leader election with full information
 In SODA’08
, 2008
"... We resolve two longstanding open problems in distributed computation by showing that both Byzantine agreement and Leader Election can be solved in subexponential time in the asynchronous full information model. Surprisingly, our protocols for both problems run in only polylogarithmic time. We thus ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
We resolve two longstanding open problems in distributed computation by showing that both Byzantine agreement and Leader Election can be solved in subexponential time in the asynchronous full information model. Surprisingly, our protocols for both problems run in only polylogarithmic time. We thus achieve a better than exponential speedup over previous results for asynchronous Byzantine agreement. In addition, to the best of our knowledge, ours is the first protocol for asynchronous fullinformation leader election. Our protocols work in the full information model with a nonadaptive adversary: the adversary is assumed to control up to a constant fraction of the processors, have unlimited computational power as well as access to all communications, but no access to processors ’ private random bits. The adversary is nonadaptive only in the sense that the corrupted processors must be chosen at the outset. Our protocols run in time that is polylogarithmic in the number of processors, n, and tolerate t < n 6+ɛ faulty processors for any positive constant ɛ. Our protocols are Monte Carlo, succeeding with probability 1 − o(1) for Byzantine agreement, and constant probability for leader election.
Locally scalable randomized consensus for synchronous crash failures
 in Proceedings of the 21st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA
, 2009
"... We consider bit communication complexity of binary consensus in synchronous message passing systems with processes prone to crashes. A distributed algorithm is locally scalable when each process contributes to the complexity measure an amount that is polylogarithmic in the size n of the system, and ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
We consider bit communication complexity of binary consensus in synchronous message passing systems with processes prone to crashes. A distributed algorithm is locally scalable when each process contributes to the complexity measure an amount that is polylogarithmic in the size n of the system, and it is globally scalable when the average contribution per process to the complexity measure is such. We show that consensus can be solved by a randomized algorithm that is locally scalable with respect to both time and bit communication complexities against oblivious adversaries. If a bound t on the number of crashes is a constant fraction of the number n of processes then our randomized consensus solution terminates in the expected O(log n) time while the expected number of bits that each process sends and receives is O(log n). Our solution uses overlay networks with topologies that are explicitly defined and have suitable connectivity and robustness properties related to graph expansion. To compare our results to deterministic consensus solutions, it is known [20] that consensus cannot be solved deterministically by an algorithm that is locally scalable with respect to message complexity and that deterministic solutions globally scalable with respect to bit communication complexity exist for any bound t < n on the number of crashes. We prove a lower bound relating the number of nonfaulty processes needed to obtain a specific message complexity of consensus of a randomized algorithm run against oblivious adversaries.
Load balanced Scalable Byzantine Agreement through Quorum Building, with Full Information
"... Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round befor ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round before sending out its own messages for that round. Furthermore, each bad processor may send an unlimited number of messages. The only constraint on the adversary is that it must choose its corrupt processors at the start, without knowledge of the processors ’ private random bits. A good quorum is a set of O(log n) processors, which contains a majority of good processors. In this paper, we give a synchronous algorithm which uses polylogarithmic time and Õ( √ n) bits of communication per processor to bring all processors to agreement on a collection of n good quorums, solving Byzantine agreement as well. The collection is balanced in that no processor is in more than O(log n) quorums. This yields the first solution to Byzantine agreement which is both scalable and loadbalanced
The Contest Between Simplicity and Efficiency in Asynchronous Byzantine Agreement
"... In the wake of the decisive impossibility result of Fischer, Lynch, and Paterson for deterministic consensus protocols in the aynchronous model with just one failure, BenOr and Bracha demonstrated that the problem could be solved with randomness, even for Byzantine failures. Both protocols are natu ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
In the wake of the decisive impossibility result of Fischer, Lynch, and Paterson for deterministic consensus protocols in the aynchronous model with just one failure, BenOr and Bracha demonstrated that the problem could be solved with randomness, even for Byzantine failures. Both protocols are natural and intuitive to verify, and Bracha’s achieves optimal resilience. However, the expected running time of these protocols is exponential in general. Recently, Kapron, Kempe, King, Saia, and Sanwalani presented the first efficient Byzantine agreement algorithm in the asynchronous, full information model, running in polylogarithmic time. Their algorithm is Monte Carlo and drastically departs from the simple structure of BenOr and Bracha’s Las Vegas algorithms. In this paper, we begin an investigation of the question: to what extent is this departure necessary? Might there be a much simpler and intuitive Las Vegas protocol that runs in expected polynomial time? We will show that the exponential running time of BenOr and Bracha’s algorithms is no mere accident of their specific details, but rather an unavoidable consequence of their general symmetry and round structure. We define a natural class of “fully symmetric round protocols ” for solving Byzantine agreement in an asynchronous setting and show that any such protocol can be forced to run in expected exponential time by an adversary in the full information model. We assume the adversary controls t Byzantine processors for t = cn, where c is an arbitrary positive constant < 1 3. We view our result as a step toward identifying the level of complexity required for a polynomialtime algorithm in this setting, and also as a guide in the search for new efficient algorithms. 1
Liverpool L69 3BX, U.K.
"... We study communication complexity of consensus in synchronous messagepassing systems with processes prone to crashes. The goal in the consensus problem is to have all the nonfaulty processes agree on a common value from among the input ones, after each process has been initialized with a binary inp ..."
Abstract
 Add to MetaCart
We study communication complexity of consensus in synchronous messagepassing systems with processes prone to crashes. The goal in the consensus problem is to have all the nonfaulty processes agree on a common value from among the input ones, after each process has been initialized with a binary input value. The system consists of n processes and it is assumed that at most t < n processes crash in an execution. A consensus algorithm that tolerates up to t failures is called fast when its time complexity is O(t). All the previously known fast deterministic consensus solutions sent Ω(n 2) bits in messages. We give a fast deterministic consensus algorithm that has processes send only O(n log 4 n) bits. In our solution, processes exchange messages according to topologies of overlay graphs that have suitable robustness and connectivity properties related to graph expansion.