1-Output Logic Implementation Demonstrated by DNA

Subscriber access provided by Warwick University Library

3-Input/1-Output Logic Implementation Demonstrated by DNA Algorithmic Self-Assembly Hyunjae Cho, Sekhar Babu Mitta, Yongwoo Song, Junyoung Son, Suyoun Park, Tai Hwan Ha, and Sung Ha Park ACS Nano, Just Accepted Manuscript • DOI: 10.1021/acsnano.8b00068 • Publication Date (Web): 23 Apr 2018 Downloaded from http://pubs.acs.org on April 24, 2018

Just Accepted “Just Accepted” manuscripts have been peer-reviewed and accepted for publication. They are posted online prior to technical editing, formatting for publication and author proofing. The American Chemical Society provides “Just Accepted” as a service to the research community to expedite the dissemination of scientific material as soon as possible after acceptance. “Just Accepted” manuscripts appear in full in PDF format accompanied by an HTML abstract. “Just Accepted” manuscripts have been fully peer reviewed, but should not be considered the official version of record. They are citable by the Digital Object Identifier (DOI®). “Just Accepted” is an optional service offered to authors. Therefore, the “Just Accepted” Web site may not include all articles that will be published in the journal. After a manuscript is technically edited and formatted, it will be removed from the “Just Accepted” Web site and published as an ASAP article. Note that technical editing may introduce minor changes to the manuscript text and/or graphics which could affect content, and all legal disclaimers and ethical guidelines that apply to the journal pertain. ACS cannot be held responsible for errors or consequences arising from the use of information contained in these “Just Accepted” manuscripts.

is published by the American Chemical Society. 1155 Sixteenth Street N.W., Washington, DC 20036 Published by American Chemical Society. Copyright © American Chemical Society. However, no copyright claim is made to original U.S. Government works, or works produced by employees of any Commonwealth realm Crown government in the course of their duties.

Page 1 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

3-Input/1-Output Logic Implementation Demonstrated by DNA Algorithmic Self-Assembly

Hyunjae Cho,† Sekhar Babu Mitta,† Yongwoo Song,† Junyoung Son,† Suyoun Park,† Tai Hwan Ha*,§,‡ and Sung Ha Park*,†

†

Department of Physics and Sungkyunkwan Advanced Institute of Nanotechnology (SAINT), Sungkyunkwan University, Suwon 16419, Korea §

Hazards Monitoring BNT Research Center,

Korea Research Institute of Bioscience and Biotechnology (KRIBB), Daejeon 34141, Korea ‡

Department of Nanobiotechnology, KRIBB School of Biotechnology,

Korea University of Science and Technology (UST), Daejeon 34113, Korea

ACS Paragon Plus Environment

ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ABSTRACT: Although structural DNA nanotechnology is a well-established field, computations performed using DNA algorithmic self-assembly is still in the primitive stages in terms of its adaptability of rule implementation and experimental complexity. Here, we discuss the feasibility of constructing an M-input/N-output logic gate implemented into simple DNA building blocks. To date, no experimental demonstrations have been reported with M > 2 owing to the difficulty of tile design. To overcome this problem, we introduce a special tile referred to as an operator. We design appropriate binding domains in DNA tiles, and we demonstrate the growth of DNA algorithmic lattices generated by eight different rules from among 256 rules in a 3-input/1-output logic. The DNA lattices show simple, line-like, random and mixed patterns, which we analyse to obtain errors and sorting factors. The errors vary from 0.8% to 12.8% depending upon the pattern complexity, and sorting factors obtained from the experiment are in good agreement with simulation results within a range of 1 ~ 18%.

KEYWORDS: DNA, self-assembly, DNA lattice, algorithm, logic implementation


Page 2 of 26

Page 3 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

Nowadays, molecular computing is considered an unconventional but efficient method of computing complex problems which exist in nature. Because of the large information density, high energy efficiency and effective parallel computation capabilities, there are certain advantages with using molecules in computation. Using various types of molecular computers, there have been attempts to solve many distinct problems (e.g. the Hamiltonian path problem, chess problem, logic-gate algorithmic implementation, and neural network demonstration) which require large computational time or which have high complexity.1–12 Of the various types of molecules, DNA is conceived as one of the most promising molecules in computation owing to the base-sequence programmability, bottom-up self-assembly as well as relatively stable biomolecules.13 Consequently, for the past 30 years, DNA molecules have been extensively studied in the field of nanotechnology, which is known as DNA nanotechnology, and there has been special focus

on

developing

dimensional

nanostructure

constructions

and

specific

functionalization via molecular modifications.14–20 In addition, there has been much attention on the demonstration of algorithmic self-assembly (for complex pattern generation, autonomous computation and complex circuit fabrication) using DNA molecules with relatively simple manipulation in order to realize molecular computation.21–23 The field of structural DNA nanotechnology, which investigates the design of novel nanostructures, characterizing nanomaterial-embedded DNA templates, and fabricating functionalized devices or sensors is well established.24–30 However, DNA algorithmic self-assembly is still in the early developmental stages with respect to the universality

of

rule

implementation

and

the

demonstration

of

experimental

