New Geometric Algorithms for Fully Connected Staged Self-Assembly

We consider staged self-assembly systems, in which square-shaped tiles can be added to bins in several stages. Within these bins, the tiles may connect to each other, depending on the glue types of their edges. Previous work by Demaine et al. showed that a relatively small number of tile types suffices to produce arbitrary shapes in this model. However, these constructions were only based on a spanning tree of the geometric shape, so they did not produce full connectivity of the underlying grid graph in the case of shapes with holes; designing fully connected assemblies with a polylogarithmic number of stages was left as a major open problem. We resolve this challenge by presenting new systems for staged assembly that produce fully connected polyominoes in O(log^2 n) stages, for various scale factors and temperature {\tau} = 2 as well as {\tau} = 1. Our constructions work even for shapes with holes and uses only a constant number of glues and tiles. Moreover, the underlying approach is more geometric in nature, implying that it promised to be more feasible for shapes with compact geometric description.Comment: 21 pages, 14 figures; full version of conference paper in DNA2

Verification in Staged Tile Self-Assembly

We prove the unique assembly and unique shape verification problems, benchmark measures of self-assembly model power, are $\mathrm{coNP}^{\mathrm{NP}}$-hard and contained in $\mathrm{PSPACE}$ (and in $\mathrm{\Pi}^\mathrm{P}_{2s}$ for staged systems with $s$ stages). En route, we prove that unique shape verification problem in the 2HAM is $\mathrm{coNP}^{\mathrm{NP}}$-complete.Comment: An abstract version will appear in the proceedings of UCNC 201

Optimal Staged Self-Assembly of General Shapes

We analyze the number of tile types $t$, bins $b$, and stages necessary to assemble $n \times n$ squares and scaled shapes in the staged tile assembly model. For $n \times n$ squares, we prove $\mathcal{O}(\frac{\log{n} - tb - t\log t}{b^2} + \frac{\log \log b}{\log t})$ stages suffice and $\Omega(\frac{\log{n} - tb - t\log t}{b^2})$ are necessary for almost all $n$. For shapes $S$ with Kolmogorov complexity $K(S)$, we prove $\mathcal{O}(\frac{K(S) - tb - t\log t}{b^2} + \frac{\log \log b}{\log t})$ stages suffice and $\Omega(\frac{K(S) - tb - t\log t}{b^2})$ are necessary to assemble a scaled version of $S$, for almost all $S$. We obtain similarly tight bounds when the more powerful flexible glues are permitted.Comment: Abstract version appeared in ESA 201

Optimal staged self-assembly of linear assemblies

We analyze the complexity of building linear assemblies, sets of linear assemblies, and O(1)-scale general shapes in the staged tile assembly model. For systems with at most b bins and t tile types, we prove that the minimum number of stages to uniquely assemble a 1 n line is (logt n + logb n t + 1). Generalizing to O(1) n lines, we prove the minimum number of stages is O( log n tb t log t b2 + log log b log t ) and ( log n tb t log t b2 ). Next, we consider assembling sets of lines and general shapes using t = O(1) tile types. We prove that the minimum number of stages needed to assemble a set of k lines of size at most O(1) n is O( k log n b2 + k p log n b + log log n) and ( k log n b2 ). In the case that b = O( p k), the minimum number of stages is (log n). The upper bound in this special case is then used to assemble \hefty shapes of at least logarithmic edge-length-to- edge-count ratio at O(1)-scale using O( p k) bins and optimal O(log n) stages

Self-Assembly of Arbitrary Shapes Using RNAse Enzymes: Meeting the Kolmogorov Bound with Small Scale Factor (extended abstract)

