Sequence Alignment

2

Sequence ComparisonMuch 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 Protein: alphabet ∑ of 20 letters

3

Sequence Comparison Finding similarity between sequences is important

for many biological questions

Biological evolution (mutation, deletion, duplication, addition, move of subsequences…)

Homologous (share a common ancestor) sequences are (relatively) similar

Algorithms try to detect similar sequence that possibly share a common function

4

Sequence Comparison (cont)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

g1g2

Complete DNA Sequences

More than 1000 complete genomes have been sequenced

Evolution

Evolution at the DNA level

…ACGGTGCAGTTACCA…

…AC----CAGTCCACCA…

Mutation

SEQUENCE EDITS

REARRANGEMENTS

Deletion

InversionTranslocationDuplication

Evolutionary Rates

OKOKOK

XX

Still OK?

next generation

Sequence conservation implies function

Alignment is the key to• Finding important regions• Determining function• Uncovering evolutionary events

Sequence Alignment

-AGGCTATCACCTGACCTCCAGGCCGA--TGCCC---TAG-CTATCAC--GACCGC--GGTCGATTTGCCCGAC

DefinitionGiven two strings x = x1x2...xM, y = y1y2…yN,

an alignment is an assignment of gaps to positions0,…, N in x, and 0,…, N in y, so as to line up each

letter in one sequence with either a letter, or a gapin the other sequence

AGGCTATCACCTGACCTCCAGGCCGATGCCCTAGCTATCACGACCGCGGTCGATTTGCCCGAC

What is a good alignment?

AGGCTAGTT, AGCGAAGTTT

AGGCTAGTT- 6 matches, 3 mismatches, 1 gapAGCGAAGTTT

AGGCTA-GTT- 7 matches, 1 mismatch, 3 gapsAG-CGAAGTTT

AGGC-TA-GTT- 7 matches, 0 mismatches, 5 gapsAG-CG-AAGTTT

Scoring Function

• Sequence edits:AGGCCTC

Mutations AGGACTC

Insertions AGGGCCTC

Deletions AGG . CTC

Scoring Function:Match: +mMismatch: -sGap: -d

Score F = (# matches) m - (# mismatches) s – (#gaps) d

Alternative definition:

minimal edit distance

“Given two strings x, y,find minimum # of edits (insertions, deletions,

mutations) to transform one string to the other”

13

Simple Scoring RuleScore each position independently: Match m: +1 Mismatch s: -1 Indel d: -2Score of an alignment is sum of position scores

Scoring Function:Match: m m≥0Mismatch: s s≤0Gap: d s≤0

Score F = (#matches)m + (#mismatches)s + (#gaps)d

14

Alignments-GCGC-ATGGATTGAGCGATGCGCCATTGAT-GACC-A

Three elements: Matches Mismatches Insertions & deletions (indel)

15

ExampleExample:

-GCGC-ATGGATTGAGCGATGCGCCATTGAT-GACC-A

Score: (+1x13) + (-1x2) + (-2x4) = 3

------GCGCATGGATTGAGCGATGCGCC----ATTGATGACCA--

Score: (+1x5) + (-1x6) + (-2x11) = -23

16

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.)

· Exchange of an amino-acid by one with opposite properties

Probabilistic interpretation: (e.g.) How likely is one alignment versus another ?

17

Additive Scoring Rules We define a scoring function by specifying a

function