complexity.13,31 There remain certain limitations to the use of DNA algorithmic selfassembly broadly because of the lower method adoptability, difficulty with implementing


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

binding domains and geometrical interference when designing building blocks. The design characteristics (i.e. generalized M-input/N-output logic implementation and the design methodology of binding domains) and performing an experimental demonstration with systematic analysis are seldom discussed. In this study, we discuss the feasibility of performing an experiment using M-input/N-output logic gates (in particular M > 2) which are implemented into simple DNA building blocks, and which demonstrate multiple logic gates (i.e. 256 (= 28) rules in 3-input/1-output), employing a full description of the binding domain design. In order to overcome the difficulties associated with implementing higher inputs (M > 2) in DNA building blocks, we introduce an operator block. The operators are placed between rulebuilding blocks, propagate information from input to output rule blocks and enable us to design rules with values of M greater than 2. Distinct patterns such as simple, line-like, random and mixed patterns are generated by specific rules from among the 256 in the 3-input/1-output logic gate, and we analysed them thoroughly based on experimental observation in order to understand the error and sorting mechanisms of the patterns.

RESULTS AND DISCUSSION Design of 3-input/1-output logic implementation via rectangular building blocks. The generation of algorithmic patterns using M-input/N-output logic-implemented abstract building blocks has been an interesting subject of one-dimensional (1D) cellular automata (described in Figure 1).32–34 In this study, we considered 3-input/1-output logic gates because M-input/N-output logic gates (in particular M > 2) which are implemented into simple building blocks have rarely been discussed. There were 256 (= 28) different rules (from R000 to R255) available in a 3-input/1-output logic with 8 (from binary of 000 to 111) and 256 (the sequence of 8 binary digits from 00000000 to 11111111) kinds


Page 4 of 26

Page 5 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

of inputs and outputs, respectively. One of the rules, i.e. R110, which can be demonstrated as an example of universal computation,35 had an output which was a serial of 8-digit numbers of 01101110 (which corresponded to the decimal number 110), and was highlighted by yellow (indicated as a 0-bit) and brown (as a 1-bit) cells on its output column (Figure 1a). Because of the different outputs of each rule, every rule had its own two-dimensional (2D) characteristic pattern which was due to block algorithmic assembly. In order to test the feasibility of using an abstract building block having binding domains of 2 for input and 2 for output, operator building blocks (OP) were introduced to generate 2D algorithmic patterns produced by the M-input/N-output logic (where M > 2, N = 1). Without an OP, a rectangular building block (which is called a rule block (RU) containing either 0- or 1-bit information represented as a yellow or brown block in Figure 1b) had a certain geometrical limitation to implement the M-input/N-output logic gate (e.g. M = 3, N = 1). Although information in the 2 bits from the two previous RUs can be delivered to the next RU (indicated by the blue arrows), the remaining bit cannot be transferred (indicated by the red arrows) owing to the limited number of binding domains. Even if we introduce an RU which has a sufficient number of binding domains, it is difficult to design proper rules to construct a 2D algorithmic lattice because of spacial interference. Schematics for the implementation of the 3-input/1-output logic gate with the aid of OPs are shown in Figure 1c and 1d. OPs (shown as gray) which are placed between the RUs deliver bit information from the previous RUs to the next. Because an OP is bound with two RUs, OPs containing four kinds of input information, i.e. 00, 01, 10 and 11 had to be introduced. Consequently, two OPs (to acquire and transfer information) are needed to build a single 3-input/1-output operation. Of the eight different inputs, two


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

inputs of 010 and 100 in R110 with corresponding outputs of 1 and 0, respectively, are shown in Figure 1c. Two consecutive inputs, i.e. 010 (with an orange-coloured boundary) and 100 (pink) of R110 are shown in an algorithmic lattice (displayed up to the growth of two successive steps; initialized from the nth-step and grown up to the (n + 2)nd-step) in Figure 1d. In addition, an example of a set of inputs, 01001, for the 5-input/1-output logic gate was also marked as a green. Our proposed approach with OPs may be applicable with an odd number of M and 1 of N such as the 5-input/1-output logic gate.

