99 research outputs found
Brief Announcement: Fault-Tolerant Shape Formation in the Amoebot Model
The amoebot model is a distributed computing model of programmable matter. It envisions programmable matter as a collection of computational units called amoebots or particles that utilize local interactions to achieve tasks of coordination, movement and conformation. In the geometric amoebot model the particles operate on a hexagonal tessellation of the plane. Within this model, numerous problems such as leader election, shape formation or object coating have been studied. One area that has not received much attention so far, but is highly relevant for a practical implementation of programmable matter, is fault tolerance. The existing literature on that aspect allows particles to crash but assumes that crashed particles do not recover. We propose a new model in which a crash causes the memory of a particle to be reset and a crashed particle can detect that it has crashed and try to recover using its local information and communication capabilities. We propose an algorithm that solves the hexagon shape formation problem in our model if a finite number of crashes occur and a designated leader particle does not fail. At the heart of our solution lies a fault-tolerant implementation of the spanning forest primitive, which, since other algorithms in the amoebot model also make use of it, is also of general interest
Fast Reconfiguration for Programmable Matter
The concept of programmable matter envisions a very large number of tiny and
simple robot particles forming a smart material. Even though the particles are
restricted to local communication, local movement, and simple computation,
their actions can nevertheless result in the global change of the material's
physical properties and geometry.
A fundamental algorithmic task for programmable matter is to achieve global
shape reconfiguration by specifying local behavior of the particles. In this
paper we describe a new approach for shape reconfiguration in the amoebot
model. The amoebot model is a distributed model which significantly restricts
memory, computing, and communication capacity of the individual particles. Thus
the challenge lies in coordinating the actions of particles to produce the
desired behavior of the global system.
Our reconfiguration algorithm is the first algorithm that does not use a
canonical intermediate configuration when transforming between arbitrary
shapes. We introduce new geometric primitives for amoebots and show how to
reconfigure particle systems, using these primitives, in a linear number of
activation rounds in the worst case. In practice, our method exploits the
geometry of the symmetric difference between input and output shape: it
minimizes unnecessary disassembly and reassembly of the particle system when
the symmetric difference between the initial and the target shapes is small.
Furthermore, our reconfiguration algorithm moves the particles over as many
parallel shortest paths as the problem instance allows
Turning Machines
Molecular robotics is challenging, so it seems best to keep it simple. We consider an abstract molecular robotics model based on simple folding instructions that execute asynchronously. Turning Machines are a simple 1D to 2D folding model, also easily generalisable to 2D to 3D folding. A Turning Machine starts out as a line of connected monomers in the discrete plane, each with an associated turning number. A monomer turns relative to its neighbours, executing a unit-distance translation that drags other monomers along with it, and through collective motion the initial set of monomers eventually folds into a programmed shape. We fully characterise the ability of Turning Machines to execute line rotations, and to do so efficiently: computing an almost-full line rotation of 5?/3 radians is possible, yet a full 2? rotation is impossible. We show that such line-rotations represent a fundamental primitive in the model, by using them to efficiently and asynchronously fold arbitrarily large zig-zag-rastered squares and y-monotone shapes
Non-Crossing Geometric Steiner Arborescences
Motivated by the question of simultaneous embedding of several flow maps, we consider the problem of drawing multiple geometric Steiner arborescences with no crossings in the rectilinear and in the angle-restricted setting. When terminal-to-root paths are allowed to turn freely, we show that two rectilinear Steiner arborescences have a non-crossing drawing if neither tree necessarily completely disconnects the other tree and if the roots of both trees are "free". If the roots are not free, then we can reduce the decision problem to 2SAT. If terminal-to-root paths are allowed to turn only at Steiner points, then it is NP-hard to decide whether multiple rectilinear Steiner arborescences have a non-crossing drawing. The setting of angle-restricted Steiner arborescences is more subtle than the rectilinear case. Our NP-hardness result extends, but testing whether there exists a non-crossing drawing if the roots of both trees are free requires additional conditions to be fulfilled
An Optimal Algorithm to Compute the Inverse Beacon Attraction Region
The beacon model is a recent paradigm for guiding the trajectory of messages or small robotic agents in complex environments. A beacon is a fixed point with an attraction pull that can move points within a given polygon. Points move greedily towards a beacon: if unobstructed, they move along a straight line to the beacon, and otherwise they slide on the edges of the polygon. The Euclidean distance from a moving point to a beacon is monotonically decreasing. A given beacon attracts a point if the point eventually reaches the beacon.
The problem of attracting all points within a polygon with a set of beacons can be viewed as a variation of the art gallery problem. Unlike most variations, the beacon attraction has the intriguing property of being asymmetric, leading to separate definitions of attraction region and inverse attraction region. The attraction region of a beacon is the set of points that it attracts. It is connected and can be computed in linear time for simple polygons. By contrast, it is known that the inverse attraction region of a point - the set of beacon positions that attract it - could have Omega(n) disjoint connected components.
In this paper, we prove that, in spite of this, the total complexity of the inverse attraction region of a point in a simple polygon is linear, and present a O(n log n) time algorithm to construct it. This improves upon the best previous algorithm which required O(n^3) time and O(n^2) space. Furthermore we prove a matching Omega(n log n) lower bound for this task in the algebraic computation tree model of computation, even if the polygon is monotone
Convex Hull Formation for Programmable Matter
We envision programmable matter as a system of nano-scale agents (called
particles) with very limited computational capabilities that move and compute
collectively to achieve a desired goal. We use the geometric amoebot model as
our computational framework, which assumes particles move on the triangular
lattice. Motivated by the problem of sealing an object using minimal resources,
we show how a particle system can self-organize to form an object's convex
hull. We give a distributed, local algorithm for convex hull formation and
prove that it runs in asynchronous rounds, where is the
length of the object's boundary. Within the same asymptotic runtime, this
algorithm can be extended to also form the object's (weak) -hull,
which uses the same number of particles but minimizes the area enclosed by the
hull. Our algorithms are the first to compute convex hulls with distributed
entities that have strictly local sensing, constant-size memory, and no shared
sense of orientation or coordinates. Ours is also the first distributed
approach to computing restricted-orientation convex hulls. This approach
involves coordinating particles as distributed memory; thus, as a supporting
but independent result, we present and analyze an algorithm for organizing
particles with constant-size memory as distributed binary counters that
efficiently support increments, decrements, and zero-tests --- even as the
particles move
- …