· (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 the sum of position scores

}){(}){(:

How do we compute the best alignment?

AGTGCCCTGGAACCCTGACGGTGGGTCACAAAACTTCTGGA

AGTGACCTGGGAAGACCCTGACCCTGGGTCACAAAACTC

Too many possible alignments:

>> 2N

(exercise)

19

The Optimal Score The optimal alignment score between two

sequences is the maximal score over all alignments of these sequences:

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 two problems.

nment)score(aligmax),d( & of alignment 21 ss21 ss

Alignment is additive

Observation:The score of aligning x1……xM

y1……yNis additive

Say that x1…xi xi+1…xM aligns to y1…yj yj+1…yN

The two scores add up:

F(x[1:M], y[1:N]) = F(x[1:i], y[1:j]) + F(x[i+1:M], y[j+1:N])

Dynamic Programming

• There are only a polynomial number of subproblems Align x1…xi to y1…yj

• Original problem is one of the subproblems Align x1…xM to y1…yN

• Each subproblem is easily solved from smaller subproblems We will show next

• Then, we can apply Dynamic Programming!!!

Let F(i, j) = optimal score of aligning

x1……xi

y1……yj

F is the DP “Matrix” or “Table”

“Memoization”

Dynamic Programming (cont’d)

Notice three possible cases:

1. xi aligns to yjx1……xi-1 xiy1……yj-1 yj

2. xi aligns to a gapx1……xi-1 xiy1……yj -

3. yj aligns to a gapx1……xi -y1……yj-1 yj

m, if xi = yj

F(i, j) = F(i – 1, j – 1) + -s, if

not

F(i, j) = F(i – 1, j) – d

F(i, j) = F(i, j – 1) – d

Dynamic Programming (cont’d)

How do we know which case is correct?

Inductive assumption:F(i, j – 1), F(i – 1, j), F(i – 1, j – 1) are optimal

Then, F(i – 1, j – 1) + s(xi, yj)

F(i, j) = max F(i – 1, j) – d F(i, j – 1) – d

Where s(xi, yj) = m, if xi = yj; -s, if not

G -

A G T A0 -1 -2 -3 -4

A -1 1 0 -1 -2T -2 0 0 1 0A -3 -1 -1 0 2

F(i,j) i = 0 1 2 3 4

Example

x = AGTA m = 1y = ATA s = -1

d = -1

j = 012

3

F(1, 1) = max{F(0,0) + s(A, A), F(0, 1) – d, F(1, 0) – d} =

max{0 + 1, -1 – 1, -1 – 1} = 1

AA

TT

AA

Procedure to output Alignment

• Follow the backpointers

• When diagonal,OUTPUT xi, yj

• When up,OUTPUT yj

• When left,OUTPUT xi

The Needleman-Wunsch Matrix

x1 ……………………………… xMy1 …

……

……

……

……

……

… y

N

Every nondecreasing path

from (0,0) to (M, N)

corresponds to an alignment of the two sequences

An optimal alignment is composed of optimal subalignments

The Needleman-Wunsch Algorithm

1. Initialization.a. F(0, 0) = 0b. F(0, j) = - j dc. F(i, 0) = - i d

2. Main Iteration. Filling-in partial alignmentsa. For each i = 1……M

For each j = 1……N F(i – 1,j – 1) + s(xi, yj) [case 1]

F(i, j) = max F(i – 1, j) – d [case 2]

F(i, j – 1) – d [case 3]

DIAG, if [case 1]Ptr(i, j) = LEFT, if [case 2]

UP, if [case 3]

3. Termination. F(M, N) is the optimal score, andfrom Ptr(M, N) can trace back optimal alignment

Performance

• Time:O(NM)

• Space:O(NM)

• Later we will cover more efficient methods

28

Recursive Argument Of course, we also need to handle the base cases

in the recursion:

])[,(],[],[)],[(],[],[

],[

1jtj0V1j0V1is0iV01iV

000V

0 A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2

A 2 -4

A 3 -6

C 4 -8

AA- -

We fill the matrix using the recurrence rule:

ST

versus

29

Dynamic Programming Algorithm

We continue to fill the matrix using the recurrence rule

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2

A 2 -4

A 3 -6

C 4 -8

ST

30

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1

A 2 -4

A 3 -6

C 4 -8

V[0,0] V[0,1]

V[1,0] V[1,1]+1

-2 -A A-

-2 (A- versus -A)

versus

ST

31

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0

A 3 -6 -3

C 4 -8 -5

ST

32

Dynamic Programming Algorithm

0

A 1

G 2

C 3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

Conclusion: d(AAAC,AGC) = -1

ST

33

Reconstructing the Best Alignment To reconstruct the best alignment, we record which

case(s) in the recursive rule maximized the score

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

34

Reconstructing the Best Alignment We now trace back a path that corresponds to the

best alignment

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

AAACAG-C

ST

35

Reconstructing the Best Alignment Sometimes, more than one alignment has the best

score

0A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

AAACA-GC

AAAC-AGC

AAACAG-C

36

The Needleman-Wunsch Matrix

x1 ……………………………… xM

y 1 …

……

……

……

……

……

… y

N

Every nondecreasing path

from (0,0) to (M, N)

corresponds to an alignment of the two sequences

An optimal alignment is composed of optimal subalignments

37

The Needleman-Wunsch AlgorithmGlobal Alignment Algorithm

1. Initialization.a. F(0, 0) = 0b. F(0, j) = j dc. F(i, 0) = i d

2. Main Iteration. Filling-in partial alignmentsa. For each i = 1……M

For each j = 1……N F(i-1,j-1) + s(xi, yj) [case 1]

F(i, j) = max F(i-1, j) + d [case 2]

F(i, j-1) + d [case 3]

DIAG, if [case 1]Ptr(i,j) = LEFT, if [case 2]

UP, if [case 3]

3. Termination. F(M, N) is the optimal score, andfrom Ptr(M, N) can trace back optimal alignment

38

Time ComplexitySpace: O(mn)Time: O(mn) Filling the matrix O(mn) Backtrace O(m+n) 0

A1

G2

C3

0 0 -2 -4 -6

A 1 -2 1 -1 -3

A 2 -4 -1 0 -2

A 3 -6 -3 -2 -1

C 4 -8 -5 -4 -1

ST

39

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?

40

Why Do We Need So Much Space?

Compute V(i,j), column by column, storing only two columns in memory (or line by line if lines are shorter).

0

-2

-4

-6

-8

-2

1

-1

-3

-5

-4

-1

0

-2

-4

-6

-3

-2

-1

-1

0A1

G2

C3

0

A 1

A 2

A 3

C 4

Note however that This “trick” fails when we

need to reconstruct the optimizing sequence.

Trace back information requires O(mn) memory bytes.

To compute V[n,m]=d(s[1..n],t[1..m]), we need only O(min(n,m)) space:

Bounded Dynamic Programming

Assume we know that x and y are very similar

Assumption: # gaps(x, y) < k(N)

xi Then, | implies | i – j | < k(N)

yj

We can align x and y more efficiently:

Time, Space: O(N k(N)) << O(N2)

Bounded Dynamic ProgrammingInitialization:

F(i,0), F(0,j) undefined for i, j > k

Iteration:

For i = 1…M For j = max(1, i – k)…min(N, i+k)

F(i – 1, j – 1)+ s(xi, yj)F(i, j) = max F(i, j – 1) – d, if j > i – k(N)

F(i – 1, j) – d, if j < i + k(N)

Termination: same

x1 ………………………… xM

y 1 …

……

……

……

……

…

y N

k(N)

A variant of the basic algorithm:

• Maybe it is OK to have an unlimited # of gaps in the beginning and end:

----------CTATCACCTGACCTCCAGGCCGATGCCCCTTCCGGC ||||||| |||| | || ||GCGAGTTCATCTATCAC--GACCGC--GGTCG--------------

• Then, we don’t want to penalize gaps in the ends

Different types of overlaps

Example:2 overlapping“reads” from a sequencing project

Example:Search for a mouse genewithin a human chromosome

The Overlap Detection variant

Changes:

1. InitializationFor all i, j,

F(i, 0) = 0F(0, j) = 0

2. Termination maxi F(i, N)

FOPT = max maxj F(M, j)

x1 ……………………………… xM

y 1 …

……

……

……

……

……

… y

N

46

The Overlap Detection variantChanges:

1. InitializationFor all i, j,

V(i, 0) = 0V(0, j) = 0

2. Termination maxi V(i,

N)VOPT = max

maxj V(M, j)

x1 ……………………………… xM

y 1 …

……

……

……

……

……

… y

N

47

Overlap Alignment Example

H E A G A W G H E E

0 0 0 0 0 0 0 0 0 0 0

P 0

A 0

W 0

H 0

E 0

A 0

E 0

s = PAWHEAEt = HEAGAWGHEE

Scoring system: Match: +4 Mismatch: -1 Indel: -5

48

Recurrence: as in global alignment

Score: maximum value at the bottom line and rightmost line in the matrix

Overlap Alignment Initialization: V[i,0]=0 , V[0,j]=0

])[,(],[)],[(],[

])[],[(],[max],[

1jtj1iV1is1jiV

1jt1isjiV1j1iV

49

Overlap Alignment Example

H E A G A W G H E E

0 0 0 0 0 0 0 0 0 0 0

P 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1

A 0 -1

W 0 -1

H 0 4

E 0 -1

A 0 -1

E 0 -1

s = PAWHEAEt = HEAGAWGHEE

Scoring system: Match: +4 Mismatch: -1 Indel: -5

50

Overlap Alignment Example

H E A G A W G H E E

0 0 0 0 0 0 0 0 0 0 0

P 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1

A 0 -1 -2 3 -2 3 -2 -2 -2 -2 -2

W 0 -1 -2 -2 2 -2 7 2 -3 -3 -1

H 0 4 -1 -3 -3 1 2 6 6 1 -2

E 0 -1 8 3 -2 -3 0 1 5 10 5

A 0 -1 3 12 7 2 -2 -1 0 5 9

E 0 -1 3 7 11 6 1 -3 -2 4 9

s = PAWHEAEt = HEAGAWGHEE

Scoring system: Match: +4 Mismatch: -1 Indel: -5

51

Overlap Alignment Example

The best overlap is:

PAWHEAE------ ---HEAGAWGHEE

Pay attention! A different scoring system could yield a different result, such as:

---PAW-HEAE HEAGAWGHEE-

The local alignment problem

Given two strings x = x1……xM, y = y1……yN

Find substrings x’, y’ whose similarity (optimal global alignment value)is maximum

x = aaaacccccggggttay = ttcccgggaaccaacc

Why local alignment – examples

• Genes are shuffled between genomes

• Portions of proteins (domains) are often conserved

54

Cross-species genome similarity 98% of genes are conserved between any two mammals >70% average similarity in protein sequence

hum_a : GTTGACAATAGAGGGTCTGGCAGAGGCTC--------------------- @ 57331/400001mus_a : GCTGACAATAGAGGGGCTGGCAGAGGCTC--------------------- @ 78560/400001rat_a : GCTGACAATAGAGGGGCTGGCAGAGACTC--------------------- @ 112658/369938fug_a : TTTGTTGATGGGGAGCGTGCATTAATTTCAGGCTATTGTTAACAGGCTCG @ 36008/68174 hum_a : CTGGCCGCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 57381/400001mus_a : CTGGCCCCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 78610/400001rat_a : CTGGCCCCGGTGCGGAGCGTCTGGAGCGGAGCACGCGCTGTCAGCTGGTG @ 112708/369938fug_a : TGGGCCGAGGTGTTGGATGGCCTGAGTGAAGCACGCGCTGTCAGCTGGCG @ 36058/68174

hum_a : AGCGCACTCTCCTTTCAGGCAGCTCCCCGGGGAGCTGTGCGGCCACATTT @ 57431/400001mus_a : AGCGCACTCG-CTTTCAGGCCGCTCCCCGGGGAGCTGAGCGGCCACATTT @ 78659/400001rat_a : AGCGCACTCG-CTTTCAGGCCGCTCCCCGGGGAGCTGCGCGGCCACATTT @ 112757/369938fug_a : AGCGCTCGCG------------------------AGTCCCTGCCGTGTCC @ 36084/68174 hum_a : AACACCATCATCACCCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 57481/400001mus_a : AACACCGTCGTCA-CCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 78708/400001rat_a : AACACCGTCGTCA-CCCTCCCCGGCCTCCTCAACCTCGGCCTCCTCCTCG @ 112806/369938fug_a : CCGAGGACCCTGA------------------------------------- @ 36097/68174

“atoh” enhancer in human, mouse, rat, fugu fish

The Smith-Waterman algorithm

Idea: Ignore badly aligning regions

Modifications to Needleman-Wunsch:

Initialization: F(0, j) = F(i, 0) = 0

0Iteration: F(i, j) = max F(i – 1, j) – d

F(i, j – 1) – dF(i – 1, j – 1) + s(xi, yj)

The Smith-Waterman algorithm

Termination:

1. If we want the best local alignment…

FOPT = maxi,j F(i, j)

Find FOPT and trace back

2. If we want all local alignments scoring > t

?? For all i, j find F(i, j) > t, and trace back?

Complicated by overlapping local alignments

Waterman–Eggert ’87: find all non-overlapping local alignments with minimal recalculation of the DP matrix

57

Local AlignmentNew option: We can start a new match instead of extending a

previous alignment

01jtj1iV

1is1jiV1jt1isjiV

1j1iV])[,(],[)],[(],[

])[],[(],[max],[

Alignment of empty suffixes

]))1[,(],0[,0max(]1,0[))],1[(]0,[,0max(]0,1[

0]0,0[

jtjVjVisiViV

V

58

Local Alignment Example

0 A 1

T 2

C 3

T 4

A 5

A 6

0 0 0 0 0 0 0 0

T 1 0

A 2 0

A 3 0

T 4 0

A 5 0

s = TAATAt = TACTAA

ST

59

Local Alignment Example

0 T 1

A 2

C 3

T 4

A 5

A 6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0

T 4 0

A 5 0

s = TAATAt = TACTAA

ST

60

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST

61

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST

62

Local Alignment Example

0T1

A2

C3

T4

A5

A6

0 0 0 0 0 0 0 0

T 1 0 1 0 0 1 0 0

A 2 0 0 2 0 0 2 1

A 3 0 0 1 1 0 1 3

T 4 0 0 0 0 2 0 1

A 5 0 0 1 0 0 3 1

s = TAATAt = TACTAA

ST

63

Alignment with gapsObservation: Insertions and deletions often occur in blocks longer than a single nucleotide.

mlengthofgapPmlengthofgapP )1()(

Consequence: Standard scoring of alignment studied in lecture, which give a constant penalty d per gap unit , does not score well this phenomenon; Hence, a better gap score model is needed.Question: Can you think of an appropriate change to the scoring system for gaps?

Scoring the gaps more accurately

Current model:

Gap of length nincurs penalty nd

However, gaps usually occur in bunches

Convex gap penalty function:

(n):for all n, (n + 1) - (n) (n) - (n – 1)

(n)

(n)

Convex gap dynamic programming

Initialization: same

Iteration:F(i – 1, j – 1) + s(xi, yj)

F(i, j) = max maxk=0…i-1F(k, j) – (i – k) maxk=0…j-1F(i, k) – (j – k)

Termination: same

Running Time: O(N2M) (assume N>M)Space: O(NM)

Compromise: affine gaps

(n) = d + (n – 1)e | | gap gap open extend

To compute optimal alignment,

At position i, j, need to “remember” best score if gap is open best score if gap is not open

F(i, j): score of alignment x1…xi to y1…yj

if xi aligns to yj

G(i, j): score if xi aligns to a gap after yj

H(i, j): score if yj aligns to a gap after xi

V(i, j) = best score of alignment x1…xi to y1…yj

de

(n)

67

Needleman-Wunsch with affine gapsWhy do we need two

matrices?

• xi aligns to yj

x1……xi-1 xi xi+1

y1……yj-1 yj -

2. xi aligns to a gapx1……xi-1 xi xi+1

y1……yj …- -

Add -d

Add -e

Needleman-Wunsch with affine gaps

Why do we need matrices F, G, H?

• xi aligns to yj

x1……xi-1 xi xi+1

y1……yj-1 yj -

• xi aligns to a gap after yj

x1……xi-1 xi xi+1

y1……yj …- -

Add -d

Add -e

G(i+1, j) = F(i, j) – d

G(i+1, j) = G(i, j) – e

Because, perhaps

G(i, j) < V(i, j)

(it is best to align xi to yj if we were aligningonly x1…xi to y1…yj and not the rest of x, y),

but on the contrary

G(i, j) – e > V(i, j) – d

(i.e., had we “fixed” our decision that xi alignsto yj, we could regret it at the next step whenaligning x1…xi+1 to y1…yj)

Needleman-Wunsch with affine gaps

Initialization: V(i, 0) = d + (i – 1)eV(0, j) = d + (j – 1)e

Iteration:V(i, j) = max{ F(i, j), G(i, j), H(i, j) }

F(i, j) = V(i – 1, j – 1) + s(xi, yj)

V(i – 1, j) – d G(i, j) = max

G(i – 1, j) – e

V(i, j – 1) – d H(i, j) = max

H(i, j – 1) – e

Termination: V(i, j) has the best alignmentTime?

Space?

To generalize a bit…

… think of how you would compute optimal alignment with this gap function

….in time O(MN)

(n)

71

Remark: Edit DistanceInstead of speaking about the score of an alignment, one often

talks about an edit distance between two sequences, defined to be the “cost” of the “cheapest” set of edit operations needed to transform one sequence into the other.

· Cheapest operation is “no change”· Next cheapest operation is “replace”· The most expensive operation is “add space”.

Our goal is now to minimize the cost of operations, which is exactly what we actually did.

72

Where do scoring rules come from ?We have defined an additive scoring function by specifying a

function ( , ) such that· (x,y) is the score of replacing x by y· (x,-) is the score of deleting x· (-,x) is the score of inserting x

But how do we come up with the “correct” score ?

Answer: By encoding experience of what are similar sequences for the task at hand.

76

Substitution matrix There exist several matrix based on this scoring scheme but

differing by the way the statistic is computed The two major one are PAM and BLOSUM PAM 1 correspond to statistics computed from an global

alignments of proteins with at most 1% of mutations Other PAM matrix (until PAM 250) are extrapolated by

matrix products BLOSUM 62 correspond to statistics from local alignments

with 62% of similarity. Other BLOSUM matrix are build from other alignments

PAM100 ==> Blosum90 PAM120 ==> Blosum80 PAM160 ==> Blosum60 PAM200 ==> Blosum52 PAM250 ==> Blosum45

Linear-Space Alignment

Subsequences and Substrings

Definition A string x’ is a substring of a string x,if x = ux’v for some prefix string u and suffix string v

(similarly, x’ = xi…xj, for some 1 i j |x|)

A string x’ is a subsequence of a string xif x’ can be obtained from x by deleting 0 or more letters

(x’ = xi1…xik, for some 1 i1 … ik |x|)

Note: a substring is always a subsequence

Example: x = abracadabray = cadabr; substringz = brcdbr; subseqence, not substring

Hirschberg’s algortihm

Given a set of strings x, y,…, a common subsequence is a string u that is a subsequence of all strings x, y, …

• Longest common subsequence Given strings x = x1 x2 … xM, y = y1 y2 … yN, Find longest common subsequence u = u1 … uk

• Algorithm:F(i – 1, j)

• F(i, j) = max F(i, j – 1)F(i – 1, j – 1) + [1, if xi = yj; 0 otherwise]

• Ptr(i, j) = (same as in N-W)

• Termination: trace back from Ptr(M, N), and prepend a letter to u whenever • Ptr(i, j) = DIAG and F(i – 1, j – 1) < F(i, j)

• Hirschberg’s original algorithm solves this in linear space

F(i,j)

Introduction: Compute optimal score

It is easy to compute F(M, N) in linear space

Allocate ( column[1] )Allocate ( column[2] )

For i = 1….MIf i > 1, then:

Free( column[ i – 2 ] )

Allocate( column[ i ] )For j = 1…N

F(i, j) = …

Linear-space alignment

To compute both the optimal score and the optimal alignment:

Divide & Conquer approach:

Notation:

xr, yr: reverse of x, yE.g. x = accgg;

xr = ggcca

Fr(i, j): optimal score of aligning xr1…xr

i & yr1…yr

j

same as aligning xM-i+1…xM & yN-j+1…yN

Linear-space alignment

Lemma: (assume M is even)

F(M, N) = maxk=0…N( F(M/2, k) + Fr(M/2, N – k) )

x

y

M/2

k*

F(M/2, k) Fr(M/2, N – k)

Example:ACC-GGTGCCCAGGACTG--CATACCAGGTG----GGACTGGGCAG

k* = 8

Linear-space alignment

• Now, using 2 columns of space, we can computefor k = 1…M, F(M/2, k), Fr(M/2, N – k)

PLUS the backpointers

x1 … xM/2

y1

xM

yN

x1 … xM/2+1 xM

…

y1

yN

…

Linear-space alignment

• Now, we can find k* maximizing F(M/2, k) + Fr(M/2, N-k)• Also, we can trace the path exiting column M/2 from k*

k*

k*+1

0 1 …… M/2 M/2+1 …… M M+1

Linear-space alignment

• Iterate this procedure to the left and right!

N-k*

M/2M/2

k*

Linear-space alignment

Hirschberg’s Linear-space algorithm:

MEMALIGN(l, l’, r, r’): (aligns xl…xl’ with yr…yr’)

1. Let h = (l’-l)/22. Find (in Time O((l’ – l) (r’ – r)), Space O(r’ – r))

the optimal path, Lh, entering column h – 1, exiting column hLet k1 = pos’n at column h – 2 where Lh enters

k2 = pos’n at column h + 1 where Lh exits

3. MEMALIGN(l, h – 2, r, k1)

4. Output Lh

5. MEMALIGN(h + 1, l’, k2, r’)

Top level call: MEMALIGN(1, M, 1, N)

Linear-space alignment

Time, Space analysis of Hirschberg’s algorithm: To compute optimal path at middle column,

For box of size M N,Space: 2NTime: cMN, for some constant c

Then, left, right calls cost c( M/2 k* + M/2 (N – k*) ) = cMN/2

All recursive calls cost Total Time: cMN + cMN/2 + cMN/4 + ….. = 2cMN = O(MN)

Total Space: O(N) for computation, O(N + M) to store the optimal alignment

Heuristic Local Alignerers

1. The basic indexing & extension technique

2. Indexing: techniques to improve sensitivityPairs of Words, Patterns

3. Systems for local alignment

Indexing-based local alignment

Dictionary:All words of length k (~10)Alignment initiated between words of alignment score T

(typically T = k)

Alignment:Ungapped extensions until score

below statistical threshold

Output:All local alignments with score

> statistical threshold

……

……

query

DB

query

scan

Indexing-based local alignment—Extensions

A C G A A G T A A G G T C C A G T

C

T G

A

T

C C

T

G

G

A T

T

G C

G

A

Gapped extensions until threshold

• Extensions with gaps until score < C below best score so far

Output:

GTAAGGTCCAGTGTTAGGTC-AGT

Sensitivity-Speed Tradeoff

long words(k = 15)

short words(k = 7)

Sensitivity Speed

Kent WJ, Genome Research 2002

Sens.

Speed

X%

Sensitivity-Speed Tradeoff

Methods to improve sensitivity/speed

1. Using pairs of words

2. Using inexact words

3. Patterns—non consecutive positions

……ATAACGGACGACTGATTACACTGATTCTTAC……

……GGCACGGACCAGTGACTACTCTGATTCCCAG……

……ATAACGGACGACTGATTACACTGATTCTTAC……

……GGCGCCGACGAGTGATTACACAGATTGCCAG……

TTTGATTACACAGAT T G TT CAC G

Measured improvement

Kent WJ, Genome Research 2002

Non-consecutive words—Patterns

Patterns increase the likelihood of at least one match within a long conserved region

3 common

5 common

7 common

Consecutive Positions Non-Consecutive Positions

6 common

On a 100-long 70% conserved region: Consecutive Non-consecutive

Expected # hits: 1.07 0.97Prob[at least one hit]: 0.30 0.47

Advantage of Patterns

11 positions11 positions

10 positions

Multiple patterns

• K patterns Takes K times longer to scan Patterns can complement one another

• Computational problem: Given: a model (prob distribution) for homology between two regions Find: best set of K patterns that maximizes Prob(at least one match)

TTTGATTACACAGAT T G TT CAC G T G T C CAG TTGATT A G

Buhler et al. RECOMB 2003Sun & Buhler RECOMB 2004

How long does it take to search the query?

Variants of BLAST

• NCBI BLAST: search the universe http://www.ncbi.nlm.nih.gov/BLAST/• MEGABLAST: http://genopole.toulouse.inra.fr/blast/megablast.html

Optimized to align very similar sequences• Works best when k = 4i 16• Linear gap penalty

• WU-BLAST: (Wash U BLAST) http://blast.wustl.edu/ Very good optimizations Good set of features & command line arguments

• BLAT http://genome.ucsc.edu/cgi-bin/hgBlat Faster, less sensitive than BLAST Good for aligning huge numbers of queries

• CHAOS http://www.cs.berkeley.edu/~brudno/chaos Uses inexact k-mers, sensitive

• PatternHunter http://www.bioinformaticssolutions.com/products/ph/index.php Uses patterns instead of k-mers

• BlastZ http://www.psc.edu/general/software/packages/blastz/ Uses patterns, good for finding genes

• Typhon http://typhon.stanford.edu Uses multiple alignments to improve sensitivity/speed tradeoff