Design and interpretation of binding domains in rule and operator building blocks for all 256 possible rules of 3-input/1-output logic gate. The nomenclature and binding-domain assignment of RU and OP are displayed in Figure 2a. Here, RUX1X2X3 stands for two input domains (X1X2) and one output (X3, there are two domains, but only one character is marked because two domains are the same) in an RU (e.g. RU000 and RU101 indicate 00 input & 0 output and 10 input & 1 output, respectively). Similarly, OPX1X2X3X4 stands for two input domains (X1X2) and two outputs (X3X4) in an OP (e.g. OP0000 and OP1010 indicate 00 input & 00 output and 10 input & 10 output, respectively). Five different binding domains (i.e. s0B’, s1B’, sCB’, s0A’ and s1A’) were designed for RU, and the other five domains (i.e. s0A, s1A, s0B, s1B, sCB) were designed for OP (Figure 2a and Figure S1 in the supporting information). Prime and non-prime domains with the same name were designed to bind each other. For information regarding the transfer from RU to OP, output domains of RU on the right side (marked as s0A’ for RUXX0 and s1A’ for RUXX1) and input domains of OP on the left (as s0A & s0A, s0A & s1A, s1A & s0A and s1A & s1A for OP00XX, OP01XX, OP10XX and OP11XX, respectively) were determined. Undetermined domains which are inputs of RU on the left side (indicated by black rectangles called bi’


Page 6 of 26

Page 7 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

and tj’) and outputs of OP on the right (displayed by white rectangles called t0, b0, t1, b1, t2, b2, t3 and b3) are about to be selected by one of three kinds of binding domains (s0B’, s1B’, sCB’ for RU and s0B, s1B, sCB for OP). Eight possible combinations of OPs should be considered for a 3-input/1-output logic gate (Figure 2b). Two bound OP blocks which are obtained from the input RUs can be categorized as the eight cases. For information regarding the transfer from OP to RU, output-binding domains (indicated by cyan boxes, i.e. (b3, t3), (b3, t2), (b2, t1), (b2, t0), (b1, t3), (b1, t2), (b0, t1) and (b0, t0)) have to be designed accordingly based on a given rule. Consequently, an RU was determined. For instance, an RUb0t01 and an RUb0t00 have to be chosen for a 000 input (consisting of three RUXX0) of R255 and R110, respectively (Figure 2c). In order to find sets of RUs and OPs which have proper binding domains, a computational algorithm which can handle all possible sets of binding domains in RU and OP was conceived, and a corresponding flow chart of the algorithm is shown in Figure 2d. Initially, variables of OP outputs (i.e. (b3, t3), (b3, t2), (b2, t1), (b2, t0), (b1, t3), (b1, t2), (b0, t1) and (b0, t0)) as well as a rule (chosen from 256 rules) are provided. This process leads to finding sets of RU and OP for a given rule. The sets, S0 and S1 (containing binding domains of 0 and 1 RU blocks, respectively) should be disjointed. For R110, S0 and S1 consisted of corresponding arguments (i.e. S0 = {(b3, t3), (b2, t0), (b0, t0)}, S1 = {(b3, t2), (b2, t1), (b1, t3), (b1, t2), (b0, t1)}). To consider all cases of binding domain sets, the algorithmic process (with a variable of iteration number k) was iterated within the range 0 to 38‒ 1 (i.e. from ternary of 00000000(3) to 22222222(3)) owing to the three kinds of binding domains, s0B, s1B, sCB in OP and s0B’, s1B’, sCB’ in RU. Finally, the eight variables in OP outputs were determined, and they corresponded to the ternary number obtained from the given iteration (e.g., when the number k equals 1234, t0 = 0, t1 = 1, t2 = 2, t3 = 0, b0 = 0, b1 = 2, b2 = 0, b3 = 1 which corresponds to 01200201(3)).


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Each figure in the ternary number matched binding domains (0 for s0B, 1 for s1B and 2 for sCB) in outputs of OP. The arguments, (b2,t0) = (2,0) in S0 and (b1,t3) = (2,0) in S1 marked in red have to be discarded because the sets do not satisfy the disjoint condition. After completion of the process, whole sets of available S0 and S1 are obtained. Based on the observation of the process, of the 256 rules, 192 (e.g. R004, R105, and R126) and 64 (e.g. R108 and R218) can be employed to design binding domains between OP (outputs, tj and bi) and RU (inputs, bi’ and tj’) with two (chosen from among s0B, s1B and sCB in OP and s0B’, s1B’ and sCB’ in RU) and three (s0B, s1B and sCB in OP and s0B’, s1B’ and sCB’ in RU) binding domains, respectively (Figure S2).

Experimental demonstration of four distinct classes for a 3-input/1-output logic implementation using DNA tile-based algorithmic self-assembly. To realize 3-input/1-output algorithmic self-assembly, rectangular-shaped doublecrossover (DX) DNA tiles were used as unit building blocks for RU and OP. The unit sequence-designed DX tile with dimensions of 13 × 4 nm2 (length × width) was composed of double-stranded helices connected by two crossover junctions16. Each DX tile consists of four DNA strands, each of which participates in both helices (For more details, see Figure S1). Owing to the robustness of the structure, the ease of implementation of bit information via protruding duplex hairpins (corresponding to an RU with 1-bit marked with brown colour), and the efficient programmability of stickyends (served as binding domains which function using Watson-Crick base-pairing), the DX tile which we used was one of the best candidates for 3-input/1-output algorithmic self-assembly. Here, RU and OP blocks made of DX tiles (with 3.5 full-turn length) had opposite 5’ to 3’ directionalities in their strands, which made alternative binding of RUs and OPs during the growth of a DNA algorithmic lattice.


Page 8 of 26

Page 9 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

