1. Sequence Alignment I Lecture #2
Background Readings: Gusfield, chapter 11.
Durbin et. al., chapter 2.
This class has been edited from Nir Friedman’s lecture which is available at Changes made by Dan Geiger, then Shlomo Moran, and finally Benny Chor. .

2. Sequence Comparison Much of bioinformatics involves sequences
DNA sequences
RNA sequences
Protein sequences
We can think of these sequences as strings of letters
DNA & RNA: alphabet ∑ of 4 letters (A,C,T/U,G)
Protein: alphabet ∑ of 20 letters (A,R,N,D,C,Q,…)

3. Sequence Comparison (cont)
Finding similarity between sequences is important for many biological questions
For example:
Find similar proteins
Allows to predict function & structure
Locate similar subsequences in DNA
Allows to identify (e.g) regulatory elements
Locate DNA sequences that might overlap
Helps in sequence assembly g1 g2

4. Sequence Alignment Input: two sequences over the same alphabet
Output: an alignment of the two sequences
Example:
GCGCATGGATTGAGCGA
TGCGCCATTGATGACCA
A possible alignment:
-GCGC-ATGGATTGAGCGA
TGCGCCATTGAT-GACC-A

5. Alignments -GCGC-ATGGATTGAGCGA TGCGCCATTGAT-GACC-A Three “components”:
Perfect matches
Mismatches
Insertions & deletions (indel)
Formal definition of alignment:

6. Choosing Alignments There are many (how many?) possible alignments
For example, compare:
-GCGC-ATGGATTGAGCGA
TGCGCCATTGAT-GACC-A to
------GCGCATGGATTGAGCGA
TGCGCC----ATTGATGACCA--
Which one is better?

7. Scoring Alignments Motivation:
Similar (“homologous”) sequences evolved from a common ancestor
In the course of evolution, the sequences changed from the ancestral sequence by random mutations:
Replacements: one letter changed to another
Deletion: deletion of a letter
Insertion: insertion of a letter
Scoring of sequence similarity should reflect how many and which operations took place

8. A Naive Scoring Rule Each position scored independently, using:
Match: +1
Mismatch : -1
Indel -2
Score of an alignment is sum of position scores

9. Example -GCGC-ATGGATTGAGCGA TGCGCCATTGAT-GACC-A
Score: (+1x13) + (-1x2) + (-2x4) = 3
------GCGCATGGATTGAGCGA
TGCGCC----ATTGATGACCA--
Score: (+1x5) + (-1x6) + (-2x11) = -23
according to this scoring, first alignment is better

10. More General Scores
The choice of +1,-1, and -2 scores is quite arbitrary
Depending on the context, some changes are more plausible than others
Exchange of an amino-acid by one with
similar properties (size, charge, etc.)
vs.
Exchange of an amino-acid by one with very different properties
Probabilistic interpretation: (e.g.) How likely is one alignment versus another ?

11. Additive Scoring Rules
We define a scoring function by specifying
(x,y) is the score of replacing x by y
(x,-) is the score of deleting x
(-,x) is the score of inserting x
The score of an alignment is defined as the
sum of position scores

12. The Optimal Score
The optimal (maximal) score between two sequences is the maximal score of all alignments of these sequences, namely,
Computing the maximal score or actually finding an alignment that yields the maximal score are closely related tasks with similar algorithms.
We now address these problems.

13. Computing Optimal Score
How can we compute the optimal score ?
If |s| = n and |t| = m, the number A(m,n) of possible alignments is large!
Exercise: Show that
So it is not a good idea to go over all alignments
The additive form of the score allows us to apply dynamic programming to compute optimal score efficiently.
הנוסחה כנראה לא מדוייקת

14. Recursive Argument
Suppose we have two sequences: s[1..n+1] and t[1..m+1]
The best alignment must be one of three cases:
1. Last match is (s[n+1],t[m +1] )
2. Last match is (s[n +1],-)
3. Last match is (-, t[m +1] )

15. Recursive Argument
Suppose we have two sequences: s[1..n+1] and t[1..m+1]
The best alignment must be one of three cases:
1. Last match is (s[n+1],t[m +1] )
2. Last match is (s[n +1],-)
3. Last match is (-, t[m +1] )

