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

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

Fuel Efficient Computation in Passive Self-Assembly

In this paper we show that passive self-assembly in the context of the tile self-assembly model is capable of performing fuel efficient, universal computation. The tile self-assembly model is a premiere model of self-assembly in which particles are modeled by four-sided squares with glue types assigned to each tile edge. The assembly process is driven by positive and negative force interactions between glue types, allowing for tile assemblies floating in the plane to combine and break apart over time. We refer to this type of assembly model as passive in that the constituent parts remain unchanged throughout the assembly process regardless of their interactions. A computationally universal system is said to be fuel efficient if the number of tiles used up per computation step is bounded by a constant. Work within this model has shown how fuel guzzling tile systems can perform universal computation with only positive strength glue interactions. Recent work has introduced space-efficient, fuel-guzzling universal computation with the addition of negative glue interactions and the use of a powerful non-diagonal class of glue interactions. Other recent work has shown how to achieve fuel efficient computation within active tile self-assembly. In this paper we utilize negative interactions in the tile self-assembly model to achieve the first computationally universal passive tile self-assembly system that is both space and fuel-efficient. In addition, we achieve this result using a limited diagonal class of glue interactions

Covert Computation in Staged Self-Assembly: Verification Is PSPACE-Complete

Staged self-assembly has proven to be a powerful abstract model of self-assembly by modeling laboratory techniques where several nanoscale systems are allowed to assemble separately and then be mixed at a later stage. A fundamental problem in self-assembly is Unique Assembly Verification (UAV), which asks whether a single final assembly is uniquely constructed. This has previously been shown to be ?^{p}?-hard in staged self-assembly with a constant number of stages, but a more precise complexity classification was left open related to the polynomial hierarchy. Covert Computation was recently introduced as a way to compute a function while hiding the input to that function for self-assembly systems. These Tile Assembly Computers (TACs), in a growth only negative aTAM system, can compute arbitrary circuits, which proves UAV is coNP-hard in that model. Here, we show that the staged assembly model is capable of covert computation using only 3 stages. We then utilize this construction to show UAV with only 3 stages is ?^{p}?-hard. We then extend this technique to open problems and prove that general staged UAV is PSPACE-complete. Measuring the complexity of n stage UAV, we show ?^{p}_{n - 1}-hardness. We finish by showing a ?^{p}_{n + 1} algorithm to solve n stage UAV leaving only a constant gap between membership and hardness

One-dimensional staged self-assembly

17th International Conference, DNA 17, Pasadena, CA, USA, September 19-23, 2011. ProceedingsWe introduce the problem of staged self-assembly of one-dimensional nanostructures, which becomes interesting when the elements are labeled (e.g., representing functional units that must be placed at specific locations). In a restricted model in which each operation has a single terminal assembly, we prove that assembling a given string of labels with the fewest stages is equivalent, up to constant factors, to compressing the string to be uniquely derived from the smallest possible context-free grammar (a well-studied O(logn)-approximable problem). Without this restriction, we show that the optimal assembly can be substantially smaller than the optimal context-free grammar, by a factor of Ω √n/log n even for binary strings of length n. Fortunately, we can bound this separation in model power by a quadratic function in the number of distinct glues or tiles allowed in the assembly, which is typically small in practice

Randomness, information encoding, and shape replication in various models of DNA-inspired self-assembly

Self-assembly is the process by which simple, unorganized components autonomously combine to form larger, more complex structures. Researchers are turning to self-assembly technology for the design of ever smaller, more complex, and precise nanoscale devices, and as an emerging fundamental tool for nanotechnology. We introduce the robust random number generation problem, the problem of encoding a target string of bits in the form of a bit string pad, and the problem of shape replication in various models of tile-based self-assembly. Also included are preliminary results in each of these directions with discussion of possible future work directions

Polyominoes Simulating Arbitrary-Neighborhood Zippers and Tilings

This paper provides a bridge between the classical tiling theory and the complex neighborhood self-assembling situations that exist in practice. The neighborhood of a position in the plane is the set of coordinates which are considered adjacent to it. This includes classical neighborhoods of size four, as well as arbitrarily complex neighborhoods. A generalized tile system consists of a set of tiles, a neighborhood, and a relation which dictates which are the "admissible" neighboring tiles of a given tile. Thus, in correctly formed assemblies, tiles are assigned positions of the plane in accordance to this relation. We prove that any validly tiled path defined in a given but arbitrary neighborhood (a zipper) can be simulated by a simple "ribbon" of microtiles. A ribbon is a special kind of polyomino, consisting of a non-self-crossing sequence of tiles on the plane, in which successive tiles stick along their adjacent edge. Finally, we extend this construction to the case of traditional tilings, proving that we can simulate arbitrary-neighborhood tilings by simple-neighborhood tilings, while preserving some of their essential properties.Comment: Submitted to Theoretical Computer Scienc

Encoding Color Sequences in Active Tile Self-Assembly

Constructing patterns is a well-studied problem in both theoretical and experimental self-assembly with much of the work focused on multi-staged assembly. In this paper, we study building 1D patterns in a model of active self assembly: Tile Automata. This is a generalization of the 2-handed assembly model that borrows the concept of state changes from Cellular Automata. In this work we further develop the model by partitioning states as colors and show lower and upper bounds for building patterned assemblies based on an input pattern. Our first two sections utilize recent results to build binary strings along with Turing machine constructions to get Kolmogorov optimal state complexity for building patterns in Tile Automata, and show nearly optimal bounds for one case. For affinity strengthening Tile Automata, where transitions can only increase affinity so there is no detachment, we focus on scaled patterns based on Space Bounded Kolmogorov Complexity. Finally, we examine the affinity strengthening freezing case providing an upper bound based on the minimum context-free grammar. This system utilizes only one dimensional assemblies and has tiles that do not change color