Eight specific rules (R000, R004, R105, R108, R110, R126, R218 and R255) from among 256 algorithmic patterns from the 3-input/1-output logic operation were implemented on RU and OP DX tiles, and were demonstrated experimentally, as shown in Figures 3 and 4. The minimum number of required tile sets, which consisted of RU and OP building blocks, depended solely on a given rule (shown by a truth table. Examples are shown in the first columns of Figures 3 and 4), and can be determined computationally (as discussed in the previous section). RU and OP tile sets with detailed binding domains indicated by colour-coded symbols on both sides and corresponding sticky-end base sequences in DX tiles are shown in the second columns of Figures 3, 4, and in Figure S1 and Table S1 in the supporting information. Interestingly, algorithmic self-assembled DNA patterns which implemented any of the 256 rules (of 3-input/1output logic gates designed by our computational process) can be demonstrated using only 30 different DNA stands, as shown in Tables S2 ~ S6. Although a slightly greater number of RUs than the minimum number in a set can be designed (e.g. R110 with 5 RUs in Figure 4b), we mostly used the minimum number of RU tiles (containing either 0- or 1-bit information) which were in the range of 2 ~ 6 (e.g. 2 for R000, R255, 4 for R004, R105, R110, R126, and 6 for R218, R108). In contrast, the number of OPs which was 4 did not depend on rules. Although R000 (R255), which had all 0s (1s) of outputs required only a RU of 0, i.e. RU000 (an RU of 1, i.e. RU111) during the growth of the lattices, an RU of 1, i.e. RU111 in R000 (an RU of 0, i.e. RU000 in R255) was provided to random growth. Algorithmic lattices with the corresponding rule sets grown up to the 3rd-step of growth (with initial values of 01011) are shown in the third column in Figures 3 and 4. The reading direction of the initial values and the layer growth direction of lattices are indicated by cyan and purple arrows, respectively. Algorithmic lattices with the classification of distinct characteristic patterns


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

which were generated by simulations and which were grown experimentally were discussed (Figures 3 and 4). We generated lattice patterns up to the 128th-step with 128 random initial values for R110 using five RU tiles (Figure 4b), as well as up to the 16thstep with 32 random initial values (e.g. magnified patterns with random initial values with the reading direction are shown in the insets of Figure 3a and Figure 4a) for eight distinct rules in order to recognize the general pattern formation. Characteristic patterns produced by the 3-input/1-output logic gate can be classified by their complexities as follows: simple patterns with no dependencies of initial values, ordered line-like patterns, random small-scale structure (e.g. triangle) embedded patterns and mixed patterns comprising random and ordered ones which are called class 1, class 2, class 3 and class 4, respectively.33 Two representative rules from each class were constructed experimentally, i.e. R000, R255 for class 1, R004, R108 for class 2, R105, R126 for class 3 and R110, R218 for class 4. Representative atomic force microscope (AFM) images of DNA lattices embedded with the eight different rules, which roughly agreed with the computergenerated patterns, are displayed at the far right in Figures 3 and 4.

AFM images and analysis of errors and sorting factors of algorithmic lattices formed by different rules. Figure 5a ~ f showed representative AFM images of algorithmic lattices formed by rules of R000, R255, R108, R105, R110(4) and R110(5). Here, the parenthesis in R110 indicates the total number (i.e. 4 or 5) of RU tiles in each tile set. The vertical and horizontal arrows shown in Figure 5a indicate the reading direction of randomly generated initial values and the direction of DNA lattice growth, respectively. The overlaid guide lines of individual RU (unfilled rectangle) and OP (filled with gray) are marked in AFM images with a scan size of 200 × 200 nm2 for better visualization of the


Page 10 of 26

Page 11 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

experimental data. The lattices began to grow from the random initial values located in the first column of AFM images. RU tiles without and with green dots representing hairpins are read as a 0- and a 1-bit, respectively, and RUs with yellow crosses indicate improper RU bindings to a lattice, and is considered an error. Figure 5g displays a bar graph of the average errors obtained from the experimental AFM data. The error, which was defined as the percentage of the ratio of the number of errors to the total number of RU tiles, arose as a result of assembling incorrect tiles during the propagation of information both from RU to OP and from OP to RU tiles. Errors occurred mainly because of the disproportionate of tiles during the course of annealing. The errors ranged from 0.8% to 12.8% depending on the rules (i.e. simple pattern errors of 1.5% for R000, 0.8% for R255, line-like errors of 12.17% for R004, 12.18% for R108, random-like errors of 12.39% for R105, 12.82% for R126, and mixed errors of 10.5% for R110, 7.14% for R218). Owing to the random initial values produced without boundaries, the errors measured in this work were slightly greater (except R000 and R255) than the previously reported ones (roughly between 1% and 10%).21-23 Errors with the simplest (class 1, R000 or R255) and complex (class 3, R105 or R126) patterns of the four classes gave the lowest and highest numerical values, respectively, as we expected. Stacked histogram of average sorting factors (Γ) of DNA lattices and simulationbased algorithmic lattices incorporated with specific algorithmic rules obtained from experimental (E) and simulation (S) data, respectively are shown in Figure 5h. A 0-bit (1bit) sorting factor, Γ0 (Γ1), which is indicated as white (black), is defined as the total number of 0-bit (1-bit) RUs over the total number of RUs at a given area, which describes the 0 (1)-bit population in the DNA lattices grown by the specific rules. Here, Γ had the following characteristics; (i) the sum of Γ0 and Γ1 has to be 1 (i.e. Γ0 + Γ1 = 1), (ii)


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Γ0 or 1 has to be within the range of 0 ~ 1 (0 ≤ Γ0 or 1 ≤ 1), (iii) zero of Γ0 (Γ1) means no 0 (1) RUs in a lattice, (iv) Γ0 = 1 (Γ1 =1) means that all 0 (1) RUs in a lattice without 1 (0), and (v) 0 and 1 RUs have the same number of 0- and 1-bit tiles in the lattice when Γ0 = Γ1 = 0.5. Albeit the equimolar concentration of RU tiles (e.g. RU000, RU0C0, RUC00 and RUCC1 for R004) in a sample tube was kept constant at 100 nM, Γ0 or 1 depended greatly on a given rule. Consequently, Γ provided an indirect degree of the proper implementation of rules on a DNA algorithmic lattice with a specific rule. For instance, the experimental and simulation results of Γ0 (Γ1) for R004 were 0.68 (0.32) and 0.86 (0.14), which indicated that there was a difference of 18% (= |0.68 ‒ 0.86| × 100) between experimental and simulation results. The experimental and simulation values of the average Γ0 (Γ1) for R255, which was analysed by the algorithmically self-assembled DNA lattices and the computational calculations, were 0.02 (0.98) and 0.03 (0.97), respectively. The value of 0.02 for Γ0, which was obtained from the experiment, corresponded to six RU tiles having no hairpins, while when Γ1 = 0.98, it corresponded to 266 of the 272 RU tiles with hairpins in a given AFM image (similar to Figure 5b) with a scan size of 200 × 200 nm2. For the other rules, the values of Γ0 and Γ1 are shown in Figure 5h. The overall average sorting factors obtained from the experimental data were in good agreement with simulation results, and varied within the range of 1 ~ 18%.

