13 research outputs found
Optimal Staged Self-Assembly of General Shapes
We analyze the number of tile types , bins , and stages necessary to
assemble squares and scaled shapes in the staged tile assembly
model. For squares, we prove stages suffice and
are necessary for almost all .
For shapes with Kolmogorov complexity , we prove
stages suffice and are necessary to
assemble a scaled version of , for almost all . We obtain similarly tight
bounds when the more powerful flexible glues are permitted.Comment: Abstract version appeared in ESA 201
Verification in Staged Tile Self-Assembly
We prove the unique assembly and unique shape verification problems,
benchmark measures of self-assembly model power, are
-hard and contained in (and in
for staged systems with stages). En route,
we prove that unique shape verification problem in the 2HAM is
-complete.Comment: An abstract version will appear in the proceedings of UCNC 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 Any Shape with Constant Tile Types using High Temperature
Inspired by nature and motivated by a lack of top-down tools for precise nanoscale manufacture, self-assembly is a bottom-up process where simple, unorganized components autonomously combine to form larger more complex structures. Such systems hide rich algorithmic properties - notably, Turing universality - and a self-assembly system can be seen as both the object to be manufactured as well as the machine controlling the manufacturing process. Thus, a benchmark problem in self-assembly is the unique assembly of shapes: to design a set of simple agents which, based on aggregation rules and random movement, self-assemble into a particular shape and nothing else. We use a popular model of self-assembly, the 2-handed or hierarchical tile assembly model, and allow the existence of repulsive forces, which is a well-studied variant. The technique utilizes a finely-tuned temperature (the minimum required affinity required for aggregation of separate complexes).
We show that calibrating the temperature and the strength of the aggregation between the tiles, one can encode the shape to be assembled without increasing the number of distinct tile types. Precisely, we show one tile set for which the following holds: for any finite connected shape S, there exists a setting of binding strengths between tiles and a temperature under which the system uniquely assembles S at some scale factor. Our tile system only uses one repulsive glue type and the system is growth-only (it produces no unstable assemblies). The best previous unique shape assembly results in tile assembly models use O(K(S)/(log K(S))) distinct tile types, where K(S) is the Kolmogorov (descriptional) complexity of the shape S
Covert Computation in the Abstract Tile-Assembly Model
There have been many advances in molecular computation that offer benefits such as targeted drug delivery, nanoscale mapping, and improved classification of nanoscale organisms. This power led to recent work exploring privacy in the computation, specifically, covert computation in self-assembling circuits. Here, we prove several important results related to the concept of a hidden computation in the most well-known model of self-assembly, the Abstract Tile-Assembly Model (aTAM). We show that in 2D, surprisingly, the model is capable of covert computation, but only with an exponential-sized assembly. We also show that the model is capable of covert computation with polynomial-sized assemblies with only one step in the third dimension (just-barely 3D). Finally, we investigate types of functions that can be covertly computed as members of P/Poly
Engaging Students during Research through the Use of Games
Engaging students during a research seminar/meeting can be a difficult challenge, and as as student myself, I can attest to how difficult actively listening to a presentation can be. As such, upon researching more ways to have an audience engaged, one of the most promising concepts is the use of games. Games, in any form, can be very engaging to a person, and even more so if there is active engagement and participation within an audience group. With this concept in mind, I decided to take it upon myself to create a game based around a theoretical computer science model, and see if I can have newcomers learn how the theoretical model works faster than during a normal presentation. I have worked with the concept of games various times before, and as such, I will include that work in this thesis for the sake of theme, and to argue that learning with games tends to be a lot easier than traditional forms of learning
Building Squares with Optimal State Complexity in Restricted Active Self-Assembly
Tile Automata is a recently defined model of self-assembly that borrows many concepts from cellular automata to create active self-assembling systems where changes may be occurring within an assembly without requiring attachment. This model has been shown to be powerful, but many fundamental questions have yet to be explored. Here, we study the state complexity of assembling n × n squares in seeded Tile Automata systems where growth starts from a seed and tiles may attach one at a time, similar to the abstract Tile Assembly Model. We provide optimal bounds for three classes of seeded Tile Automata systems (all without detachment), which vary in the amount of complexity allowed in the transition rules. We show that, in general, seeded Tile Automata systems require Θ(log^{1/4} n) states. For Single-Transition systems, where only one state may change in a transition rule, we show a bound of Θ(log^{1/3} n), and for deterministic systems, where each pair of states may only have one associated transition rule, a bound of Θ(({log n}/{log log n})^{1/2})
Building Squares with Optimal State Complexity in Restricted Active Self-Assembly
Tile Automata is a recently defined model of self-assembly that borrows many concepts from cellular automata to create active self-assembling systems where changes may be occurring within an assembly without requiring attachment. This model has been shown to be powerful, but many fundamental questions have yet to be explored. Here, we study the state complexity of assembling n × n squares in seeded Tile Automata systems where growth starts from a seed and tiles may attach one at a time, similar to the abstract Tile Assembly Model. We provide optimal bounds for three classes of seeded Tile Automata systems (all without detachment), which vary in the amount of complexity allowed in the transition rules. We show that, in general, seeded Tile Automata systems require Θ(log^{1/4} n) states. For Single-Transition systems, where only one state may change in a transition rule, we show a bound of Θ(log^{1/3} n), and for deterministic systems, where each pair of states may only have one associated transition rule, a bound of Θ(({log n}/{log log n})^{1/2})
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
Accelerating Self-Assembly of Crisscross Slat Systems
We present an abstract model of self-assembly of systems composed of "crisscross slats", which have been experimentally implemented as a single-stranded piece of DNA [Minev et al., 2021] or as a complete DNA origami structure [Wintersinger et al., 2022]. We then introduce a more physically realistic "kinetic" model and show how important constants in the model were derived and tuned, and compare simulation-based results to experimental results [Minev et al., 2021; Wintersinger et al., 2022]. Using these models, we show how we can apply optimizations to designs of slat systems in order to lower the numbers of unique slat types required to build target structures. In general, we apply two types of techniques to achieve greatly reduced numbers of slat types. Similar to the experimental work implementing DNA origami-based slats, in our designs the slats oriented in horizontal and vertical directions are each restricted to their own plane and sets of them overlap each other in square regions which we refer to as macrotiles. Our first technique extends their previous work of reusing slat types within macrotiles and requires analyses of binding domain patterns to determine the potential for errors consisting of incorrect slat types attaching at undesired translations and reflections. The second technique leverages the power of algorithmic self-assembly to efficiently reuse entire macrotiles which self-assemble in patterns following designed algorithms that dictate the dimensions and patterns of growth.
Using these designs, we demonstrate that in kinetic simulations the systems with reduced numbers of slat types self-assemble more quickly than those with greater numbers. This provides evidence that such optimizations will also result in greater assembly speeds in experimental systems. Furthermore, the reduced numbers of slat types required have the potential to vastly reduce the cost and number of lab steps for crisscross assembly experiments