A fast parallel algorithm for finding the longest common sequence of multiple

biosequences.

Yixin Chen, Andrew Wan, Wei Liu

Washington University / Yangzhou University

December 2006

Biological Review

DNA can be represented as sequence of four letters

(ACGT).

New biosequences every day.

Sequence comparison.

Find similarities with other sequences already

known.

Longest Common Subsequence (LCS).

Longest Common Subsequence LCS

Search a substring that is common and longest to

two or more given strings.

Searching for the LCS of multiple biosequences is a

fundamental task in Bioinformatics.

LCS is a special case of global sequence alignment.

All algorithms of global sequence alignment can

be used to solve LCS.

Longest Common Subsequence LCSAlgorithms and complexity

Dynamic programming.

Smith-Waterman algorithm

Complexity O(mn).

Mayers and Miller

Complexity O(m+n).

Parallel algorithms.

CREW-PRAM

Longest Common Subsequence LCSAlgorithms and complexity in Multiple sequences

What is the problem with those Algorithms?

Smith-Waterman: complexity now is exponential.

Carrillo and Lipman algorithm.

New divide and conquer algorithm DCA.(Stoye)

Clustal-W (Feng and Doolittle’s algorithm).

FAST_LCS

Seeks the successors of initial identical character

pairs. Tables

Pruning operations

FAST_LCS can be extended to find LCS of multiple

biosequences.

They it implemented using Parallel computing model

as well.

Initial identical character pair and its successor table

Let X and Y be two biosequences,

where Xi and Yi to { A, C , G, T }

Define an Array CH of four CHaracters:

CH(1) = A

CH(2) = C

CH(3) = G

CH(4) = T

Initial identical character pair and its successor table

Build the successor table of identical characters for two strings,

Lets call the tables TX for sequence X an TY for sequence Y.

The table(s) are defined as follows:

TX(i,j) = min { k | k SX (i,j) } SX(i,j)

Otherwise

Where SX (i,j) = {k | Xk = CH(i), k > j } and i = 1,2,3,4 and j = 0,1,…n

For example if i = 1 means A

Example

Let X = “TGCATA” and Y = “ATCTGAT”

If Xi = Yi = CH(k) then call them an identical pair CH(k)

and denote as (i,j).

Let (i,j) and (k,l) be two identical characters pairs of X

Then: If i < k and j < l they call (i, j) a “predecessor” of (k,l).

or (k,l) the a “successor” of (i,j)

Successor Table for example

Remember the sequence X = “TGCATA”

SX(1,0) = k | Xk = CH(A) , k > 0 then k = {4 ,6}

TX(1,0) = min { 4,6} => TX(1,0) = 4...

SX(1,4) = k | Xk = CH(A) , k > 4 then k = {6}

TX(1,4) = 6

ExampleThe final Tables are these:

SX(1,0) = 4 SX(1,5) = 6

SX(1,1) = 4 SX(1,6) = -

SX(1,2) = 4

SX(1,3) = 4

SX(1,4) = 6

TGCATA”

Some definitions

If Xi=Yi=CH(k) they call them “Identical pair of CH(k)”

and it denoted as (i,j).

The set of all “Identical pairs” of X is denoted as

S(X,Y).

If an identical pair (i,j) S(X,Y) and there is not

(k,l) S(X,Y) such that (k,l) < (i,j) then they call (i,j)

“initial identical pair”

Some definitions

The level of each pairs is defined as follows:

Theorems

T1: If the length of LCS of X and Y is denote as |

LCS(X,Y)| then |LCS(X,Y)| = max {level(i,j) | (i,j) S(X,Y)}

T2: For an identical character pair (i,j) S(X,Y) the

operations of producing all its direct successors is as

follows:

Back to the Example

The successors of the pair (2,5) are:

(4,6), (3,-), (-,-), (5,7)

Example

The successors of the pair (2,5) are:

(4,6), (5,7)

Pruning operations

Operation 1

If on the same level, there are two identical character

pairs (i,j) and (k,l) and (k,l) > (i,j) then (k,l) can be

pruned without to affecting the correctness of the

algorithm

This operation will remove all the redundant identical

pairs

Back to the Example

The successors of the pair (2,5) were

(4,6), (5,7)

since they are on the same level and (4,6) > (5,7)

The successors of the pair (2,5) is:

(4,6)

Pruning operations

Operation 2

If on the same level, there are two identical character

pairs (i1,j) and (i2,j) and i1< i2 then (i2,j) can be pruned

without to affecting the correctness of the algorithm

Pruning operations

Operation 3

If on the same level, there are two identical character

pairs (i1,j), (i2,j), …,(ir,j) and i1< i2 … < ir then :

(i2,j) … (ir,j) can be pruned

FAST_LCS complexity

They claim that the complexity of their algorithm is

O(L) where L is the number of the identical character

pairs of X,Y.

When they algorithm is implement using Parallel

computing the complexity is O(|LCS(X,Y)|)

FAST_LCS and multiple sequences

FAST_LCS can be easily extended to the LCS

problem of multiple sequences.

From the biological point of views is more important

to find LCS for multiple sequence.

FAST_LCS and multiple sequences

Suppose there are n sequence X1, X2, …, Xn where X=

(Xi1, Xi2, …, Xi,ni), ni is the length of Xi, Xij to { A, C , G,

T } and where j = 1,2,3…,ni.

The successors tables will be denoted as:

TX1, TX2,….,TXn Where TXs is a two dimesional array

for the sequence Xs=(Xs1, Xs2,… Xns),

s = 1,2,…,n

FAST_LCS and multiple sequences

Following the same procedure that it is used to find two

sequences, in this case start building the successors

tables of all the sequences, following:

FAST_LCS and multiple sequences

Identical character tuple for LCS of multiple

sequences.

The level of each tuple comes from the following:

FAST_LCS and multiple sequences

For an Identical character tuple this operation follows:

They claim two more Theorems which are basically

the extension of T1 and T2 for multiple sequence

Example

Let n = 3, X1 = “TGCATA”, X2=“ATCTGAT” and

X3=“CTGATTC”

The successors tables are:

Example

The direct successors of the identical character triple

(1,2,2) can be obtained by :

Example

The successors are : (4,6,4), (3,3,7), (2,5,3), (1,2,2).

Then following the algorithm, apply the pruning

operations we get (3,3,7), (2,5,3), (1,2,2), etc.

FAST_LCS for multiple sequence. complexity

The time complexity of most algorithms for multiple

sequence LCS depends on the number of sequence.

They are not practicable when the number of

sequence is large.

FAST_LCS for multiple sequence. complexity

When FAST_LCS algorithm is implement using

Parallel computing the complexity is

O(|LCS(X1, X2,… Xn)|).

It complexity is “Independent of the number of

sequences n”

Sequential computation on two sequences

Sequential computation on multiple sequences

Sequential computation on using parallel computing

Conclusion

The precision of FAST_LCS is higher than FASTA and faster

than S-W algo for computation on two sequences

FAST_LCS is faster than other algorithms that compute LCS for

multiple sequences, like

CLUSTAL-W.

FAST_LCS could be implemented using Parallel computation.