CONCLUSIONS We addressed a methodology for implementing the 3-input/1-output logic gate by employing the DNA algorithmic self-assembly using specially designed rule (RU) and operator (OP) building blocks. Using computational processes, we developed an efficient way of designing binding domains in building blocks for all 256 rules in 3-input/1-output


Page 12 of 26

Page 13 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

logic gate. This process provided all possible combinations of RU and OP tiles to construct specific DNA algorithmic patterns governed by the given rules. To enable us to implement a logic gate having more than two inputs on DNA tiles (up to the present, no experimental demonstration has been reported owing to the difficulty of tile design and complexity of logic gates), the OP was considered. The OPs which were placed between RUs received information from two RUs and delivered that information to an RU. Our design scheme with OPs enables us to demonstrate DNA algorithmic assembly using DNA strands efficiently and economically, and enabled us to design a logic gate having more than two inputs. We demonstrated eight distinct rules (i.e. R000, R004, R105, R108, R110, R126, R218 and R255) of the 3-input/1-output logic gate, and we categorized them into four classes. Each class had a distinct pattern, such as simple (R000, R255), line-like (R004, R108), random (R105, R126) and mixed (R110, R218) patterns. Finally, algorithmic errors which occurred during the growth of the DNA lattice, and sorting factors which described the bit population in the DNA lattice were analysed thoroughly based on experimental AFM images. Depending on the given rules, the errors varied from 0.8% to 12.8%. As we expected, the errors became larger with an increased complexity of the algorithmic patterns. The simplest (average value of 1.2% for class 1) and most complex (12.6% for class 3) patterns among the four classes gave the lowest and highest errors, respectively. Besides, the overall average sorting factors obtained from the experimental data were in good agreement with simulation results, and the percentage differences ranged from 1 ~ 18%.


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Page 14 of 26

METHODS Fabrication of algorithmic DNA lattices: Synthetic oligonucleotides, purified by highperformance liquid chromatography, were purchased from Integrated DNA Technologies (IA, USA). In order to obtain algorithmic DNA lattices, a two-step annealing method was adopted. Individual tiles (both RUs and OPs) were formed by mixing a stoichiometric quantity of each strand in buffer, 1× TAE/Mg2+ (Tris-acetate-EDTA: 40 mM Tris, 1 mM EDTA (pH 8.0), 12.5 mM magnesium acetate). A final concentration of 1

M was

achieved. For 1st-step annealing, the sample test tubes were placed in a Styrofoam box with 2 L of boiled water, and were then cooled slowly from 95 to 25°C over a period of at least 24 h to facilitate the hybridization process. Then, equal amounts of annealed individual RU and OP tiles of a given rule were added together into a new test tube. A final tile concentration of 100 nM with a total volume of 50 µL was obtained. Finally (2nd-step annealing), the sample test tube was then cooled gradually from 40 to 25°C by placing the sample in 2 L of water in a Styrofoam box to facilitate further hybridization.

AFM Imaging: The AFM image of the 3-input/1-output logic algorithmic DNA lattices was obtained by pipetting 5 µL of an annealed sample onto a freshly cleaved mica substrate (with a size of 5 × 5 mm2), followed by incubation for ~30 seconds. 40 µL of 1× TAE/Mg2+ buffer were then pipetted onto the substrate, and another 20 µL of 1× TAE/Mg2+ buffer were dispensed on an oxide-sharpened silicon nitride AFM tip (Veeco Inc., CA, USA). All of the AFM images were obtained using a Digital Instruments Nanoscope III (Veeco Inc., CA, USA) in the tapping mode with a multimode fluid cell head.


Page 15 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

