Performing computations

Early work in DNA computing by Len Adleman investigated the feasibility of using custom designed DNA molecules to solve NP-complete problems by performing massively parallel computations. The general concept is to have huge numbers of individual molecular complexes which nondeterministically each select a potential solution to a given instance of an NP-complete problem and then each perform the necessary computation to determine if the selected solution is correct. As long as there is a way to easily select the correct answers from the sea of failures, the hope was to provide a method to quickly solve such problems by harnessing the massive numbers of molecules which can compute in parallel. Adleman was able to solve a version of the Hamiltonian path problem for a graph of 7 vertices, proving the concept. Since then, a series of results by Brun , Cheng et al. , Cheng and Xiao , and Wang et al. have continued to demonstrate the theoretical ability of the aTAM to solve such problems. Unfortunately, however, as the size of a problem instance approaches useful sizes (e.g. even a few hundred nodes for a graph problem), the exponential number of possible solutions inevitably destroys the utility of this approach, for reasonably-sized inputs requiring the number of assemblies to be at least equivalent to the number of particles in the universe.

While tile-based self-assembly may not be practically useful for solving computationally intractable NP-complete problems, there are still many other interesting problems to ask about its computational power. While the previously mentioned methods for solving such problems was to use many assemblies in parallel, it is interesting to consider what is possible for any individual assembly in terms of computation. Since the aTAM has been shown to be computationally universal, a single seeded assembly can simulate an arbitrary Turing machine. However, there are even more complicated computations which can be considered, and in doing so one of the fundamental characteristics of tile-based self-assembly is confronted: computational space, which is consumed by tiles attaching to an assembly, is analogous to write-once memory. Once a tile is placed, having performed its part of the computation (by converting the information encoded by its input glues into information encoded by its output glues), it can never change or be removed. This causes difficulties related to performing computations which are unique to such a physical model, and the following results have helped to uncover the complex ways in which geometry can be related to computation.

In , Patitz and Summers showed that a set of natural numbers \(D \subseteq \mathbb{N}\) is decidable if and only if \(D \times \{0\}\) and \(D^c \times \{0\}\) weakly self-assemble. That is, the canonical representations of \(D\) and the complement of \(D\) weakly self-assemble. For \(D \times \{0\}\) to weakly self-assemble, at every point along the \(x\)-axis such that the value of the \(x\) coordinate is contained in \(D\), the tile placed at that location is colored black. All other locations remain either untiled or receive a tile which is not black. The construction for is a relatively straightforward ``stacking of Turing machine simulations, so that a given Turing machine \(M\) which decides the language in question is first simulated on input \(0\), then immediately above that \(M(1)\) is simulated, etc. As each simulation completes, the ``answer of whether or not that input is in the language is propagated via a one-tile-wide path down the side of the previous computations to the \(x\)-axis where the appropriately colored tile attaches.

In , Lathrop, Lutz, Patitz, and Summers answered the more complicated question of whether a similar result applied to computably enumerable (a.k.a. recursively enumerable) languages. They showed that a set of natural numbers \(D \subseteq \mathbb{N}\) is computably enumerable if and only if the set \(X_A = \{(f(n),0) | n \in D \}\) weakly self-assembles (where \(f\) is a roughly quadratic function). For that construction, since any Turing machine \(M\) used to determine membership in \(D\) cannot be guaranteed to halt for non-members, the simple ``stacking construction cannot work. Instead, the construction performs the infinite series of computations side-by-side, spread out along the \(x\)-axis (hence the need for \(f\)), providing a potentially infinite amount of tape space for each computation while ensuring that none of them collide and a path to the relevant point on the \(x\)-axis always remains available for cases in which a black tile must be placed. The space reserved for each computation is achieved by a scheme in which each computation proceeds with each row simply copying the row beneath it for most rows, and then with a frequency half that of the computation to its immediate left, a row performs a new step of the computation. This, combined with a unique and well-defined slope for the assembly representing each computation ensures that the potentially infinite space requirements for every computation can be assured.

On the other hand, showing a limitation to the power of computation by self-assembly in the aTAM, in they showed there there exist decidable sets of pairs of integers, or points (i.e. \(D \subseteq \mathbb{Z}^2\)), which do not weakly self-assemble in the aTAM. Their proof leverages the fact that space is not reusable in aTAM assembly, and that new space must therefore constantly be used to perform each subsequent step of a computation. They designed a pattern consisting of an infinite sequence of concentric diamonds which were centered on the origin and whose diameters were specified by a decidable set of natural numbers. By employing the time hierarchy theorem , they were able to show that there exist sets of diameters whose time complexity is so great (i.e. the amount of time required to computer whether a value is in the set) that if the pattern of diamonds with those diameters could self-assemble it would contradict the time complexity of the set. Essentially, the computation to determine whether or not the diamond at some particular diameter should be included in the pattern could not be performed by tiles from within that diamond and must therefore use space that may be required to mark subsequent diamonds. This result shows a limitation to the computational power of the aTAM, and the strong correlation between geometry and computation within it.