16. Recursive Argument
Suppose we have two sequences: s[1..n+1] and t[1..m+1]
The best alignment must be one of three cases:
1. Last match is (s[n+1],t[m +1] )
2. Last match is (s[n +1],-)
3. Last match is (-, t[m +1] )

17. Useful Notation (ab)use of notation:
V[i,j] = value of optimal alignment between
i prefix of s and j prefix of t.

18. Recursive Argument (ab)use of notation:
V[i,j] = value of optimal alignment between
i prefix of s and j prefix of t.
Using our recursive argument, we get the following recurrence for V:
V[i,j]
V[i+1,j]
V[i,j+1]
V[i+1,j+1]

19. Recursive Argument
Of course, we also need to handle the base cases in the recursion (boundary of matrix): S T AA
- -
versus
We fill the “interior of matrix” using our recurrence rule

20. Dynamic Programming AlgorithmS T
We continue to fill the matrix using the recurrence rule

21. Dynamic Programming AlgorithmS T
V[0,0]
V[0,1]
V[1,0]
V[1,1] +1
-2 -A A-
-2 (A- versus -A)
versus

22. Dynamic Programming AlgorithmS T
(hey, what is the scoring function s(x,y) ? )

23. Dynamic Programming AlgorithmS T
Conclusion: V(AAAC,AGC) = -1

24. Reconstructing the Best Alignment
To reconstruct the best alignment, we record which case(s) in the recursive rule maximized the score S T

25. Reconstructing the Best Alignment
We now trace back a path that corresponds to the best alignment
AAAC
AG-C S T

26. Reconstructing the Best Alignment
More than one alignment could have the best score
(sometimes, even exponentially many) S T
AAAC
A-GC
AAAC
-AGC
AG-C

27. Time Complexity Space: O(mn) Time: O(mn) Filling the matrix O(mn)
Backtrace O(m+n) S T

28. Space Complexity In real-life applications, n and m can be very large
The space requirements of O(mn) can be too demanding
If m = n = 1000, we need 1MB space
If m = n = 10000, we need 100MB space
We can afford to perform extra computation to save space
Looping over million operations takes less than seconds on modern workstations
Can we trade space with time?

29. Why Do We Need So Much Space?
To compute just the value V[n,m]=V(s[1..n],t[1..m]),
we need only O(min(n,m)) space: A 1 G 2 C 3 4
Compute V(i,j), column by column, storing only two columns in memory
(or line by line if lines are shorter). -2 -4 -6 -8 -2 1 -1 -3 -5 -4 -1 -2 -6 -3 -2 -1
Note however that
This “trick” fails if we want to reconstruct the optimal alignment.
Trace back information requires keeping all back pointers, O(mn) memory.

30. Local Alignment The alignment version we studies so far is called
global alignment: We align the whole sequence s
to the whole sequence t.
Global alignment is appropriate when s,t are highly
similar (examples?), but makes little sense if they
are highly dissimilar. For example, when s (“the query”)
is very short, but t (“the database”) is very long.

31. Local Alignment
When s and t are not necessarily similar, we may want to consider a different question:
Find similar subsequences of s and t
Formally, given s[1..n] and t[1..m] find i,j,k, and l such that V(s[i..j],t[k..l]) is maximal
This version is called local alignment.

32. Local Alignment As before, we use dynamic programming
We now want to setV[i,j] to record the maximum value over all alignments of a suffix of s[1..i]
and a suffix of t[1..j]
In other words, we look for a suffix of a prefix.
How should we change the recurrence rule?
Same as before but with an option to start afresh
The result is called the Smith-Waterman algorithm, after its inventors (1981).

33. Local Alignment New option:
We can start a new match instead of extending a previous alignment
Alignment of empty suffixes

34. Local Alignment ExampleS T
s = TAATA
t = TACTAA

35. Local Alignment ExampleS T
s = TAATA
t = TACTAA

36. Local Alignment ExampleS T
s = TAATA
t = TACTAA