■ ASSOCIATED CONTENT Supporting Information The Supporting Information is available free of charge on the ACS Publications website at DOI: XX.XXXX/acs.nano.XXXXXXX. Design of rectangular building blocks and corresponding double-crossover DNA tiles, sticky-ends name and corresponding DNA base sequences, list of rules and corresponding rule (RU) and operator (OP) tiles, and design of a RU and OP tile set and experimental demonstration of DNA algorithmic lattices.

■ AUTHOR INFORMATION Corresponding Authors *E-mail: [email protected]. *E-mail: [email protected]. ORCID Sung Ha Park: 0000-0002-0256-3363 Author Contributions H.C., S.B.M., and Y.S. contributed equally to this work. Funding This research was supported by grants from the Korea Research Institute of Bioscience and Biotechnology (KRIBB) Research Initiative Program and from the National Research Foundation (NRF) of Korea (2017R1D1A1B03035053, 2018R1A2B6008094).


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Page 16 of 26

■ REFERENCES (1) Adleman, L. M.

Molecular

Computation

of

Solutions

to

Combinatorial

Problems. Science 1994, 266, 1021–1024. (2) Lipton, R. J. DNA Solution of Hard Computational Problems. Science 1995, 268, 542–545. (3) Guarnieri, F.; Fliss, M.; Bancroft, C. Making DNA Add. Science 1996, 273, 220–223. (4) Ouyang, Q.; Kaplan, P. D.; Liu, S.; Libchaber, A. DNA Solution of the Maximal Clique Problem. Science 1997, 278, 446–449. (5) Faulhammer, D.; Cukras, A. R.; Lipton, R. J.; Landweber, L. F. Molecular Computation: RNA Solutions to Chess Problems. Proc. Natl. Acad. Sci. U. S. A. 2000, 97, 1385–1389. (6) Mao, C.; LaBean, T. H.; Reif, J. H.; Seeman, N. C. Logical Computation Using Algorithmic Self-assembly of DNA Triple-Crossover Molecules. Nature 2000, 407, 493–496. (7) Benenson, Y.; Paz-Elizur, T.; Adar, R.; Keinan, E.; Livneh, Z.; Shapiro, E. Programmable and Autonomous Computing Machine Made of Biomolecules. Nature 2001, 414, 430–434. (8) Braich, R. S.; Chelyapov, N.; Johnson, C.; Rothemund, P. W. K.; Adleman, L. Solution of a 20-Variable 3-SAT Problem on a DNA Computer. Science 2002, 296, 499–502. (9) Rothemund, P. W. K.; Papadakis, N.; Winfree, E. Algorithmic Self-Assembly of DNA Sierpinski Triangles. PLOS Biol. 2004, 2, 2041–2053. (10) Qian, L.; Winfree, E. Scaling Up Digital Circuit Computation with DNA Strand Displacement Cascades. Science 2011, 332, 1196–1201. (11) Qian, L.; Winfree, E.; Bruck, J. Neural Network Computation with DNA Strand


Page 17 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

Displacement Cascades. Nature 2011,475, 368–372. (12) Woo, S.; Rothemund, P. W. K. Programmable Molecular Recognition Based on the Geometry of DNA Nanostructures. Nat. Chem. 2011, 3, 620–627. (13) Winfree, E. On The Computational Power of DNA Annealing and Ligation. In DNA Based Computing; Lipton, E. J., Baum, E. B., Eds.; American Mathematical Society: Providence, RI, 1996, 27, 199−219. (14) Seeman, N. C. Nucleic Acid Junctions and Lattices. J. Theor. Biol. 1982, 99, 237– 247. (15) Fu, T. J.; Seeman, N. C. DNA Double-Crossover Molecules. Biochemistry 1993, 32, 3211–3220. (16) Winfree, E.; Liu, F.; Wenzler, L. A.; Seeman, N. C. Design and Self-Assembly of Two-Dimensional DNA Crystals. Nature 1998, 394, 539–544. (17) Park, S. H.; Barish, R.; Li, H.; Reif, J. H.; Finkelstein, G.; Yan, H.; LaBean, T. H. Three-Helix Bundle DNA Tiles Self-Assemble into 2D Lattice or 1D Templates for Silver Nanowires. Nano Lett. 2005, 5, 693–696. (18) He, Y.; Chen, Y.; Liu, H.; Ribbe, A. E.; Mao, C. Self-Assembly of Hexagonal DNA Two-Dimensional (2D) Arrays. J. Am. Chem. Soc. 2005, 127, 12202–12203. (19) Park, S. H.; Pistol, C.; Ahn, S. J.; Reif, J. H.; Lebeck, A. R.; Dwyer, C.; LaBean, T. H. Finite-Size, Fully Addressable DNA Tile Lattices Formed by Hierarchical Assembly Procedures. Angew. Chem., Int. Ed. 2006, 45, 735–739. (20) He, Y.; Ye, T.; Su, M.; Zhang, C.; Ribbe, A. E.; Jiang, W.; Mao, C. Hierarchical SelfAssembly of DNA Into Symmetric Supramolecular Polyhedral. Nature 2008, 452, 198–201. (21) Barish, R. D.; Rothemund, P. W. K.; Winfree, E. Two Computational Primitives for Algorithmic Self-Assembly: Copying and Counting. Nano Lett. 2005, 5, 2586–2592.


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

