3 research outputs found
Fault Tolerant Network Constructors
In this work, we consider adversarial crash faults of nodes in the network
constructors model Michail and Spirakis, 2016. We first show that,
without further assumptions, the class of graph languages that can be (stably)
constructed under crash faults is non-empty but small. In particular, if an
unbounded number of crash faults may occur, we prove that (i) the only
constructible graph language is that of spanning cliques and (ii) a strong
impossibility result holds even if the size of the graphs that the protocol
outputs in populations of size need only grow with (the remaining nodes
being waste). When there is a finite upper bound on the number of faults,
we show that it is impossible to construct any non-hereditary graph language.
On the positive side, by relaxing our requirements we prove that: (i)
permitting linear waste enables to construct on nodes, any graph
language that is constructible in the fault-free case, (ii) partial
constructibility (i.e. not having to generate all graphs in the language)
allows the construction of a large class of graph languages. We then extend the
original model with a minimal form of fault notifications. Our main result here
is a fault-tolerant universal constructor: We develop a fault-tolerant protocol
for spanning line and use it to simulate a linear-space Turing Machine .
This allows a fault-tolerant construction of any graph accepted by in
linear space, with waste , where is the number of
faults in the execution. We then prove that increasing the permissible waste to
allows the construction of graphs accepted by an
-space Turing Machine, which is asymptotically the maximum simulation
space that we can hope for in this model. Finally, we show that logarithmic
local memories can be exploited for a no-waste fault-tolerant simulation of any
such protocol
Pushing Lines Helps: Efficient Universal Centralised Transformations for Programmable Matter
In this paper, we study a discrete system of entities residing on a
two-dimensional square grid. Each entity is modelled as a node occupying a
distinct cell of the grid. The set of all nodes forms initially a connected
shape . Entities are equipped with a linear-strength pushing mechanism that
can push a whole line of entities, from 1 to , in parallel in a single
time-step. A target connected shape is also provided and the goal is to
\emph{transform} into via a sequence of line movements. Existing models
based on local movement of individual nodes, such as rotating or sliding a
single node, can be shown to be special cases of the present model, therefore
their (inefficient, ) \emph{universal transformations} carry over.
Our main goal is to investigate whether the parallelism inherent in this new
type of movement can be exploited for efficient, i.e., sub-quadratic
worst-case, transformations. As a first step towards this, we restrict
attention solely to centralised transformations and leave the distributed case
as a direction for future research. Our results are positive. By focusing on
the apparently hard instance of transforming a diagonal into a straight
line , we first obtain transformations of time without and
with preserving the connectivity of the shape throughout the transformation.
Then, we further improve by providing two -time transformations for
this problem. By building upon these ideas, we first manage to develop an
-time universal transformation. Our main result is then an -time universal transformation. We leave as an interesting open
problem a suspected -time lower bound.Comment: 40 pages, 27 figure
Distributed leader election and computation of local identifiers for programmable matter
International audienceThe context of this paper is programmable matter, which consists of a set of computational elements, called particles, in an infinite graph. The considered infinite graphs are the square, triangular and king grids. Each particle occupies one vertex, can communicate with the adjacent particles, has the same clockwise direction and knows the local positions of neighborhood particles. Under these assumptions, we describe a new leader election algorithm affecting a variable to the particles, called the k-local identifier, in such a way that particles at close distance have each a different k-local identifier. For all the presented algorithms, the particles only need a O(1)-memory space