33,575 research outputs found
The Computational Power of Beeps
In this paper, we study the quantity of computational resources (state
machine states and/or probabilistic transition precision) needed to solve
specific problems in a single hop network where nodes communicate using only
beeps. We begin by focusing on randomized leader election. We prove a lower
bound on the states required to solve this problem with a given error bound,
probability precision, and (when relevant) network size lower bound. We then
show the bound tight with a matching upper bound. Noting that our optimal upper
bound is slow, we describe two faster algorithms that trade some state
optimality to gain efficiency. We then turn our attention to more general
classes of problems by proving that once you have enough states to solve leader
election with a given error bound, you have (within constant factors) enough
states to simulate correctly, with this same error bound, a logspace TM with a
constant number of unary input tapes: allowing you to solve a large and
expressive set of problems. These results identify a key simplicity threshold
beyond which useful distributed computation is possible in the beeping model.Comment: Extended abstract to appear in the Proceedings of the International
Symposium on Distributed Computing (DISC 2015
Scalable and Secure Aggregation in Distributed Networks
We consider the problem of computing an aggregation function in a
\emph{secure} and \emph{scalable} way. Whereas previous distributed solutions
with similar security guarantees have a communication cost of , we
present a distributed protocol that requires only a communication complexity of
, which we prove is near-optimal. Our protocol ensures perfect
security against a computationally-bounded adversary, tolerates
malicious nodes for any constant (not
depending on ), and outputs the exact value of the aggregated function with
high probability
Breaking the O(n^2) Bit Barrier: Scalable Byzantine agreement with an Adaptive Adversary
We describe an algorithm for Byzantine agreement that is scalable in the
sense that each processor sends only bits, where is
the total number of processors. Our algorithm succeeds with high probability
against an \emph{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 \emph{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 . To the best of our knowledge, ours is the first
algorithm to solve Byzantine agreement against an adaptive adversary, while
requiring total bits of communication
- âŠ