3,118 research outputs found
Efficient size estimation and impossibility of termination in uniform dense population protocols
We study uniform population protocols: networks of anonymous agents whose
pairwise interactions are chosen at random, where each agent uses an identical
transition algorithm that does not depend on the population size . Many
existing polylog time protocols for leader election and majority
computation are nonuniform: to operate correctly, they require all agents to be
initialized with an approximate estimate of (specifically, the exact value
). Our first main result is a uniform protocol for
calculating with high probability in time and
states ( bits of memory). The protocol is
converging but not terminating: it does not signal when the estimate is close
to the true value of . If it could be made terminating, this would
allow composition with protocols, such as those for leader election or
majority, that require a size estimate initially, to make them uniform (though
with a small probability of failure). We do show how our main protocol can be
indirectly composed with others in a simple and elegant way, based on the
leaderless phase clock, demonstrating that those protocols can in fact be made
uniform. However, our second main result implies that the protocol cannot be
made terminating, a consequence of a much stronger result: a uniform protocol
for any task requiring more than constant time cannot be terminating even with
probability bounded above 0, if infinitely many initial configurations are
dense: any state present initially occupies agents. (In particular,
no leader is allowed.) Crucially, the result holds no matter the memory or time
permitted. Finally, we show that with an initial leader, our size-estimation
protocol can be made terminating with high probability, with the same
asymptotic time and space bounds.Comment: Using leaderless phase cloc
Space-Optimal Majority in Population Protocols
Population protocols are a model of distributed computing, in which
agents with limited local state interact randomly, and cooperate to
collectively compute global predicates. An extensive series of papers, across
different communities, has examined the computability and complexity
characteristics of this model. Majority, or consensus, is a central task, in
which agents need to collectively reach a decision as to which one of two
states or had a higher initial count. Two complexity metrics are
important: the time that a protocol requires to stabilize to an output
decision, and the state space size that each agent requires.
It is known that majority requires states per agent to
allow for poly-logarithmic time stabilization, and that states
are sufficient. Thus, there is an exponential gap between the upper and lower
bounds.
We address this question. We provide a new lower bound of
states for any protocol which stabilizes in time, for any constant. This result is conditional on basic monotonicity and output
assumptions, satisfied by all known protocols. Technically, it represents a
significant departure from previous lower bounds. Instead of relying on dense
configurations, we introduce a new surgery technique to construct executions
which contradict the correctness of algorithms that stabilize too fast.
Subsequently, our lower bound applies to general initial configurations.
We give an algorithm for majority which uses states, and
stabilizes in time. Central to the algorithm is a new leaderless
phase clock, which allows nodes to synchronize in phases of
consecutive interactions using states per node. We also employ our
phase clock to build a leader election algorithm with states,
which stabilizes in time
Time-space trade-offs in population protocols
Population protocols are a popular model of distributed computing, in which randomly-interacting agents with little computational power cooperate to jointly perform computational tasks. Inspired by developments in molecular computation, and in particular DNA computing, recent algorithmic work has focused on the complexity of solving simple yet fundamental tasks in the population model, such as leader election (which requires convergence to a single agent in a special "leader" state), and majority (in which agents must converge to a decision as to which of two possible initial states had higher initial count). Known results point towards an inherent trade-off between the time complexity of such algorithms, and the space complexity, i.e. size of the memory available to each agent.
In this paper, we explore this trade-off and provide new upper and lower bounds for majority and leader election. First, we prove a unified lower bound, which relates the space available per node with the time complexity achievable by a protocol: for instance, our result implies that any protocol solving either of these tasks for n agents using O(log log n) states must take Ω(n/polylogn) expected time. This is the first result to characterize time complexity for protocols which employ super-constant number of states per node, and proves that fast, poly-logarithmic running times require protocols to have relatively large space costs.
On the positive side, we give algorithms showing that fast, poly-logarithmic convergence time can be achieved using O(log²n) space per node, in the case of both tasks. Overall, our results highlight a time complexity separation between O (log log n) and Θ(log²n) state space size for both majority and leader election in population protocols, and introduce new techniques, which should be applicable more broadly
Time-space trade-offs in population protocols
Population protocols are a popular model of distributed computing, in which randomly-interacting agents with little computational power cooperate to jointly perform computational tasks. Inspired by developments in molecular computation, and in particular DNA computing, recent algorithmic work has focused on the complexity of solving simple yet fundamental tasks in the population model, such as leader election (which requires convergence to a single agent in a special "leader" state), and majority (in which agents must converge to a decision as to which of two possible initial states had higher initial count). Known results point towards an inherent trade-off between the time complexity of such algorithms, and the space complexity, i.e. size of the memory available to each agent.
In this paper, we explore this trade-off and provide new upper and lower bounds for majority and leader election. First, we prove a unified lower bound, which relates the space available per node with the time complexity achievable by a protocol: for instance, our result implies that any protocol solving either of these tasks for n agents using O(log log n) states must take Ω(n/polylogn) expected time. This is the first result to characterize time complexity for protocols which employ super-constant number of states per node, and proves that fast, poly-logarithmic running times require protocols to have relatively large space costs.
On the positive side, we give algorithms showing that fast, poly-logarithmic convergence time can be achieved using O(log²n) space per node, in the case of both tasks. Overall, our results highlight a time complexity separation between O (log log n) and Θ(log²n) state space size for both majority and leader election in population protocols, and introduce new techniques, which should be applicable more broadly
Exact size counting in uniform population protocols in nearly logarithmic time
We study population protocols: networks of anonymous agents that interact under a scheduler that picks pairs of agents uniformly at random. The _size counting problem_ is that of calculating the exact number of agents in the population, assuming no leader (each agent starts in the same state). We give the first protocol that solves this problem in sublinear time. The protocol converges in time and uses states ( bits of memory per agent) with probability . The time complexity is also in expectation. The time to converge is also in expectation. Crucially, unlike most published protocols with states, our protocol is _uniform_: it uses the same transition algorithm for any population size, so does not need an estimate of the population size to be embedded into the algorithm. A sub-protocol is the first uniform sublinear-time leader election population protocol, taking time and states. The state complexity of both the counting and leader election protocols can be reduced to and respectively, while increasing the time to
Dynamic Size Counting in Population Protocols
The population protocol model describes a network of anonymous agents that
interact asynchronously in pairs chosen at random. Each agent starts in the
same initial state . We introduce the *dynamic size counting* problem:
approximately counting the number of agents in the presence of an adversary who
at any time can remove any number of agents or add any number of new agents in
state . A valid solution requires that after each addition/removal event,
resulting in population size , with high probability each agent "quickly"
computes the same constant-factor estimate of the value (how quickly
is called the *convergence* time), which remains the output of every agent for
as long as possible (the *holding* time). Since the adversary can remove
agents, the holding time is necessarily finite: even after the adversary stops
altering the population, it is impossible to *stabilize* to an output that
never again changes.
We first show that a protocol solves the dynamic size counting problem if and
only if it solves the *loosely-stabilizing counting* problem: that of
estimating in a *fixed-size* population, but where the adversary can
initialize each agent in an arbitrary state, with the same convergence time and
holding time. We then show a protocol solving the loosely-stabilizing counting
problem with the following guarantees: if the population size is , is
the largest initial estimate of , and s is the maximum integer
initially stored in any field of the agents' memory, we have expected
convergence time , expected polynomial holding time, and
expected memory usage of bits. Interpreted as
a dynamic size counting protocol, when changing from population size
to , the convergence time is
A population protocol for exact majority with stabilization time and asymptotically optimal number of states.
A population protocol is a sequence of pairwise interactions of n agents. During one interaction, two randomly selected agents update their states by applying a deterministic transition function. The goal is to stabilize the system at a desired output property. The main performance objectives in designing such protocols are small number of states per agent and fast stabilization time. We present a fast population protocol for the exact-majority problem, which uses Theta(log n) states (per agent) and stabilizes in O(log^{5/3} n) parallel time (i.e., in O(n log^{5/3} n) interactions) in expectation and with high probability. Alistarh et al. [SODA 2018] showed that exact-majority protocols which stabilize in expected O(n^{1-Omega(1)}) parallel time and have the properties of monotonicity and output dominance require Omega(log n) states. Note that the properties mentioned above are satisfied by all known population protocols for exact majority, including ours. They also showed an O(log^2 n)-time exact-majority protocol with O(log n) states, which, prior to our work, was the fastest exact-majority protocol with polylogarithmic number of states. The standard design framework for majority protocols is based on O(log n) phases and requires that all agents are well synchronized within each phase, leading naturally to upper bounds of the order of log^2 n because of Theta(log n) synchronization time per phase. We show how this framework can be tightened with weak synchronization to break the O(log^2 n) upper bound of previous protocols
Brief announcement: Exact size counting in uniform population protocols in nearly logarithmic time
We study population protocols: networks of anonymous agents whose pairwise interactions are chosen uniformly at random. The size counting problem is that of calculating the exact number n of agents in the population, assuming no leader (each agent starts in the same state). We give the first protocol that solves this problem in sublinear time. The protocol converges in O(log n log log n) time and uses O(n 60 ) states (O(1)+60 log n bits of memory per agent) with probability 1−O( lognlog n ). The time to converge is also O(log n log log n) in expectation. Crucially, unlike most published protocols with ω(1) states, our protocol is uniform: it uses the same transition algorithm for any population size, so does not need an estimate of the population size to be embedded into the algorithm
- …