Winfree’s abstract Tile Assembly Model (aTAM) is one of the most popular abstract models for DNA nano-computing. This papers presents a seedless version of the aTAM. Instead of a designated seed assembly, any single isolated tile can initiate the assembly. This paper shows that such system can simulate any aTAM system at constant scale and it presents a tile set to do so. All systems can be simulated at scale at most 10 and most of them can be simulated at scale 5, provided that their seeds are large enough. Removing the need for seed in self-assembly is a new way of solving the nucleation problem, that is, the problem of controlling the initialisation of any self-assembly process. It also allows for a convergence of the aTAM towards other classical tiling models, such as Wang’s. The systems presented are based on independent modules made of tiles. The modules are carefully designed so they act kind of like stem cells. When a module self-assembles from an isolated tile, it grows a pseudo-seed which represents the seed of the simulated system with a Hamiltonian cycle along the borders of the corresponding macrotiles. The other modules, which appear later on during the simulation as components of the "regular" macrotiles, depend on each other to self-assemble. In such cases, the assembly is synchronised in a way so that the growth of any pseudo-seed is blocked. This ensures that a macrotile self-assembles only when interacting either with the pseudo-seed or with previously completed macrotiles.

Abstract This paper answers a long-standing open question in tile-assembly theory, namely that it is possible to strictly assemble discrete self-similar fractals (DSSFs) in the abstract Tile-Assembly Model (aTAM). We prove this in 2 separate ways, each taking advantage of a novel set of tools. One of our constructions shows that specializing the notion of a quine , a program which prints its own output, to the language of tile-assembly naturally induces a fractal structure. The other construction introduces self-describing circuits as a means to abstractly represent the information flow through a tile-assembly construction and shows that such circuits may be constructed for a relative of the Sierpinski carpet, and indeed many other DSSFs, through a process of fixed-point iteration. This later result, or more specifically the machinery used in its construction, further enable us to provide a polynomial time procedure for deciding whether any given subset of $$\mathbb {Z}^2$$ will generate an aTAM producible DSSF. To this end, we also introduce the Tree Pump Theorem , a result analogous to the important Window Movie Lemma , but with requirements on the set of productions rather than on the self-assembling system itself. This paper is an extension of a version that appeared in the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’25).

In this paper we study the relationship between mathematical models of tile-based self-assembly which differ in terms of the synchronicity of tile additions. In the standard abstract Tile Assembly Model (aTAM), each step of assembly consists of a single tile being added to an assembly. At any given time, each location on the perimeter of an assembly to which a tile can legally bind is called a frontier location, and for each step of assembly one frontier location is randomly selected and a tile is added. In the Synchronous Tile Assembly Model (syncTAM), at each step of assembly every frontier location simultaneously receives a tile. Our results show that while directed, non-cooperative syncTAM systems are capable of universal computation (while directed, non-cooperative aTAM systems are known not to be), and they are capable of building shapes that can't be built within the aTAM, the non-cooperative aTAM is also capable of building shapes that can't be built within the syncTAM even cooperatively. We show a variety of results that demonstrate the similarities and differences between these two models.

This paper answers a long-standing open question in tile-assembly theory, namely that it is possible to strictly assemble discrete self-similar fractals (DSSFs) in the abstract Tile-Assembly Model (aTAM). We prove this in 2 separate ways, each taking advantage of a novel set of tools. One of our constructions shows that specializing the notion of a quine, a program which prints its own output, to the language of tile-assembly naturally induces a fractal structure. The other construction introduces self-describing circuits as a means to abstractly represent the information flow through a tile-assembly construction and shows that such circuits may be constructed for a relative of the Sierpinski carpet, and indeed many other DSSFs, through a process of fixed-point iteration. This later result, or more specifically the machinery used in its construction, further enable us to provide a polynomial time procedure for deciding whether any given subset of ℤ2 will generate an aTAM producible DSSF. To this end, we also introduce the Tree Pump Theorem, a result analogous to the important Window Movie Lemma, but with requirements on the set of productions rather than on the self-assembling system itself.

International audience

The broadcast congested clique model (BClique) is a message-passing model of distributed computation where $n$ nodes communicate with each other in synchronous rounds. First, in this paper we prove that there is a one-round, deterministic algorithm that reconstructs the input graph $G$ if the graph is $d$-degenerate, and rejects otherwise, using bandwidth $b=\mathcal{O}(d \cdot \log n)$. Then, we introduce a new parameter to the model. We study the situation where the nodes, initially, instead of knowing their immediate neighbors, know their neighborhood up to a fixed radius $r$. In this new framework, denoted ${{\sc BClique}}[r]$, we study the problem of detecting, in $G$, an induced cycle of length at most $k$ (${\sc Cycle}_{\leq k}$) and the problem of detecting an induced cycle of length at least $k+1$ (${\sc Cycle}_{>k}$). We give upper and lower bounds. We show that if each node is allowed to see up to distance $r={\lfloor k/2 \rfloor + 1}$, then a polylogarithmic bandwidth is sufficient for solving ${\sc Cycle}_{>k}$ with only two rounds. Nevertheless, if nodes were allowed to see up to distance $r=\lfloor k/3 \rfloor$, then any one-round algorithm that solves ${\sc Cycle}_{>k}$ needs the bandwidth $b$ to be at least $\Omega(n/\log n)$. We also show the existence of a one-round, deterministic ${{\sc BClique}}$ algorithm that solves ${\sc Cycle}_{\leq k}$ with bandwitdh $b=\mathcal{O}(n^{1/\lfloor{k/2}\rfloor} \cdot \log n)$. On the negative side, we prove that, if $\epsilon \leq 1/3$ and $0 < r \leq k/4 $, then any $\epsilon$-error, $R$-round, $b$-bandwidth algorithm in the ${{\sc BClique}}[r]$ model that solves problem ${\sc Cycle}_{\leq k}$ satisfies $R \cdot b = \Omega(n^{1/\lfloor{k/2}\rfloor})$.

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.

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 and streaming 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 {\it 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.

In this paper we ask which properties of a distributed network can be computed from a few amount of local information provided by its nodes. The distributed model we consider is a restriction of the classical CONGEST (distributed) model and it is close to the simultaneous messages (communication complexity) model defined by Babai, Kimmel and Lokam. More precisely, each of these n nodes-which only knows its own ID and the IDs of its neighbors- is allowed to send a message of O(log n) bits to some central entity, called the referee. Is it possible for the referee to decide some basic structural properties of the network topology G? We show that simple questions like, "does G contain a square?", "does G contain a triangle?" or "Is the diameter of G at most 3?" cannot be solved in general. On the other hand, the referee can decode the messages in order to have full knowledge of G when G belongs to many graph classes such as planar graphs, bounded tree width graphs and, more generally, bounded degeneracy graphs. We leave open questions related to the connectivity of arbitrary graphs.