(22) Fujibayashi, K.; Hariadi, R.; Park, S. H.; Winfree, E.; Murata, S. Toward Reliable Algorithmic Self-Assembly of DNA Tiles: A Fixed-Width Cellular Automaton Pattern. Nano Lett. 2008, 8, 1791–1797. (23) Fujibayashi, K.; Murata, S. Precise Simulation Model for DNA Tile Self-Assembly. IEEE Trans. Nanotechnol. 2009, 8, 361–368. (24) Rothemund, P. W. K. Folding DNA to Create Nanoscale Shapes and Patterns. Nature 2006, 440, 297–302. (25) Yin, P.; Hariadi, R. F.; Sahu, S.; Choi, H. M. T.; Park, S. H.; LaBean, T. H.; Reif, J. H. Programming DNA Tube Circumferences. Science 2008, 321, 824–826. (26) Ke, Y.; Ong, L. L.; Shih, W. M.; Yin, P. Three-Dimensional Structures SelfAssembled from DNA Bricks. Science 2012, 338, 1177–1183. (27) Douglas, S. M.; Bachelet, I.; Church, G. M. A Logic-Gated Nanorobot for Targeted Transport of Molecular Payloads. Science 2012, 335, 831–834. (28) Wei, B.; Dai, M.; Yin, P. Complex Shapes Self-Assembled from Single-Stranded DNA Tiles. Nature 2012, 485, 623–626. (29)

Roller, E.

M.; Khorashad, L.

K.; Fedoruk, M.; Schreiber, R.; Govorov, A.

O.; Liedl, T. DNA-Assembled Nanoparticle Rings Exhibit Electric and Magnetic Resonances at Visible Frequencies. Nano Lett. 2015, 15, 1368–1373. (30) Dugasani, S. R.; Hwang, T.; Kim, J. A.; Gnapareddy, B.; Kim, T.; Park, S. H. Metal Electrode Dependent Field Effect Transistors Made of Lanthanide Ion-Doped DNA Crystals. J. Phys. D: Appl. Phys. 2016, 49, 105501. (31) Winfree, E.; Yang, X.; Seeman, N. C. Universal Computation via Self-Assembly of DNA: Some Theory and Experiments; DNA Based Comput. II: 1999, 44, 191–213. (32) Lohn, J. D.; Reggia, J. A. Automatic Discovery of Self-Replicating Structures in Cellular Automata. IEEE Trans. Evol. Comp. 1997, 1, 165–178.


Page 18 of 26

Page 19 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

(33) Wolfram, S. A New Kind of Science (Wolfram Media, 2002). (34) Kim, J.; Ha, T. H.; Park, S. H. Substrate-Assisted 2D DNA Lattices and Algorithmic Lattices from Single-Stranded Tiles. Nanoscale 2015, 7, 12336–12342. (35) Cook, M. A Concrete View of Rule 110 Computation. Electron. Proc. Theor. Comput. Sci. 2009, 1, 31–55.


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Figures

Figure 1. Design of 3-input/1-output logic implementation demonstrated by rectangular building blocks. (a) The truth table for the 3-input/1-output logic gate. 256 (= 28) rules are available. One of the rules, i.e. R110 is highlighted in yellow (indicated as a 0-bit) and brown (as a 1-bit) cells on its output column. (b) Geometrical limitation to implement the 3-input/1-output logic gate by a rectangular building block having 2-input and 2-output binding domains. By using the blocks (referred to as rule blocks which each contain single-bit information), 2-bit information from two rule blocks can be delivered to the next growth layer (indicated by blue arrows), but a remaining bit cannot be transferred (shown as red). (c) Implementation of the 3-input/1-output logic gate introduced by the operator blocks. Two operator blocks (shown as gray) which are placed between the rule blocks can transfer information from the previous 3-bit rule block layer to the next 1-bit rule block. Two representative inputs, i.e. 010 and 100, of R110 are displayed. (d) A representative algorithmic lattice of the M-input/N-output block assembly. Two consecutive inputs, 010 and 100 of R110, for the 3-input/1-output logic gate are highlighted by the orange- and pink-coloured boundaries, respectively. In addition, an example of an input, 01001 for the 5-input/1-output logic gate, is marked as green. Here, n indicates the step number of the growth layer for rule blocks.


Page 20 of 26

Page 21 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

