Florent Becker

Self-assemblying classes of shapes with a minimum number of tiles, and in optimal time

In this paper we construct fixed finite tile systems that assemble into particular classes of shapes. Moreover, given an arbitrary n, we show how to calculate the tile concentrations in order to ensure that the expected size of the produced shape is n. For rectangles and squares our constructions are optimal (with respect to the size of the systems). We also introduce the notion of parallel time, which is a good approximation of the classical asynchronous time. We prove that our tile systems produce the rectangles and squares in linear parallel time (with respect to the diameter). Those results are optimal. Finally, we introduce the class of diamonds. For these shapes we construct a non trivial tile system having also a linear parallel time complexity.

Pictures worth a thousand tiles, a geometrical programming language for self-assembly

We present a novel way to design self-assembling systems using a notion of signal (or ray) akin to what is used in analyzing the behaviour of cellular automata. This allows purely geometrical constructions, with a smaller specification and easier analysis. We show how to design a system of signals for a given set of shapes, and how to transform these signals into a set of tiles which self-assemble into the desired shapes. We show how to use this technique on two examples: squares (with optimal assembly time and a small number of tiles) and general polygons with arbitrarily good resolution.

The Simultaneous Number-in-Hand Communication Model for Networks: Private Coins, Public Coins and Determinism

We study the multiparty communication model where players are the nodes of a network and each of these players knows his/her own identifier together with the identifiers of his/her neighbors. The players simultaneously send a unique message to a referee who must decide a graph property. The goal of this article is to separate, from the point of view of message size complexity, three different settings: deterministic protocols, randomized protocols with private coins and randomized protocols with public coins. For this purpose we introduce the boolean function Twins. This boolean function returns 1 if and only if there are two nodes with the same neighborhood.

Brief Announcement: A Hierarchy of Congested Clique Models, from Broadcast to Unicast

The CONGEST model is a synchronous, message-passing model of distributed computation in which each node can send (possibly different) messages of O(log n) bits along each of its incident communication links in each round, where n is the number of computing nodes in the system. In the particular case where the communication network is a complete graph, we have the unicast congested clique model. On the other end is the broadcast version of the congested clique model, in which each node can only broadcast a single message over all its links in each round. In this paper we explore the space, in terms of round complexity, that lies between these two congested clique models. Hence, we parametrize the congested clique model with the range r, the maximum number of different messages a node can send over its incident links in one round. Additionally, we study the effect of the bandwidth b, the maximum size in bits of these messages. We show that the space between the unicast and broadcast congested clique models is very rich and interesting. For instance, we show that a problem (especially designed for this work) takes Ω(n/ log n) rounds in the broadcast model (r = 1), while it can be solved in two rounds if two messages can be sent (r = 2). Other gaps are found in other parts of the spectrum of values of r. We do this by providing techniques to simulate protocols with different parameters. Therefore, we conclude that, with respect to their power to solve certain problems, there is a strict hierarchy of congested clique models.

Time Optimal Self-assembly for 2D and 3D Shapes: The Case of Squares and Cubes

Self-assembling tile systems are a model for assembling DNA-based nano artefacts. In the currently known constructions, most of the effort is put on garanteeing the size of the output object, whereas the geometrical efficiency of the assembling of the shape itself is left aside. We propose in this paper a framework to obtain provably time efficient self-assembling tile systems. Our approach consists in studying how the flow of information has to circulate within the desired shape to guarantee an optimal time construction. We show how this study can yield an adequate ordering of the tiling process from which one can deduced a provably time efficient tile systems for that shape. We apply our framework to squares and cubes for which we obtain time optimal self-assembling tile systems.

Allowing each node to communicate only once in a distributed system: shared whiteboard models

In this paper we study distributed algorithms on massive graphs where links represent a particular relationship between nodes (for instance, nodes may represent phone numbers and links may indicate telephone calls). Since such graphs are massive they need to be processed in a distributed way. When computing graph-theoretic properties, nodes become natural units for distributed computation. Links do not necessarily represent communication channels between the computing units and therefore do not restrict the communication flow. Our goal is to model and analyze the computational power of such distributed systems where one computing unit is assigned to each node. Communication takes place on a whiteboard where each node is allowed to write at most one message. Every node can read the contents of the whiteboard and, when activated, can write one small message based on its local knowledge. When the protocol terminates its output is computed from the final contents of the whiteboard. We describe four synchronization models for accessing the whiteboard. We show that message size and synchronization power constitute two orthogonal hierarchies for these systems. We exhibit problems that separate these models, i.e., that can be solved in one model but not in a weaker one, even with increased message size. These problems are related to maximal independent set and connectivity. We also exhibit problems that require a given message size independently of the synchronization model.

Abstract geometrical computation 8: Small machines, accumulations & rationality

In the context of abstract geometrical computation, computing with colored line segments, we study the possibility of having an accumulation with small signal machines, ie, signal machines having only a very limited number of distinct speeds. The cases of 2 and 4 speeds are trivial: we provide a proof that no machine can produce an accumulation in the case of 2 speeds and exhibit an accumulation with 4 speeds. The main result is the twofold case of 3 speeds. On the one hand, we prove that accumulations cannot happen when all ratios between speeds and all ratios between initial distances are rational. On the other hand, we provide examples of an accumulation in the case of an irrational ratio between 2 speeds and in the case of an irrational ratio between two distances in the initial configuration. This dichotomy is explained by the presence of a phenomenon computing Euclids algorithm (gcd): it stops if and only if its input is commensurate (ie, of rational ratio).

Average Binary Long-Lived Consensus: Quantifying the Stabilizing Role Played by Memory

Consider a system composed of nsensors operating in synchronous rounds. In each round an input vectorof sensor readings xis produced, where the i-th entry of xis a binary value produced by the i-th sensor. The sequence of input vectors is assumed to be smooth: exactly one entry of the vector changes from one round to the next one. The system implements a fault-tolerant averaging consensus functionf. This function returns, in each round, a representative output valuevof the sensor readings x. Assuming that at most tentries of the vector can be erroneous, fis required to return a value that appears at least t+ 1 times in x. The instabilityof the system is the number of output changes over a random sequence of input vectors. Our first result is to design optimal instability consensus systems with and without memory. Roughly, in the memoryless case, we show that an optimal system is D 0 , that outputs 1 unless it is forced by the fault-tolerance requirement to output 0 (on vectors with tor less 1s). For the case of systems with memory, we show that an optimal system is D 1 , that initially outputs the most common value in the input vector, and then stays with this output unless forced by the fault-tolerance requirement to change (i.e., a single bit of memory suffices). Our second result is to quantify the gain factor due to memory by computing c n (t), the number of decision changes performed by D 0 per each decision change performed by D 1 . If

The Impact of Locality on the Detection of Cycles in the Broadcast Congested Clique Model

t=\frac{n}{2}

Transformations and Preservation of Self-assembly Dynamics through Homotheties

the system is always forced to decide the simple majority and, in that case, memory becomes useless. We show that the same type of phenomenon occurs when