We consider a model of algorithmic self-assembly of geometric shapes out of square Wang tiles studied in SODA 2010, in which there are two types of tiles (e.g., constructed out of DNA and RNA material) and one operation that destroys all tiles of a particular type (e.g., an RNAse enzyme destroys all RNA tiles). We show that a single use of this destruction operation enables much more efficient construction of arbitrary shapes. In particular, an arbitrary shape can be constructed using an asymptotically optimal number of distinct tile types (related to the shape's Kolmogorov complexity), after scaling the shape by only a logarithmic factor. By contrast, without the destruction operation, the best such result has a scale factor at least linear in the size of the shape, and is connected only by a spanning tree of the scaled tiles. We also characterize a large collection of shapes that can be constructed efficiently without any scaling

Unique Assembly Verification in Two-Handed Self-Assembly

One of the most fundamental and well-studied problems in Tile Self-Assembly is the Unique Assembly Verification (UAV) problem. This algorithmic problem asks whether a given tile system uniquely assembles a specific assembly. The complexity of this problem in the 2-Handed Assembly Model (2HAM) at a constant temperature is a long-standing open problem since the model was introduced. Previously, only membership in the class coNP was known and that the problem is in P if the temperature is one (τ=1). The problem is known to be hard for many generalizations of the model, such as allowing one step into the third dimension or allowing the temperature of the system to be a variable, but the most fundamental version has remained open.In this paper, we prove the UAV problem in the 2HAM is hard even with a small constant temperature (τ=2), and finally answer the complexity of this problem (open since 2013). Further, this result proves that UAV in the staged self-assembly model is coNP-complete with a single bin and stage (open since 2007), and that UAV in the q-tile model is also coNP-complete (open since 2004). We reduce from Monotone Planar 3-SAT with Neighboring Variable Pairs, a special case of 3SAT recently proven to be NP-hard. We accompany this reduction with a positive result showing that UAV is solvable in polynomial time with the promise that the given target assembly will have a tree-shaped bond graph, i.e., contains no cycles. We provide a O(n5) algorithm for UAV on tree-bonded assemblies when the temperature is fixed to 2, and a O(n5logτ) time algorithm when the temperature is part of the input

Active Self-Assembly of Algorithmic Shapes and Patterns in Polylogarithmic Time

We describe a computational model for studying the complexity of self-assembled structures with active molecular components. Our model captures notions of growth and movement ubiquitous in biological systems. The model is inspired by biology's fantastic ability to assemble biomolecules that form systems with complicated structure and dynamics, from molecular motors that walk on rigid tracks and proteins that dynamically alter the structure of the cell during mitosis, to embryonic development where large-scale complicated organisms efficiently grow from a single cell. Using this active self-assembly model, we show how to efficiently self-assemble shapes and patterns from simple monomers. For example, we show how to grow a line of monomers in time and number of monomer states that is merely logarithmic in the length of the line. Our main results show how to grow arbitrary connected two-dimensional geometric shapes and patterns in expected time that is polylogarithmic in the size of the shape, plus roughly the time required to run a Turing machine deciding whether or not a given pixel is in the shape. We do this while keeping the number of monomer types logarithmic in shape size, plus those monomers required by the Kolmogorov complexity of the shape or pattern. This work thus highlights the efficiency advantages of active self-assembly over passive self-assembly and motivates experimental effort to construct general-purpose active molecular self-assembly systems

Algorithmic Assembly of Nanoscale Structures

The development of nanotechnology has become one of the most significant endeavors of our time. A natural objective of this field is discovering how to engineer nanoscale structures. Limitations of current top-down techniques inspire investigation into bottom-up approaches to reach this objective. A fundamental precondition for a bottom-up approach is the ability to control the behavior of nanoscale particles. Many abstract representations have been developed to model systems of particles and to research methods for controlling their behavior. This thesis develops theories on two such approaches for building complex structures: the self-assembly of simple particles, and the use of simple robot swarms. The concepts for these two approaches are straightforward. Self-assembly is the process by which simple particles, following the rules of some behavior-governing system, naturally coalesce into a more complex form. The other method of bottom-up assembly involves controlling nanoscale particles through explicit directions and assembling them into a desired form. Regarding the self-assembly of nanoscale structures, we present two construction methods in a variant of a popular theoretical model known as the 2-Handed Tile Self-Assembly Model. The first technique achieves shape construction at only a constant scale factor, while the second result uses only a constant number of unique particle types. Regarding the use of robot swarms for construction, we first develop a novel technique for reconfiguring a swarm of globally-controlled robots into a desired shape even when the robots can only move maximally in a commanded direction. We then expand on this work by formally defining an entire hierarchy of shapes which can be built in this manner and we provide a technique for doing so

Fractals, Randomization, Optimal Constructions, and Replication in Algorithmic Self-Assembly

The problem of the strict self-assembly of infinite fractals within tile self-assembly is considered. In particular, tile assembly algorithms are provided for the assembly of the discrete Sierpinski triangle and the discrete Sierpinski carpet. The robust random number generation problem in the abstract tile assembly model is introduced. First, it is shown this is possible for a robust fair coin flip within the aTAM, and that such systems guarantee a worst case O(1) space usage. This primary construction is accompanied with variants that show trade-offs in space complexity, initial seed size, temperature, tile complexity, bias, and extensibility. This work analyzes the number of tile types t, bins b, and stages necessary and sufficient to assemble n × n squares and scaled shapes in the staged tile assembly model. Further, this work shows how to design a universal shape replicator in a 2-HAM self-assembly system with both attractive and repulsive forces