Figure 2. Binding domain design of a building block set for a given 3-input/1-output logic gate. (a) Binding domain assignment of rule (RU) and operator (OP) blocks. For information regarding the transfer from RU to OP, output domains of RU on the right side (referred to as s0A’ for RU XX0 and s1A’ for RU XX1) and input domains of OP on the left (referred to as s0B & s0B, s0B & s1B, s1B & s0B and s1B & s1B for OP 00XX, OP 01XX, OP 10XX and OP11XX, respectively) are determined. Undetermined domains which are inputs of RU on the left side (shown by black rectangles referred to as bi’ and tj’) and outputs of OP on the right (displayed by white rectangles referred to as t0, b0, t1, b1, t2, b2, t3 and b3) are about to be selected by one of three kinds of binding domains (s0B’, s1B’ and sCB’ for RU, and s0B, s1B and sCB for OP). (b) Eight possible combinations of OPs for a 3-input/1-output logic gate. Two bound OP blocks which are obtained from the input RUs can be categorized as the eight cases. For information regarding the transfer from OP to RU, output binding domains (indicated by cyan boxes, i.e. (b3, t3), (b3, t2), (b2, t1), (b2, t0), (b1, t3), (b1, t2), (b0, t1) and (b0, t0)) should be designed. (c) Determination of an RU block. An RU is selected by a given rule. For instance, an RU b0t01 and an RU b0t00 have to be chosen for a 000 input (consisting of three RU XX0) of R255 and R110, respectively. (d) A flow chart for finding RU and OP block sets having proper binding domains. Variables of OP outputs and a rule are provided. This process leads us to find sets of RU and OP for a certain algorithmic rule. The sets, S0 and S1 (containing binding domains of 0 and 1 RU blocks, respectively) should be disjoint. For example, R110 at k = 1234 is described on the right, where k is the number of iterations of the process, ranging from 0 to 38 ‒ 1. The arguments, (b2,t0) = (2,0) in S0 and (b1,t3) = (2,0) in S1, which are marked in red have to be discarded because the sets do not satisfy


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

the disjoint condition. After completion of the process, whole sets of available S0 and S1 are obtained.

Figure 3. Experimental demonstration of three distinct classes (class 1 through class 3) for a 3-input/1-output logic implementation via DNA tile-based algorithmic selfassembly. (a-f) Classification of six representative patterns, e.g. R000, R255 for class 1, R004, R108 for class 2, and R105, R126 for class 3. Each class pattern has specific characteristics. Classes 1, 2 and 3 display simple patterns with no dependencies of initial values, ordered line-like patterns and random triangle-embedded patterns, respectively.


Page 22 of 26

Page 23 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

Truth tables, rule (RU) and operator (OP) tile sets with detailed binding information are shown in the 1st and 2nd columns. Binding domains of RU and OP building blocks are replaced by the appropriate sticky-ends sequences in DNA tiles. Algorithmic lattices grown up to the 3rd (with initial values of 01011 located at a step number n = 1) and 16th (with 32 computer-generated random initial values) steps of the RU are shown in the 3rd and 4th columns. The reading direction of initial values and the layer growth direction of lattices are indicated by cyan and purple arrows, respectively. Representative atomic force microscope images which are in close agreement with the computer-generated patterns are displayed at the far right. All scan image sizes are 200 × 200 nm2.

Figure 4. Experimental demonstration of a class 4 via DNA tile-based algorithmic selfassembly. (a-c) Design schemes and experimental results of class 4 patterns, e.g. R110 (with 4 and 5 RU tiles) and R218. Class 4 displays mixed patterns ‒ mixed random and ordered ones. Truth tables, RU (4 and 5 RU tile designs for R110 and 6 RU tile design for R218) and OP sets are displayed. Algorithmic lattices grown up to the 3rd (with initial values of 01011) and 16th (128th with random 128 initial values for b) steps of the RU are shown. Representative AFM images of R110 and R218 with scan sizes of 200 × 200 nm2 are displayed in the far right column.


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Figure 5. Representative atomic force microscope images and analysis of errors and sorting factors of algorithmic lattices formed by different rules. (a-f) Representative AFM images of R000, R255, R108, R105, R110(4), and R110(5). Simple (R000, R255), linelike (R108), random-like (R105) and mixed (R110) patterns are classified as class 1, 2, 3 and 4 respectively, and are displayed. Here, the parentheses in R110(4) and R110(5) indicate the total number of RU tiles used in R110. The vertical (marked as a cyan line) and horizontal (purple) arrows in the upper-left corner indicate the reading direction of initial values (randomly generated) and the direction of DNA lattice growth, respectively. The overlaid guide lines of the individual rule (RU) and operator (OP, filled with gray) tiles are marked for better visualization of experimental data. RU tiles without and with a hairpin (indicated by a green dot) are read as a 0-bit and 1-bit, respectively, and the yellow crosses in RU indicate errors. The lattices are initiated to grow based on the generation of random initial values shown in the first column of each logic gate. The scan size of all of the AFM images is 200 × 200 nm2. (g) Histogram representation of error


Page 24 of 26

Page 25 of 26 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

ACS Nano

analysis obtained from the experimental data. The error is defined as the percentage of the ratio of number of errors to the total number of RU tiles. (h) Stacked histogram of sorting factor analysis obtained from experimental data (E) and simulations (S). A 0-bit (1-bit) sorting factor indicated as white (black) is defined by the total number of 0-bit (1bit) tiles over the total number of RU tiles in a given area, which describes the bitpopulation in the DNA lattices grown by the specific rules. The overall average sorting factors obtained from the experimental data are in good agreement with simulation results.


ACS Nano 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

3-Input/1-Output Logic Implementation Demonstrated by DNA Algorithmic Self-Assembly

Table of contents


Page 26 of 26

1-Output Logic Implementation Demonstrated by DNA

Recommend Documents