It is no longer believed that DNA computing will outperform digital computers when it comes to thecomputation of intractable problems. In this paper, we emphasise the in silico implementation of DNA-inspired algorithms as the only way to compete with other algorithms for solving NP-complete problems.For this, we provide sticker algorithms for some of themost representative NP-complete graph problems.The simple data structures and bit-vertical operationsmake them suitable for some parallel architectures.The parallel algorithmsmight solve eithermoderate-size problems in an exactmanner or,when combinedwith a heuristic, large problems in polynomial time.
Although theoretically discussed by Head in 1987 [16], theconcept of DNA Computing was not adopted until 1994 whenAdleman solved a small instance of the Hamiltonian path problemwith DNA [1]. The Adleman’s experiment attracted considerableinterest from the scientific community, who were hoping thatthe massive parallelization of DNA molecules would one daybe the basis to outperform electronic computers when it comesto the computation of complex combinatorial problems [3,8,18,23,25–28]. But this vision was rapidly discarded whenresearchers realized some of the drawbacks related to thisincipient technology: a growing number of error-prone, time-consuming operations and exponential growth of DNA volumeaccording to problem size [15]. Although some attempts weremade to tackle these difficulties [5,22,24,29,33], no satisfactorysolution was found to these problems, making the novel fieldimpractical enough to be not considered as a viable technology forsolving intractable problems.In this paper, rather than in vitro, we emphasise the in silico
implementation of DNA-based algorithms as the only way tocompete with other algorithms in combinatorics. For this, weprovide sticker algorithms for solving classical NP-complete graphproblems, i.e., vertex cover, k-clique, independent set, 3-coloringproblems, bipartite subgraph, k-matching, perfect matching, andedge dominating k-set problems. Such algorithms could make useof the parallelism offered by some computational architectures,
eliminating the noisy, time-consuming operations of the in vitroapproaches. We mitigate the combinatorial complexity by usingsmall combinatorial input libraries [33], a strategy that mightenable us to solve either moderate-size problems in an exactmanner or, when combined with a heuristic, large problems inpolynomial time.The rest of the paper is organized as follows. In Section 2,
we introduce the theoretical fundamentals of DNA Computingand the sticker model. Section 3 describes the data structuresand the basic operations of the sticker algorithms. In Section 4,we describe some useful procedures for the construction of thealgorithms. In Section 5,we introduce the algorithms for the vertexcover, k-clique, 3-coloring, independent set, bipartite subgraph, k-matching, perfect matching, and edge dominating k-set problems,respectively. Finally, in Section 6 we discuss some directions forthe in silico implementation of the algorithms.
2. DNA and the sticker model
Deoxyribonucleic acid (DNA) is the molecule that encodes theinformation required to build a cell or an organism. DNA consistsof two associated polynucleotide strands that wind together inform of a double helix. It is composed of four nucleotides: adenine(A), guanine (G), cytosine (C), and thymine (T). Nucleid acids arecovalently bonded end-to-end in 5′ to 3′ direction to form single-stranded (ss) DNAmolecule. To this end, each sugar is linked to thenext via the phosphate group, creating a polymer chain composedof a repetitive sugar–phosphate backbonewith its respective basesprotruding from it. The associated antiparallel strand is bondeddue to the complementary structures of the bases, in which A ispaired with T by two hydrogen bonds, and G is paired with C by
Fig. 1. (A) 4-bit memory complexes and (B) its associated stickers.
three hydrogen bonds. DNA molecules can be thought of as basestrings allowing a number of useful operations such as matching,concatenation, and insertion. These operations are supported bythemodern techniques of DNAmanipulation and serve as buildingblocks for universal computational models [20,19].The sticker model is one of these resulting models. It belongs to
the so-called filteringmodels of classical DNAComputing, inwhichthere is a separation or filtering operation as a central mechanismof computation [28]. In particular, the stickermodel implements anidealized computing machine better known as a register machine,whose registers consist of single stranded DNA molecules of fixedlength intended to represent binary information. To this end,each data register is divided into several substrands (bits) of afixed number of nucleotides. Furthermore, there is a set of stickerstrands, each of them is complementary to only one substrandof the data register. A substrand having its annealed stickerrepresents a bit ‘on’; otherwise, it represents a bit ‘off’. The complexcomposed of a single stranded DNA molecule and its associatedstickers is calledmemory complex. In this way, a memory complexmay represent any binary number (of fixed length) as neededby just annealing the corresponding sticker at the required bitpositions of the data registers. A collection ofmemory complexes iscalled a tube, which can containmultiple copies of the same strand.The sticker model (see Fig. 1) employs a set of operations to
manipulate tubes: the combination of two tubes into a new tube(merge), the separation of a tube into two new tubes (separate),and the setting (set) and clearing (clear) of a determined bit ofevery register in a tube. These operations are bit-vertical as theymanipulate one bit position of allmemory complexes at a time. Anyfinite sequence of these operations is termed a sticker algorithm,whose complexity is given by the total number of laboratory steps.Moreover, this set of operations is robust enough to guaranteecomputational completeness [20].A sticker algorithm has a set of bit strings, called initial test tube,
as input parameters. Although the overall strategy of most stickeralgorithms is to generate an initial test tube containing a large setof potential solutions (and then to remove all non-solutions), onecould also generate an initial test tubewith approximate solutions,and construct the admisible solutions using a sticker program. Atthe end of the algorithm, one or more final test tubes contain thesolutions, if any.Originally, the stickermodel introduces the concept of the [n, k]
library as initial test tube, where n stands for the number of bits foreach strand. The first k substrands encode the inputs by turningthem on or off. The last n − k substrands are turned off; they areemployed for internal calculations. Besides, in order to guaranteethe complete combinatorial space of solutions, an [n, k] librarymust provide 2k different memory strands.The main disadvantage of this library is that the number of
strands necessary to represent all solutions will grow exponen-tially with the size of the problem. Zimmermann [33] introduced
small combinatorial input libraries, called[m,( nk
)]libraries, for
solving NP complete graph problems. Such a library consists of mbit long strands, each of them formed so that the first n substrandshave k substrands turned on and n − k substrands turned off. Sothis library provides an encoding of all subsets of k elements (k-subsets) of an n-set. The lastm− n substrands are turned off; as inthe previous library, they are employed for internal calculations.
3. Data structures and sticker operations
The sticker model is suitable for in silico implementationbecause of its simple data structures and operations. In the stickermodel, the basic unit of information is a bit or substrand. Inthis document, both terms are used interchangeably. A memorycomplex is a bit string. A tube is an array of type memory complex.An initial
[m,( nk
)]-tube contains
( nk
)memory complexes, where
eachmemory complex is anm-bit long string, fromwhich, the firstn bits have k bits turned on and n− k bits turned of. The lastm− nbits are initially turned off. We can manipulate a tube with thefollowing operations:
(i) Merge. Themerge (N1, N2, N) operation combines the contentof two input test tubes (N1, N2) to produce a new test tube(N) containing the memory complexes of the previous tubes.Alternatively, we will use the instruction merge (N1, N) toindicate that tube N1 empties its content into tube N .
(ii) Separate. The separate (N , N+, N−, i) operation divides thecontent of test tube N into two test tubes N+ and N−. Thosememory complexes whose ith substrand is set will be placedinto test tube N+; the rest will be placed into test tube N−.
(iii) Set. The set (N , i) operation turns on the ith substrand of eachmemory complex of a test tube N .
(iv) Clear. The clear (N , i) operation turns off the ith substrand ofeach memory complex of a test tube N .
(v) Discard. The discard (N) operation empties the content of atest tube N .
4. Useful subroutines
We describe some useful procedures which serve as buildingblocks for the construction of more complex sticker algorithms. Inthe following, let G = (V , E) be a finite undirected graph withvertex set V = {v1, . . . , vn} and edge set E = {e1, . . . , em}.The ith edge is denoted by ei = {vi1 , vi2}. The graph informationcan be represented by either adjacency or incidency matrix. Allalgorithms presented in this paper were programmed using theStickerSim library [30], a programming environment for thedevelopment of sticker algorithms. Although this library does notinclude the probabilistic nature of DNA computations (i.e., thekinetics and thermodynamics of DNA hybridization), it allows totest the logical behavior of sticker algorithms.
4.1. The EdgeInducedGraphs procedure
The algorithm EdgeInducedGraphs provides all subgraphs ofa graph G which are induced by the k-subsets of edges [33]. LetF ⊆ E be a subset of edges of the graph G. The graph inducedby F is a subgraph GF = (U, F) of G with vertex set U = {v ∈V | v end point of e ∈ F}. We provide a sticker algorithm whichdetermines all subgraphs of G induced by the k-subsets of the edgeset E, where 1 ≤ k ≤ m.The input of the algorithm is an
[m+ n,
(mk
)]library N0
providing the encodings of all k-subsets of edges. The algorithmoperates in a bit-vertical fashion as it considers in parallel the ithsubstrand of the memory complexes where 1 ≤ i ≤ m. Forthose memory complexes whose ith substrand is on, the edge ei
1: for i← 1 tom do2: separate(N0,N+,N−, i)3: set(N+,m+ i1)4: set(N+,m+ i2)5: merge(N+,N−,N0)6: end for7: return N0
Fig. 2. A graph G.
occurs in the corresponding k-set of edges. If the ith substrand ison, the substrands m + i1 and m + i2 are turned on indicating thevertices of the edge ei. In the final test tube, thememory complexescorrespond to the subgraphs of G which are induced by the k-setsof edges. The algorithm requires 4m steps.For instance, in view of the graph in Fig. 2 and k = 2, the
algorithm yields the following types of memory complexes
The algorithm Weightening extracts from an input test tubeN0 those memory complexes in which exactly k of the substrandsm+1, . . . ,m+n are turned on [20,33]. At the end of the loop (1–7),the data test tube Ni, 0 ≤ i ≤ n, contains all memory complexesin which exactly i of the substrands m + 1, . . . ,m + n are turnedon. The data test tube Nk provides the output of the algorithm. Thesticker algorithm requires 2n n+12 = n
2+ n steps.
Algorithm 2Weightening(N0,m, n, k)Require: input test tube N01: for i← 0 to n− 1 do2: for j← i down to 0 do3: separate(Nj,N+,N−,m+ i+ 1)4: merge(N+,Nj+1)5: merge(N−,Nj)6: end for7: end for8: return Nk
For instance, consider an input test tube N0 providing theencodings of the memory complexes 00000, 10101, 01111, 11010.Table 1 shows the computation ofWeightening with m = 0 andn = 5. The output of the algorithm is the test tube Nk so that
Algorithm 3 Complement(N0, n)
Require: [2n,(nk
)] library N0
1: for for i← 1 to n do do2: separate (N0,N+,N−, i)3: set(N−, i+ n)4: merge (N+,N−,N0)5: end for6: return N0
Table 1Computation ofWeightening
N0 N1 N2 N3 N4 N5
Initial 00000101010111111010
i = 1 00000 10101Sep. on 1 01111 11010
i = 2 00000 10101 11010Sep. on 2 01111
i = 3 00000 1101010101
Sep. on 3 01111
i = 4 00000 10101 11010Sep. on 4 01111
i = 5 00000 11010 01111Sep. on 5 10101
Table 2Computation of Complementwith n = 4 and k = 2
the test tubes Nk+1, . . . ,Nn are not required. Therefore, the secondstatement can be altered to
2 : for j← min{i, k} down to 0 do.
The correspondinglymodified algorithmneeds only 2(1+2+· · ·+k+ (n− k)(k+ 1)) = 2n(k+ 1)− k2 − k steps.
4.3. The Complement procedure
The algorithm Complement yields the complements of all k-subsets of vertices in a graph G. Let S ⊆ V be a k-subset of thevertices of the graph G. The algorithm finds the complementarysubset S of S in V .The input of the algorithm is an
[2n,
( nk
)]library N0 providing
the encodings of all k-subsets of vertices, where 1 ≤ k ≤ n. Thealgorithm turns on substrand i + n for those memory complexeswhose ith substrand is turned off. As a result, at the end of the loopwe can find the complement of a strand composed of n substrands.The algorithm requires 3n steps.For example, considering the library N0 with n = 4 and k = 2.
The output of the algorithm is shown in Table 2.
4.4. The IncidenceRelation procedure
The algorithm IncidenceRelation provides the incidencerelation between vertices and edges in a graph G.
1: for i← l to u do2: separate (N0,N+,N−, i)3: for j← 1 tom do4: if incident(i, j) then5: set(N+, u+ j)6: end if7: end for8: merge(N+,N−,N0)9: end for10: return N0
providing the encoding of all k-subsets of vertices (1 ≤ k ≤ n). Forpractical reasons, we introduce two additional parameters, i.e. thelower (l) and upper (u) bound of the set of substrands of size n, with((c−1)n+1 ≤ l < u ≤ cn). This allows to generalize the procedureto n consecutive substrands of a
[(c + c ′)n+m,
( nk
)]library. For
those memory complexes whose ith substrand is turned on (tubeN+), the algorithm verifies in parallel if the vertex-edge pair (vi, ej)is incident and, in this case, turns on the (u + j)th substrand,corresponding to the incident edge (statements 4–5). At the end ofthe loop, the strands composed of the last m substrands providethe incidence relation (vi, ej) between vertices and edges. Thealgorithm requires at most n(m+ 2) steps.For example, in view of the graph G in Fig. 2 and the library N0
(with n = 4 and k = 2), the output of the algorithm is given inTable 3. It indicates that in the first memory complex, the set ofincident edges for v1 and v2 is e1, e2, and e3 (e1 and e2 are incidentwith v1, while e1 and e3 are incident with v2).
4.5. The IndependentSubset procedure
The algorithm IndependentSubset constructs an independentset in each subgraph with k vertices of a graph. An independent setin a graph G is a subset of vertices of G such that no two vertices inthe set are connected.The input of the algorithm is an
[2n,
( nk
)]library N0 providing
the encodings of all k-subsets of vertices of G with 1 ≤ k ≤ n.Moreover, lower (l) and upper (u) bounds of the set of substrandsof size n are given (1 ≤ l < u ≤ n). The algorithm verifies whetherthe ith and jth substrands are turned on (tube N++), i.e., thevertices vi and vj, with i < j, are adjacent. In the affirmative case,the jth substrand is cleared and the (u+ 1)+ (j− l)th substrand isset, i.e., the vertex vj is removed from the k-subset and stored in thesecond set of substrands of size n. At the end of the algorithm, thefirst n strands of each memory complex provide an independentsubset of the initially given k-subset. The algorithm requires atmost n2 + 6n steps. Notice that the constructed independentsubsets depend on the ordering of the vertices.For example, in view of the graph G in Fig. 2 and the library N0
(with n = 4 and k = 3), the algorithm yields the output tube.
Algorithm 5 IndependentSubset(N0, l, u)
Require: [2n,(nk
)] library N0
1: for i← l to u− 1 do2: for j← i+ 1 to u do3: separate (N0,N+,N−, i)4: separate (N+,N++,N+−, j)5: merge (N−,N+−,N0)6: if adjacent(i, j) then7: set(N++, (u+ 1)+ (j− l))8: clear(N++, j)9: end if10: merge(N++,N0)11: end for12: end for13: return N0
For instance, the second memory complex encodes theindependent subset {v1, v4} of the subgraph spanned by the vertexset {v1, v2, v4}.
4.6. TheMutuallyDisjointSets procedure
The algorithm MutuallyDisjointSets verifies whether thevertex set of a graph G is partitioned into two disjoint subsets.
Algorithm 6 MutuallyDisjointSets(N0, l, u)
Require: [2n,(2nk
)] library N0
1: for i← l to u do2: separate (N0,N+,N−, i)3: separate (N+,N++,N+−, i+ u)4: separate (N−,N−+,N−−, i+ u)5: merge (N+−,N−+,N0)6: discard (N++)7: discard (N−−)8: end for9: return N0
The input of the algorithm is an[2n,
(2nk
)]library N0 such that
the first n substrands provide an encoding of the k-subsets of V .Likewise, the second n substrands give another encoding of subsetsof V . Moreover, bounds l and u on the set of substrands of size n aregiven (1 ≤ l < u ≤ n). The algorithm separates the library N0 intofour tubes N++, N+−, N−+ and N−− each of which indicating thepresence (+) or absence (−) of vertices vi and vi+u, respectively.The next statement merges the tubes that contain either vertex vior vertex vi+u, while the tubes N++ and N−− are discarded. Thisalgorithm requires at most 6n steps.For example, assume that an already processed N0 library with
The algorithm eliminates those memory complexes whose ithand (i + u)th substrands have the same value (l = 1 and u = 4).The algorithm produces the output tube.
v1 v2 v3 v4 v1 v2 v3 v4
1 0 1 0 0 1 0 10 1 1 0 1 0 0 10 0 1 1 1 1 0 0
5. NP complete graph problems
5.1. The vertex cover problem
The algorithm VertexCover determines if a graph G exhibits avertex cover of size k. A vertex cover is a set of vertices in G thatmeets every edge of graph G. The problem of finding a vertex coverof size k or less in a graph G is NP-complete [21].
Algorithm 7 VertexCover(N0,m, n)
Require: [n+m,(nk
)] library N0
1: IncidenceRelation(N0, 1, n,m)2: Weightening (N0, n,m,m)3: if ¬empty (N0) then4: return N05: else6: report ‘‘no vertex cover’’7: end if
The input of the algorithm is an[n+m,
( nk
)]library N0
providing the encodings of all k-subsets of vertices, where 1 ≤ k ≤n. The algorithm first constructs for each k-subset of vertices the setof incident edges by using the procedure IncidenceRelation. Theseedges are stored in the lastm substrands of thememory complexes.Those memory complexes in which allm substrands are turned onprovide vertex covers. The memory complexes with this propertyare filtered out byWeightening. The algorithm requires nm+2n+m2 + m steps, O(n) tubes, and an initial library with O
(( nk
))bit
strings. Guo et al. [13] proposed an algorithm which solves theproblem using a exponential initial library of O(2n) strands.The minimum vertex cover problem can be solved by invoking
this algorithm for increasing parameters k = 1, . . . , n (resp. inputtest tubes) until the corresponding output test tube is nonempty.For instance, a library N0 (with k = 2, n = 4, and m = 4)
So {v1, v3} and {v2, v3} are the vertex covers of G.
5.2. The k-clique problem
The algorithm k-Clique provides all cliques of size k in a graphG. A cliqueofG is a subgraphofG inwhich all vertices are connected.Such a subgraph is called complete. The problem of finding a cliqueof size k in a graph G is NP-complete [21].
Algorithm 8 k-Clique(N0, l, u)Require: [n,
(nk
)] library N0
1: for i← l to u− 1 do2: for j← i+ 1 to u do3: separate (N0,N+,N−, i)4: separate (N+,N++,N+−, j)5: merge (N−,N+−,N0)6: if adjacent(i, j) then7: merge(N++,N0)8: end if9: discard (N++)10: end for11: end for12: if ¬empty (N0) then13: return N014: else15: report ‘‘no k-Clique’’16: end if
The input of the algorithm is an[n,( nk
)]library N0 providing
the encodings of all k-subsets of vertices (1 ≤ k ≤ n) and thelower (l) and upper (u) bound of the set of substrands of size n(1 ≤l < u ≤ n). The algorithm first calculates the tube N++ containingthose memory complexes in which the ith and jth substrands areturned on. Then the algorithm checks if the corresponding verticesare adjacent. If not, the memory complexes are filtered out (6–7).This algorithm requires at most n2 + 5n steps, O(1) tubes, andO(( nk
))bit strings. Previous approaches solved the problemusing a
exponential initial library [2,17,25]. The maximum clique problemcan be solved by invoking k-Clique for descreasing parametersk = n, n − 1, . . . (resp. input test tubes) until the correspondingoutput test tube is nonempty. A different implementation is givenby Zimmermann [33], requiring 4m+2n(k+1)− k2− k steps and
O((
m(k2
))) bit strings.For instance, consider the graph G in Fig. 2 and the library
N0 (with n = 4 and k = 3) providing the following memorycomplexes.
v1 v2 v3 v4
1 1 1 01 1 0 11 0 1 10 1 1 1
The final tube contains the memory strand.
v1 v2 v3 v4
1 1 1 0
Therefore, G contains a single 3-clique given by {v1, v2, v3}.
The algorithm k-Clique can be modified to provide theindependent k-sets in a given graph G. An independent k-set ofa graph G is a k-subset of the vertex set of G such that no twovertices in the k-subset are connected. The problem of finding anindependent vertex set of size k in a graph G is NP-complete [21].The input of the algorithm is an
[n,( nk
)]libraryN0 providing the
encodings of all k-subsets of vertices (1 ≤ k ≤ n) and the lower(l) and upper (u) bound of the set of substrands of size n. In thealgorithm k-Clique, line 6 of the code is replaced as follows,
6 : if not(adjacent(i, j)) then
So the tube N++ yields all memory complexes in which theith and jth vertex are not adjacent. This algorithm requires atmost n2 + 5n steps, O(1) tubes, and O
(( nk
))bit strings. Bach
et al. [3] proposed an algorithmwhich solves the problem using an1.51n initial library and O(n2m2) laboratory steps. Using Sterling’sapproximation, it can be shown that our algorithm is better thanthat Bach’s if k ≤ n/7 or k ≥ n − n/7, that is, in 2 outof 7 cases. Fu [9] proposed an approximation algorithm for theindependent set problem using an 1.23n initial library and anadditional operation, called append. This algorithm has a low errorratio for sufficiently large number of vertices, but it is technicallydifficult to implement [4].The maximum independent set problem can be solved by
invoking our algorithm for descreasingparameters k = n, n−1, . . .(resp. input test tubes) until the corresponding output test tube isnonempty.For instance, consider the graph G in Fig. 2 and the library
N0 (with n = 4 and k = 2). The output tube, providing theindependent 2-subsets {v1, v4} and {v2, v4} of G, is given by
v1 v2 v3 v4
1 0 0 10 1 0 1
5.4. The 3-coloring problem
The algorithm 3-Coloring solves the 3-coloring problem in agraph G. A vertex coloring of G is an assignment of label or colors toeach vertex inG such that no edge connects two identically coloredvertices. A 3-coloring of G is a vertex coloring of G with at mostthree colors. The problem of finding a 3-coloring of a graph is NP-complete [21].
Algorithm 9 3-Coloring(N0, n)
Require: [n+ 2n,k∑i=1
(ni
)] library N0
1: IndependentSet(N0, 1, n)2: Complement(N0, n)3: IndependentSubset (N0, n+ 1, 2n)4: IndependentSet(N0, 2n+ 1, 3n)5: if ¬empty (N0) then6: return N07: else8: report ‘‘no 3-coloring subgraph’’9: end if
The input of the algorithm is an [n + 2n,∑ki=1
( ni
)] library
N0, where k = bn/3c, providing the encodings of all k-subsetsof vertices. The algorithm decomposes the vertex set of G intothree disjoint independent subsets such that each subset can be
given a different color. Firstly, IndependentSet filters out those k-subsets of vertices which are independent. Secondly, Complementprovides the complement of each independent subset storingthe complementary set in the second n substrands. Thirdly,IndependentSubset constructs an independent subset of thesubgraphs spannedby those verticeswhich are given by the secondn substrands. Forthly, IndependentSet eliminates those memorycomplexes in which vertices given by the third n substrands areadjacent. The algorithm requires 3n2 + 15n steps, O(1) tubes, andO(∑k
i=1
( ni
))bit strings. The best DNA-based algorithm proposed
so far for the 3-coloring problem is due to Bach et al. [3]. Bothalgorithms use the same initial library, but that of Bach et al. usesan enhanced DNA model including an additional operation, calledappend, requiring in total O(n2 + m2) steps. Fu [9] developed anapproximation algorithm for the 3-coloring problem (via dynamicprogramming) using an 1.35n initial library. This algorithmalso hasa low error ratio for sufficiently large number of vertices, but itsimplementation is technically difficult [4].For example, pick a library N0 with n = 4 and k = 1 having the
For instance, the first memory complex encodes a decomposi-tion of the vertex set of G into three independent subsets: {v1},{v2, v4}, and {v3}.
5.5. The bipartite subgraph problem
The algorithm BipartiteSubgraph determineswhether a graphG has a k-bipartite subgraph. A k-bipartite subgraph of G is abipartite subgraph of G containing k vertices. A bipartite graph is agraph in which the vertex set can be partitioned into two disjointssubsets such that no two vertices of the same subset are adjacent.
1: IndependentSet(N0, 1, n)2: IndependentSet(N0, n+ 1, 2n)3: MutuallyDisjointSets (N0, 1, n)4: if ¬empty (N0) then5: return N06: else7: report ‘‘no bipartite subgraph’’8: end if
The problem of finding a k-bipartite subgraph in a graph is NP-complete [11].The input of the algorithm is a
[2n,
(2nk
)]library N0. Each
memory complex in N0 encodes two subsets of the vertices in G,the first and second of which is given by the first and second nsubstrands, respectively. So each memory complex correspondsto a union of a k-subset of the vertex set into two sets. Firstly,both subsets of such a k-subset are subjected to IndependentSet,filtering out those subsets which are independent in G. Secondly,memory complexes in which both subsets are independent in Gserve as input ofMutuallyExclusiveSets providing thosememorycomplexes in which the independent subsets are disjoint. So thefinal memory complexes encode k-bipartite subgraphs of G. Thealgorithm requires 2n2+ 10n+ 6n = 2n2+ 16n steps, O(1) tubes,and O
((2nk
))bit strings. This appears to be the first DNA-based
solution of the bipartite subgraph problem.For instance, take a libraryN0 with n = 4 and k = 4 having
(84
)different types of memory complexes. To simplify the example,assume that N0 consists of the following memory complexes,
In terms of the graph G in Fig. 3, the first IndependentSetstatement yields the tube.
v1 v2 v3 v4 v1 v2 v3 v4
1 0 0 1 0 1 1 00 1 1 0 1 0 0 10 0 0 0 1 1 1 1
The second IndependentSet statement provides the tube.
v1 v2 v3 v4 v1 v2 v3 v4
1 0 0 1 0 1 1 00 1 1 0 1 0 0 1
MutuallyDisjointSets gives the final tube.
v1 v2 v3 v4 v1 v2 v3 v4
1 0 0 1 0 1 1 00 1 1 0 1 0 0 1
Fig. 3. A bipartite graph G.
So the graphG is a 4-bipartite graphwith vertex subsets {v1, v4}and {v2, v3}.
5.6. The k-matching problem
The algorithm kMatching solves the k-matching problem ina graph G. A k-matching in G is a k-subset of edges in G such thatno two of them share a common vertex. The problem of finding ak-matching in a graph is NP-complete [21].
Algorithm 11 kMatching(N0,m, n, k)
Require: [m+ n,(mk
)] library N0
1: EdgeInducedGraphs(N0,m)2: Weightening (N0,m, n, 2k)3: if ¬empty (N0) then4: return N05: else6: report ‘‘no kMatching’’7: end if
The input of the algorithm is an[m+ n,
(mk
)]library N0
providing the encodings of all k-subsets of edges, where 1 ≤ k ≤n/2. Firstly, the induced subgraphs from all k-subsets of edges arecalculated. Such a subgraph provides a k-matching if and only if ithas 2k vertices. ThusWeightening filters out those subgraphswith2k vertices. The algorithm requires 4m + 2n(2k + 1) − 4k2 − 2ksteps, O(n) tubes, and O
((mk
))bit strings. A somewhat different
approach in vivo was proposed for the matching problem [10].Although interesting from the biotechnological point of view, thistechnique requires an O(2n) initial library.For example, take the libraryN0 (with k = 2,m = 4, and n = 4)
So the subgraph induced by the edges e1 and e4 is the only 2-matching in G.
5.7. The perfect matching problem
A small change in the kMatching algorithm solves the perfectmatching problem. Let n > 0 be an even integer. A perfect matchingin a graph G with n vertices is an n/2-matching in G. The problemof finding a perfect matching in a graph is also NP-complete [21].
Algorithm 12 PerfectMatching(N0,m, n)
Require: [m+ n,(mk
)] library N0
1: EdgeInducedGraphs(N0,m)2: Weightening (N0,m, n, n)3: if ¬empty (N0) then4: return N05: else6: report ‘‘no perfect matching’’7: end if
The input of the algorithm is an[m+ n,
(mk
)]library N0
providing the encodings of all n/2-subsets of edges. In oppositionto the kMatching algorithm, Weightening receives n as lastparameter instead of 2k. The algorithm requires 4m+ 2n(n+ 1)−n2 − n = 4m + n2 + n steps O(n) tubes, and O
((mk
))bit strings.
Chen et al. [6] proposed a solution of the perfectmatching problemusing the surface-based DNA computing model. For this, the DNAmolecules of the solution space are attached to a solid carrier, andbiochemical reactions are used to establish the solution. Thismodelrequires an O(2n) initial library.
5.8. The edge dominating k-set problem
The algorithm EdgeDominatingSet calculates all dominatingedge sets of size k in a graph G. Let S be a k-subset of edges in G.Let NG[S] denote the set of edges in G which are in S or adjacentto an edge in S. If NG[S] is the edge set in G, then S is said to bek-dominating. The problem of finding a k-dominated edge set in agraph is NP-complete [32].
Algorithm 13 EdgeDominatingSet(N0,m, n)
Require: [m+ (n+m),(mk
)] library N0
1: EdgeInducedGraphs(N0,m)2: IncidenceRelation(N0,m+ 1,m+ n,m)3: Weightening (N0,m+ n,m,m)4: if ¬empty (N0) then5: return N06: else7: report ‘‘no edge dominating set’’8: end if
The input of the algorithm is an[m+ (n+m),
(mk
)]library N0
providing the encodings of all k-subsets of edges, where 1 ≤ k ≤ n.Firstly, EdgeInducedGraphs provides all subgraphs in Gwhich areinduced by all the k-subsets of edges. Secondly, IncidenceRelationcalculates for each vertex set in such a subgraph, the set of incidentedges. (These edges are stored in the third set of substrands of sizem.) Such a set of incident edges is k-dominating in G if and only if itequals the edge set in G. Therefore,Weightening filters out thosememory complexeswhosem substrands on third set are turned on.The algorithm requires 4m+ nm+ 2n+ 2m(m+ 1)−m2 −m =n(m + 2) + m2 + m steps, O(m) tubes, and O
((mk
))bit strings.
Guo et al. [14] solved a related problem, the vertex dominating-setproblem, using a polynomial-time sticker algorithm with an O(2n)
initial library. The minimum edge dominating k-set problem canbe solved by invoking this algorithm for increasing parameters k =1, . . . , n (resp. input test tubes) until the corresponding output testtube is nonempty.For example, take the libraryN0 (with k = 1,m = 4, and n = 4)
Therefore, {e2} and {e3} are 1-dominating edge sets in G.
6. Discussion
Wehave described sticker algorithms for several representativeNP-complete graph problems. These problems are solved by O(n2)operations and O(n) tubes, using a initial library with O
(( nk
))bit strings. In view of the error model of the sticker system,sticker algorithms may never outperform electronic computersin solving NP-complete problems. However, DNA models ofcomputation essentially provide digital code and manipulatemassive amounts of DNA molecules in parallel. Therefore, DNAmodels of computation may be implemented in silico by computerarchitectures offering massive parallelism [7]. For instance, asticker system may be implemented in principle by a massivelyparallel register machine. In particular, the nature of the bit-vertical sticker operations suggest that sticker algorithms canbe realized by a highly parallel computer architecture such asa field-programmable gate array (FPGA) [12,31]. However, thecombinatorial complexity of the initial librarymay severely impactthe efficiency of these algorithms. For this reason, in silico DNAcomputing is also limited to solve moderate-size combinatorialproblems in an exact fashion. However, we believe the maindirection of this approach is not to solve intractable problems in anexactmanner, but in a heuristic one.Wewill explore the emulationof sticker algorithms on FPGA’s in a forthcoming project.
This research was supported by CONACYT and DAAD fellow-ships to IMMP.
References
[1] L. Adleman, Molecular computation of solutions to combinatorial problems,Science 266 (1994) 1021–1024.
[2] M. Amos, DNA computation, Ph.D. Thesis, Department of Computer Science,The University of Warwick, 1997.
[3] E. Bach, A. Condon, E. Glaser, C. Tanguay, DNA models and algorithms for NPcomplete problems, in: Proc. 11th Ann. IEEE Conf. Comp. Complexity, IEEEComputer Society Press, Philadelphia, Pennsylvania, 1996, pp. 290–299.
[4] W.-L. Chang, M. Ho, M. Guo, Molecular solution for the subset-sum problemon DNA-based supercomputing, Biosystems 73 (2004) 117–130.
[5] J. Chen, E. Antipov, B. Lemieux, W. Cedeno, D.H. Wood, DNA computingimplementing genetic algorithms, in: Preliminary Proceedings DIMACSWorkshop on Evolution as Computation, Piscataway, NJ, 1999, pp. 39–49.
[6] Z.-P. Chen, X.-L. Lu, L. Wang, Y.-P. Lin, A surface-based DNA algorithm for theperfect matching problem, Computer Research and Development 42 (2005)1241–1246.
[8] T. Eng, D. Faulhammer, A surface-based DNA algorithm for minimal set cover,in: Proc. 3rd DIMACS Meeting on DNA Based Computers, Pennsylvania, 1997,pp. 74–82.
[9] B. Fu, Volume bounded molecular computation. Ph.D. Thesis, Department ofComputer Science, Yale University, 1997.
[10] L. Gao, R.N. Ma, J. Xu, The molecular algorithm of the matching problem basedon plasmid DNA, Progress in Biochemistry and Biophysics 29 (2002) 820–823.
[11] M.R. Garey, D.S. Johnson, Computers and Intractability: A Guide to the Theoryof NP-Completeness, W.H. Freeman and Company, New York, 1979.
[12] M. Glesner, P. Zipf, M. Renovell, Field-Programmable Logic and Application,Springer, New York, 2002.
[13] M. Guo, W.L. Chang, M. Ho, J. Lu, J. Cao, Is optimal solution of every NP-complete or NP-hard problem determined from its characteristic for DNA-based computation, Biosystems 80 (2005) 71–82.
[14] M. Guo, M. Ho,W.L. Chang, Fast parallel molecular solution to the dominating-set problem on massively parallel bio-computing, Parallel Computing 30(2004) 1109–1125.
[15] J. Hartmanis, On the weight of computations, Bulletin of the EuropeanAssociation for the Theoretical Computer Science 55 (1995) 136–138.
[16] T. Head, Formal language theory and DNA: An analysis of the generativecapacity of specific recombinant behaviors, Bulletin of Mathematical Biology49 (1987) 737–759.
[17] M. Ho, W.L. Chang, M. Guo, T. Yang, Fast parallel solution for set-packing andclique problems by DNA-based computing, IEICE Transactions on Informationand Systems E87-D (2004) 1782–1788.
[18] N. Jonoska, S. Karl, A molecular computation of the road color problem, in:Proc. 2nd Annual Meeting on DNA Based Computing, Princeton, 1996, pp.148–158.
[19] L. Kari, DNA computing: Arrival of biological mathematics, The MathematicalIntelligencer 19 (1997) 9–22.
[20] L. Kari, G. Paun, G. Rozenberg, A. Salomaa, S. Yu, DNA computing, stickersystems, and universality, Acta Informatica 35 (1998) 401–420.
[21] R.M. Karp, Reducibility among combinatorial problems, in: Proc. Sympos. IBM,Plenum, New York, 1972, pp. 85–103.
[22] J.Y. Lee, H.W. Lim, S.I. Yoo, B.T. Zhang, T.H. Park, Efficient initial pool generationfor weighted graph problems using parallel overlap assembly, in: DNA10,Milano, 2005, pp. 215–223.
[23] R.J. Lipton, DNA solution of hard combinatorial problems, Science 268 (1995)542–548.
[24] I.M. Martínez-Pérez, G. Zhang, Z. Ignatova, K.-H. Zimmermann, Biomolecularautonomous solution of the Hamiltonian path problems via DNA hairpinformation, International Journal of Bioinformatics Research Applications 1(2005) 389–398.
[25] Q. Ouyang, P.D. Kaplan, S. Liu, A. Libchaber, DNA solution of themaximal cliqueproblem, Science 278 (1997) 446–449.
[26] C. Papadimitriou, K. Steiglitz, Combinatorial Optimization, Prentice Hall,Englewood Cliffs, NJ, 1982.
[27] B. Ravinderjit, N. Chelyapov, C. Johnson, P. Rothemund, L. Adleman, Solutionof a 20 variable 3-SAT problem on a molecular computer, Science 296 (2002)499–502.
[28] S.E. Roweis, E. Winfree, B. Burgoyne, N.V. Chelyapov, M. Goodman,P. Rothemund, L. Adleman, A sticker based architecture for DNA compu-tation, in: Proc. 2nd Annual DIMACS Meeting on DNA Based Computers,Princeton, 1996, pp. 1–29.
[29] K. Sakamoto, H. Gouzu, K. Komiya, D. Kiga, S. Yokoyama, T. Yokomori,M. Hagiya, Molecular computation by DNA hairpin formation, Science 288(2000) 1223–1226.
[30] O. Scharrenberg, Stickersim: A programming library for sticker algorithms,Project Work, Hamburg University of Technology, Hamburg, Germany, 2006.
[32] M. Yannakakis, F. Gavril, Edge dominating sets in graphs, SIAM Journal ofApplled Mathematics 48 (1980) 364–373.
[33] K.-H. Zimmermann, Efficient DNA sticker algorithms for graph theoreticproblems, Computer Physics Communications 144 (2002) 297–309.
Israel M. Martinez-Perez is currently a Ph.D. student atthe Department of Computer Engineering at HamburgUniversity of Technology. He received the BSc and MScdegrees in Electronic Systems and Intelligent Systems, re-spectively, from the Monterrey Institute of Technology(ITESM). His research interests include bimolecular com-puting, artificial intelligence, and optimization models in-spired by nature.
Karl-Heinz Zimmermann is an associate Professor ofComputer Science at the Hamburg University of Technol-ogy. He received the Ph.D. degree from the Universityof Erlangen and the Habilitation from the University ofBayreuth. He was a Heisenberg fellow at the Universityof Karlsruhe and a Fulbright fellow at Princeton Univer-sity. He serves as Associate Editor of International Journalof Bioinformatics Research and Applications and Journal ofVLSI Signal Processing Systems. His current research inter-ests include bimolecular computing, protein informatics,and combinatorics and optimization.
