A Space-Efficient Randomized DNA Algorithm for k-SAT Kevin Chen and Vijay Ramachandran Princeton University

DNA Computing DNA can store a lot of information! –A DNA sequence is a bitstring 5’-A-T-T-G-C-A-T G-C-A-3’ 3’-A-C-G-T-A-C-G-T-T-G-5’ –A test tube can hold approximately 2 50 strands of DNA Important chemical properties –Watson-Crick complementary hybridization

DNA Computing Massive parallelism –Each strand is a “processor” –Operations can be performed on all strands in a test tube with one laboratory step Power of large database searching –Use DNA to store lots of information, use chemical properties to pull out what we’re looking for

Examples of DNA Algorithms Hamiltonian Circuit, Adleman, 1994 –DNA sequences represent paths through a graph that self-assemble SAT, Lipton, 1995 –Strands encode solutions; generate all and filter out ones that work

Randomized Algorithms Types Of Algorithms Monte Carlo: Answer can be incorrect (e.g., Primality testing) Las Vegas: Answer always correct but running time is probabilistic (e.g., Quicksort) For more information: Motwani & Raghavan, Randomized Algorithms. Cambridge UP, 1995.

Examples of Randomized Algorithms Algorithm Best known non-randomized running time Best known randomized running time Quicksort O(n2)O(n2)O(n log n) Primality Testing (log n) O(log log log n) O(log 3 n) 3-SAT O( n )O( n )

Paturi’s k-SAT Algorithm (1997) 1.While there are unassigned variables left: –Choose a random variable x i –If x i is forced, set x i as required, else assign x i to T or F at random 2.Test if the assignment is a solution 3.Repeat steps 1 and 2, I times, where the error probability is

Paturi’s Algorithm (continued) Randomized version of Davis-Putnam (1960) Running time is O(n 2 m·2 n–n/k ) for a k-SAT instance with n variables and m clauses Monte-Carlo Algorithm: may output ‘Unsatisfiable’ when a solution exists

Objective Adapt Paturi’s algorithm to Adleman and Lipton’s DNA extract model Reduce space complexity since not all 2 n solutions are generated

Related Work Lipton (1995) –First DNA algorithm for formula-SAT –O(n) time and O(2 n ) space Ogihara and Ray (1997) –Implemented Monien-Speckenmeyer algorithm for 3-SAT –O(nm 2 + n 2 ) time and O( n ) space Diaz, Esteban and Ogihara (2000)

Model of Computation Extended version of the extract model with the APPEND primitive 2n+3 well-behaved words, needed to form assignment sequences to build solution strands Assignment sequence for “x 2 = False”, with separator and primer sequences S and P PS S’P’S’ x(2)=F x(2)=F’

Allowable Operations COMBINE DETECT EXTRACT APPEND* † POUR* TO-SINGLE- STRANDED TO-DOUBLE- STRANDED * Sources of randomness † Generalization of Boneh’s APPEND

Implementation of APPEND HPSx(5)=TPS H’P’S’x(5)=T’P’ PS S’P’S’ x(2)=T x(2)=T’ PS S’P’S’ x(2)=F x(2)=F’ Partial assignment containing x 5 = T Assignment sequence for x 2 = T Assignment sequence for x 2 = F One sequence will anneal at this exposed sticky end Each sequence has a 50% chance of appending to our partial assignment

Implementation of TO-DOUBLE-STRANDED HPSx(5)=TPS HPSx(5)=TPS HPSx(5)=TPS H’P’S’x(5)=T’P’ P’P’ Original Strand Add complement of primer sequence, P’ Add DNA polymerase, bases (A,T,C,G), and DNA ligase Polymerase will construct the complementary strand starting with the primer sequence

DNA Algorithm Start with a tube T containing I empty solution strands. While there are still unassigned variables, perform the following loop: T HPS  I I

DNA Algorithm (continued) Pour T into n tubes Remove possible repeat assignments Check for forced variables Append appropriate assignment sequences Pour out the contents of T into n tubes and associate a variable with each tube via a random permutation. … T1  x6T1  x6 T2  x2T2  x2 T3  x4T3  x4 Tn  x5Tn  x5 T

DNA Algorithm (continued) Pour T into n tubes Remove possible repeat assignments Check for forced variables Append appropriate assignment sequences If a strand already has an assignment for the variable associated with its tube, move it to the next tube and repeat. T1  x6T1  x6 Extract strands with “x 6 = T” or “x 6 = F” T2  x2T2  x2 Add to next tube and repeat +

DNA Algorithm (continued) Pour T into n tubes Remove possible repeat assignments Check for forced variables Append appropriate assignment sequences For each tube, partition the strands into three parts: forced to T, forced to F, not forced. Consider clause C = x 1  x 2  x 3  … else x 1 = F x 2 = T else etc. … Forced to x 3 = T Repeat for other clauses containing x 3 else Ti  x3Ti  x3 Ti  x3Ti  x3

DNA Algorithm (continued) Pour T into n tubes Remove possible repeat assignments Check for forced variables Append appropriate assignment sequences APPEND the correct assignment sequence for forced variables and assign a random value otherwise. Not forced Forced to T Forced to F Assign True Assign False Combine all …

DNA Algorithm (continued) Combine all tubes and repeat while loop. After n iterations (all variables have been assigned on each strand), check if any of the assignment strands are solutions to the formula using Lipton’s algorithm. T Solutions Lipton’s Algorithm

Analysis of Algorithm On an n variable, m clause instance of k-SAT, if the error probability is e – , our algorithm has space complexity: The analysis is the same as the time complexity analysis in Paturi (1997, 1998).

Comparison of DNA k-SAT Algorithms AlgorithmTypeSpaceTime max(n) k = 3 Lipton 1995 k-SATO(2 n )O(km)50 Ogihara SAT only O( n )O(n 2 +nm 2 )72 CR1999 Random k-SAT O(n 2 +k 2 nm)75

Conclusion Our algorithm reduces space complexity while only requiring O(n) words This is the first known attempt to harness the tools of randomized classical algorithms in DNA computing Further gains may be obtainable by adapting the algorithm of Paturi (1998)