26,812 research outputs found
Optimal Space Lower Bound for Deterministic Self-Stabilizing Leader Election Algorithms
Given a boolean predicate ? on labeled networks (e.g., proper coloring, leader election, etc.), a self-stabilizing algorithm for ? is a distributed algorithm that can start from any initial configuration of the network (i.e., every node has an arbitrary value assigned to each of its variables), and eventually converge to a configuration satisfying ?. It is known that leader election does not have a deterministic self-stabilizing algorithm using a constant-size register at each node, i.e., for some networks, some of their nodes must have registers whose sizes grow with the size n of the networks. On the other hand, it is also known that leader election can be solved by a deterministic self-stabilizing algorithm using registers of O(log log n) bits per node in any n-node bounded-degree network. We show that this latter space complexity is optimal. Specifically, we prove that every deterministic self-stabilizing algorithm solving leader election must use ?(log log n)-bit per node registers in some n-node networks. In addition, we show that our lower bounds go beyond leader election, and apply to all problems that cannot be solved by anonymous algorithms
Memory lower bounds for deterministic self-stabilization
In the context of self-stabilization, a \emph{silent} algorithm guarantees
that the register of every node does not change once the algorithm has
stabilized. At the end of the 90's, Dolev et al. [Acta Inf. '99] showed that,
for finding the centers of a graph, for electing a leader, or for constructing
a spanning tree, every silent algorithm must use a memory of
bits per register in -node networks. Similarly, Korman et al. [Dist. Comp.
'07] proved, using the notion of proof-labeling-scheme, that, for constructing
a minimum-weight spanning trees (MST), every silent algorithm must use a memory
of bits per register. It follows that requiring the algorithm
to be silent has a cost in terms of memory space, while, in the context of
self-stabilization, where every node constantly checks the states of its
neighbors, the silence property can be of limited practical interest. In fact,
it is known that relaxing this requirement results in algorithms with smaller
space-complexity.
In this paper, we are aiming at measuring how much gain in terms of memory
can be expected by using arbitrary self-stabilizing algorithms, not necessarily
silent. To our knowledge, the only known lower bound on the memory requirement
for general algorithms, also established at the end of the 90's, is due to
Beauquier et al.~[PODC '99] who proved that registers of constant size are not
sufficient for leader election algorithms. We improve this result by
establishing a tight lower bound of bits per
register for self-stabilizing algorithms solving -coloring or
constructing a spanning tree in networks of maximum degree~. The lower
bound bits per register also holds for leader election
Brief Announcement: Memory Lower Bounds for Self-Stabilization
In the context of self-stabilization, a silent algorithm guarantees that the communication registers (a.k.a register) of every node do not change once the algorithm has stabilized. At the end of the 90\u27s, Dolev et al. [Acta Inf. \u2799] showed that, for finding the centers of a graph, for electing a leader, or for constructing a spanning tree, every silent deterministic algorithm must use a memory of Omega(log n) bits per register in n-node networks. Similarly, Korman et al. [Dist. Comp. \u2707] proved, using the notion of proof-labeling-scheme, that, for constructing a minimum-weight spanning tree (MST), every silent algorithm must use a memory of Omega(log^2n) bits per register. It follows that requiring the algorithm to be silent has a cost in terms of memory space, while, in the context of self-stabilization, where every node constantly checks the states of its neighbors, the silence property can be of limited practical interest. In fact, it is known that relaxing this requirement results in algorithms with smaller space-complexity.
In this paper, we are aiming at measuring how much gain in terms of memory can be expected by using arbitrary deterministic self-stabilizing algorithms, not necessarily silent. To our knowledge, the only known lower bound on the memory requirement for deterministic general algorithms, also established at the end of the 90\u27s, is due to Beauquier et al. [PODC \u2799] who proved that registers of constant size are not sufficient for leader election algorithms. We improve this result by establishing the lower bound Omega(log log n) bits per register for deterministic self-stabilizing algorithms solving (Delta+1)-coloring, leader election or constructing a spanning tree in networks of maximum degree Delta
Leader Election in Anonymous Rings: Franklin Goes Probabilistic
We present a probabilistic leader election algorithm for anonymous, bidirectional, asynchronous rings. It is based on an algorithm from Franklin, augmented with random identity selection, hop counters to detect identity clashes, and round numbers modulo 2. As a result, the algorithm is finite-state, so that various model checking techniques can be employed to verify its correctness, that is, eventually a unique leader is elected with probability one. We also sketch a formal correctness proof of the algorithm for rings with arbitrary size
Computing on Anonymous Quantum Network
This paper considers distributed computing on an anonymous quantum network, a
network in which no party has a unique identifier and quantum communication and
computation are available. It is proved that the leader election problem can
exactly (i.e., without error in bounded time) be solved with at most the same
complexity up to a constant factor as that of exactly computing symmetric
functions (without intermediate measurements for a distributed and superposed
input), if the number of parties is given to every party. A corollary of this
result is a more efficient quantum leader election algorithm than existing
ones: the new quantum algorithm runs in O(n) rounds with bit complexity
O(mn^2), on an anonymous quantum network with n parties and m communication
links. Another corollary is the first quantum algorithm that exactly computes
any computable Boolean function with round complexity O(n) and with smaller bit
complexity than that of existing classical algorithms in the worst case over
all (computable) Boolean functions and network topologies. More generally, any
n-qubit state can be shared with that complexity on an anonymous quantum
network with n parties.Comment: 25 page
Emergent velocity agreement in robot networks
In this paper we propose and prove correct a new self-stabilizing velocity
agreement (flocking) algorithm for oblivious and asynchronous robot networks.
Our algorithm allows a flock of uniform robots to follow a flock head emergent
during the computation whatever its direction in plane. Robots are
asynchronous, oblivious and do not share a common coordinate system. Our
solution includes three modules architectured as follows: creation of a common
coordinate system that also allows the emergence of a flock-head, setting up
the flock pattern and moving the flock. The novelty of our approach steams in
identifying the necessary conditions on the flock pattern placement and the
velocity of the flock-head (rotation, translation or speed) that allow the
flock to both follow the exact same head and to preserve the flock pattern.
Additionally, our system is self-healing and self-stabilizing. In the event of
the head leave (the leading robot disappears or is damaged and cannot be
recognized by the other robots) the flock agrees on another head and follows
the trajectory of the new head. Also, robots are oblivious (they do not recall
the result of their previous computations) and we make no assumption on their
initial position. The step complexity of our solution is O(n)
- …