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

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

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

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

Producibility in Hierarchical Self-assembly

Three results are shown on producibility in the hierarchical model of tile self-assembly. It is shown that a simple greedy polynomial-time strategy decides whether an assembly α is producible. The algorithm can be optimized to use O(|α | log2 |α|) time. Cannon, Demaine, Demaine, Eisenstat, Patitz, Schweller, Summers, and Winslow [5] showed that the problem of deciding if an assembly α is the unique producible terminal assembly of a tile system T can be solved in O(|α|2|T | + |α||T |2) time for the special case of noncooperative “temperature 1” systems. It is shown that this can be improved to O(|α||T | log |T |) time. Finally, it is shown that if two assemblies are producible, and if they can be overlapped consistently – i.e., if the positions that they share have the same tile type in each assembly – then their union is also producible.

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

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

Verification and Computation in Restricted Tile Automata

Many models of self-assembly have been shown to be capable of performing computation. Tile Automata was recently introduced combining features of both Celluar Automata and the 2-Handed Model of self-assembly both capable of universal computation. In this work we study the complexity of Tile Automata utilizing features inherited from the two models mentioned above. We first present a construction for simulating Turing Machines that performs both covert and fuel efficient computation. We then explore the capabilities of limited Tile Automata systems such as 1-Dimensional systems (all assemblies are of height 1) and freezing Systems (tiles may not repeat states). Using these results we provide a connection between the problem of finding the largest uniquely producible assembly using n states and the busy beaver problem for non-freezing systems and provide a freezing system capable of uniquely assembling an assembly whose length is exponential in the number of states of the system. We finish by exploring the complexity of the Unique Assembly Verification problem in Tile Automata with different limitations such as freezing and systems without the power of detachment

Verification and Computation in Restricted Tile Automata

Many models of self-assembly have been shown to be capable of performing computation. Tile Automata was recently introduced combining features of both Celluar Automata and the 2-Handed Model of self-assembly both capable of universal computation. In this work we study the complexity of Tile Automata utilizing features inherited from the two models mentioned above. We first present a construction for simulating Turing Machines that performs both covert and fuel efficient computation. We then explore the capabilities of limited Tile Automata systems such as 1-Dimensional systems (all assemblies are of height 1) and freezing Systems (tiles may not repeat states). Using these results we provide a connection between the problem of finding the largest uniquely producible assembly using n states and the busy beaver problem for non-freezing systems and provide a freezing system capable of uniquely assembling an assembly whose length is exponential in the number of states of the system. We finish by exploring the complexity of the Unique Assembly Verification problem in Tile Automata with different limitations such as freezing and systems without the power of detachment

Probabilistic Analysis of Self-assembly

Probabilistic Analysis of Self-assembl