1. Greedy Algorithms And Genome Rearrangements An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

2. Turnip vs. Cabbage: Look and Taste Different Although cabbages and turnips share a recent common ancestor, they look and taste different Although cabbages and turnips share a recent common ancestor, they look and taste different An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

3. Turnip vs Cabbage: Comparing Gene Sequences Yields No Evolutionary Information An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

4. Turnip vs Cabbage: Almost Identical mtDNA gene sequences In 1980s Jeffrey Palmer studied evolution of plant organelles by comparing mitochondrial genomes of the cabbage and turnip In 1980s Jeffrey Palmer studied evolution of plant organelles by comparing mitochondrial genomes of the cabbage and turnip 99% similarity between genes 99% similarity between genes These surprisingly identical gene sequences differed in gene order These surprisingly identical gene sequences differed in gene order This study helped pave the way to analyzing genome rearrangements in molecular evolution This study helped pave the way to analyzing genome rearrangements in molecular evolution An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

5. Turnip vs Cabbage: Different mtDNA Gene Order Gene order comparison: Gene order comparison: An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

6. Turnip vs Cabbage: Different mtDNA Gene Order Gene order comparison: Gene order comparison: An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

7. Turnip vs Cabbage: Different mtDNA Gene Order Gene order comparison: Gene order comparison: An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

8. Turnip vs Cabbage: Different mtDNA Gene Order Gene order comparison: Gene order comparison: An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

9. Turnip vs Cabbage: Different mtDNA Gene Order Gene order comparison: Gene order comparison: Before After Evolution is manifested as the divergence in gene order An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

10. Transforming Cabbage into Turnip An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

11. What are the similarity blocks and how to find them? What are the similarity blocks and how to find them? What is the architecture of the ancestral genome? What is the architecture of the ancestral genome? What is the evolutionary scenario for transforming one genome into the other? What is the evolutionary scenario for transforming one genome into the other? Unknown ancestor ~ 75 million years ago Mouse (X chrom.) Human (X chrom.) Genome rearrangements An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

12. History of Chromosome X Rat Consortium, Nature, 2004 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

13. A Genetic Anomaly…

14. Reversals Blocks represent conserved genes. Blocks represent conserved genes. 1 32 4 10 5 6 8 9 7 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

15. Reversals 1 32 4 10 5 6 8 9 7 1, 2, 3, -8, -7, -6, -5, -4, 9, 10 Blocks represent conserved genes. In the course of evolution or in a clinical context, blocks 1,…,10 could be misread as 1, 2, 3, -8, -7, -6, -5, -4, 9, 10. An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

16. Reversals and Breakpoints 1 32 4 10 5 6 8 9 7 1, 2, 3, -8, -7, -6, -5, -4, 9, 10 The reversion introduced two breakpoints (disruptions in order). An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

17. Reversals: Example 5’ ATGCCTGTACTA 3’ 3’ TACGGACATGAT 5’ 5’ ATGTACAGGCTA 3’ 3’ TACATGTCCGAT 5’ Break and Invert An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

18. Types of Rearrangements Reversal 1 2 3 4 5 61 2 -5 -4 -3 6 Translocation 4 1 2 3 4 5 6 1 2 6 4 5 3 1 2 3 4 5 6 1 2 3 4 5 6 Fusion Fission An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

19. Comparative Genomic Architectures: Mouse vs Human Genome Humans and mice have similar genomes, but their genes are ordered differently Humans and mice have similar genomes, but their genes are ordered differently ~245 rearrangements ~245 rearrangements Reversals Reversals Fusions Fusions Fissions Fissions Translocation Translocation An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

20. Waardenburg’s Syndrome: Mouse Provides Insight into Human Genetic Disorder Waardenburg’s syndrome is characterized by pigmentary dysphasia Waardenburg’s syndrome is characterized by pigmentary dysphasia Gene implicated in the disease was linked to human chromosome 2 but it was not clear where exactly it is located on chromosome 2 Gene implicated in the disease was linked to human chromosome 2 but it was not clear where exactly it is located on chromosome 2 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

21. Waardenburg’s syndrome and splotch mice A breed of mice (with splotch gene) had similar symptoms caused by the same type of gene as in humans A breed of mice (with splotch gene) had similar symptoms caused by the same type of gene as in humans Scientists succeeded in identifying location of gene responsible for disorder in mice Scientists succeeded in identifying location of gene responsible for disorder in mice Finding the gene in mice gives clues to where the same gene is located in humans Finding the gene in mice gives clues to where the same gene is located in humans An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

22. Comparative Genomic Architecture of Human and Mouse Genomes To locate where corresponding gene is in humans, we have to analyze the relative architecture of human and mouse genomes To locate where corresponding gene is in humans, we have to analyze the relative architecture of human and mouse genomes An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

23. Pevzner, P. and Tesler, G. (2003). Human and mouse genomic sequences reveal extensive breakpoint reuse in mammalian evolution. PNAS, 100 (13): 7672-7677.

24. Reversals: Example  = A B C D E F G H  = A B C D E F G H  (3,5) A B E D C F G H A B E D C F G H An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info Note: we will ignore directionality of synteny blocks for the sake of simplicity…

25. Reversals: Example  = A B C D E F G H  = A B C D E F G H  (3,5) A B E D C F G H A B E D C F G H  (5,6) A B E D F C G H A B E D F C G H An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

26. Reversals and Gene Orders Gene order is represented by a permutation  Gene order is represented by a permutation   1  ------  i-1  i  i+1 ------  j-1  j  j+1 -----  n   1  ------  i-1  j  j-1 ------  i+1  i  j+1 -----  n Reversal  ( i, j ) reverses (flips) the elements from i to j in  Reversal  ( i, j ) reverses (flips) the elements from i to j in  ,j) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

27. Reversal Distance Problem Goal: Given two permutations, find the shortest series of reversals that transforms one into another Goal: Given two permutations, find the shortest series of reversals that transforms one into another Input: Permutations  and  Input: Permutations  and  Output: A series of reversals  1,…  t transforming  into  such that t is minimum Output: A series of reversals  1,…  t transforming  into  such that t is minimum t : reversal distance between  and  t : reversal distance between  and  d( ,  ) : smallest possible value of t, given  and  d( ,  ) : smallest possible value of t, given  and  An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

28. Sorting By Reversals Problem Goal: Given a permutation, find a shortest series of reversals that transforms it into the identity permutation (1 2 … n ) Goal: Given a permutation, find a shortest series of reversals that transforms it into the identity permutation (1 2 … n ) Input: Permutation  Input: Permutation  Output: A series of reversals  1, …  t transforming  into the identity permutation such that t is minimum Output: A series of reversals  1, …  t transforming  into the identity permutation such that t is minimum An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

29. Sorting By Reversals: Example t =d(  ) = reversal distance of  t =d(  ) = reversal distance of  Example : Example :  = 3 4 2 1 5 6 7 10 9 8  = 3 4 2 1 5 6 7 10 9 8 4 3 2 1 5 6 7 10 9 8 4 3 2 1 5 6 7 10 9 8 4 3 2 1 5 6 7 8 9 10 4 3 2 1 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 So d(  ) = 3 So d(  ) = 3 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

30. Sorting by reversals: 5 steps An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

31. Sorting by reversals: 4 steps An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

32. Sorting by reversals: 4 steps What is the minimum reversal distance for this permutation? Can it be sorted in 3 steps? An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

33. Pancake Flipping Problem The chef is sloppy; he prepares an unordered stack of pancakes of different sizes The chef is sloppy; he prepares an unordered stack of pancakes of different sizes The waiter wants to rearrange them (so that the smallest winds up on top, and so on, down to the largest at the bottom) The waiter wants to rearrange them (so that the smallest winds up on top, and so on, down to the largest at the bottom) He does it by flipping over several from the top, repeating this as many times as necessary He does it by flipping over several from the top, repeating this as many times as necessary Christos Papadimitrou and William Gates flip pancakes An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

34. Pancake Flipping Problem: Formulation Goal: Given a stack of n pancakes, what is the minimum number of flips to rearrange them into perfect stack? Goal: Given a stack of n pancakes, what is the minimum number of flips to rearrange them into perfect stack? Input: Permutation  Input: Permutation  Output: A series of prefix reversals  1, …  t transforming  into the identity permutation such that t is minimum Output: A series of prefix reversals  1, …  t transforming  into the identity permutation such that t is minimum An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

35. Pancake Flipping Problem: Greedy Algorithm Greedy approach: 2 prefix reversals at most to place a pancake in its right position, 2(n – 1) steps total at most Greedy approach: 2 prefix reversals at most to place a pancake in its right position, 2(n – 1) steps total at most William Gates and Christos Papadimitriou showed in the mid-1970s that this problem can be solved by at most 5/3 (n + 1) prefix reversals William Gates and Christos Papadimitriou showed in the mid-1970s that this problem can be solved by at most 5/3 (n + 1) prefix reversals Note: our problem is a bit different in that we may not have to move (i.e., “flip”) some items in order to move others… Note: our problem is a bit different in that we may not have to move (i.e., “flip”) some items in order to move others… An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

36. Sorting By Reversals: A Greedy Algorithm If sorting permutation  = 1 2 3 6 4 5, the first three elements are already in order so it does not make any sense to break them. If sorting permutation  = 1 2 3 6 4 5, the first three elements are already in order so it does not make any sense to break them. The length of the already sorted prefix of  is denoted prefix(  ) The length of the already sorted prefix of  is denoted prefix(  ) prefix(  ) = 3 prefix(  ) = 3 This results in an idea for a greedy algorithm: increase prefix(  ) at every step This results in an idea for a greedy algorithm: increase prefix(  ) at every step An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

37. Doing so,  can be sorted Doing so,  can be sorted 1 2 3 6 4 5 1 2 3 4 6 5 1 2 3 4 6 5 1 2 3 4 5 6 1 2 3 4 5 6 Greedy Algorithm: An Example An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

38. Greedy Algorithm: Pseudocode SimpleReversalSort(  ) 1 for i  1 to n – 1 2 j  position of element i in  (i.e.,  j = i) 3 if j ≠i 4    *  (i, j) 5 output  6 if  is the identity permutation 7 return An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info  3 8 2 5 1 6 7 4  i=1 j=5  *  (i, j) = 1 5 2 8 3 6 7 4

39. Analyzing SimpleReversalSort SimpleReversalSort does not guarantee the smallest number of reversals and takes five steps on  = 6 1 2 3 4 5 : SimpleReversalSort does not guarantee the smallest number of reversals and takes five steps on  = 6 1 2 3 4 5 : Step 1: 1 6 2 3 4 5 Step 1: 1 6 2 3 4 5 Step 2: 1 2 6 3 4 5 Step 2: 1 2 6 3 4 5 Step 3: 1 2 3 6 4 5 Step 3: 1 2 3 6 4 5 Step 4: 1 2 3 4 6 5 Step 4: 1 2 3 4 6 5 Step 5: 1 2 3 4 5 6 Step 5: 1 2 3 4 5 6 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info The number of reversal steps to sort a permutation of length n is at most (n – 1).

40. But it can be sorted in two steps: But it can be sorted in two steps:  = 6 1 2 3 4 5 Step 1: 5 4 3 2 1 6 Step 1: 5 4 3 2 1 6 Step 2: 1 2 3 4 5 6 Step 2: 1 2 3 4 5 6 So, SimpleReversalSort(  ) is not optimal So, SimpleReversalSort(  ) is not optimal Optimal algorithms are unknown for many problems; approximation algorithms are used Optimal algorithms are unknown for many problems; approximation algorithms are used Analyzing SimpleReversalSort (cont ’ d) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

41. Approximation Algorithms These algorithms find approximate solutions rather than optimal solutions These algorithms find approximate solutions rather than optimal solutions The approximation ratio of an algorithm A on input  is: The approximation ratio of an algorithm A on input  is: A(  ) / OPT(  ) A(  ) / OPT(  )where A(  ) -solution produced by algorithm A OPT(  ) - optimal solution of the problem A(  ) -solution produced by algorithm A OPT(  ) - optimal solution of the problem An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

42. Approximation Ratio/Performance Guarantee Approximation ratio (performance guarantee) of algorithm A: max approximation ratio of all inputs of size n Approximation ratio (performance guarantee) of algorithm A: max approximation ratio of all inputs of size n For algorithm A that minimizes objective function (minimization algorithm): For algorithm A that minimizes objective function (minimization algorithm): max |  | = n A(  ) / OPT(  ) max |  | = n A(  ) / OPT(  ) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

43. Approximation Ratio (Performance Guarantee) Approximation ratio (performance guarantee) of algorithm A: max approximation ratio of all inputs of size n Approximation ratio (performance guarantee) of algorithm A: max approximation ratio of all inputs of size n For algorithm A that minimizes objective function (minimization algorithm): For algorithm A that minimizes objective function (minimization algorithm): max |  | = n A(  ) / OPT(  ) max |  | = n A(  ) / OPT(  ) For maximization algorithm: For maximization algorithm: min |  | = n A(  ) / OPT(  ) min |  | = n A(  ) / OPT(  ) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

44. Recall: We are trying to minimize the number of reversals. In the worst case, we will make n-1 reversals for n elements when 2 would have been sufficient (e.g., consider again  = 6 1 2 3 4 5), so m ax |  | = n A(  ) / OPT(  )  (n- 1)/2. For n=1001 the number of reversals undertaken by SimpleReversalSort could be as much as 500 times the optimal. Goal: algorithms with better approximation ratios (i.e., better performance guarantees). An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info What is the approximation ratio of SimpleReversalSort?

45. An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info Key: Try using something else (i.e., besides prefix(  ) as the basis for a greedy algorithm. How about “breakpoints”?

46.  =    2  3 …  n-1  n A pair of elements  i and  i + 1 are termed an adjacency if A pair of elements  i and  i + 1 are termed an adjacency if  i+1 =  i + 1  i+1 =  i + 1 For example: For example:  = 1 9 3 4 7 8 2 6 5  = 1 9 3 4 7 8 2 6 5 (3, 4) or (7, 8) and (6,5) are adjacencies (3, 4) or (7, 8) and (6,5) are adjacencies Adjacencies and Breakpoints An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

47. There is a breakpoint between neighboring elements that are non-consecutive:  = 1 9 3 4 7 8 2 6 5  = 1 9 3 4 7 8 2 6 5 Pairs (1,9), (9,3), (4,7), (8,2) and (2,6) form breakpoints of permutation  Pairs (1,9), (9,3), (4,7), (8,2) and (2,6) form breakpoints of permutation  b(  ) - # breakpoints in permutation  b(  ) - # breakpoints in permutation  Breakpoints: An Example An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

48. Adjacency & Breakpoints An adjacency - a pair of neighboring elements that are consecutive A breakpoint - a pair of neighboring elements that are not consecutive π = 5 6 2 1 3 4 0 5 6 2 1 3 4 7 adjacencies breakpoints Extend π with π 0 = 0 and π 7 = 7 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

49.  = 0 1 9 3 4 7 8 2 6 5 10 We put two elements  0 = 0 and  n + 1 = n+1 at the ends of  We put two elements  0 = 0 and  n + 1 = n+1 at the ends of Example: Extending with 0 and 10 Notes: 1.In the example above, a new breakpoint was created after extending. 2.A permutation on n elements may have as many as n+1 breakpoints and as few as 0. Extending Permutations  = 1 9 3 4 7 8 2 6 5 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

50. Key: Because the non-consecutive elements  i and  i+1 forming a breakpoint must be separated in the process of transforming  to the identity permutation, sorting by reversals can be thought of as the process of eliminating breakpoints.

51. Each reversal can eliminate at most 2 breakpoints.  = 2 3 1 4 6 5 0 2 3 1 4 6 5 7 b(  ) = 5 0 1 3 2 4 6 5 7 b(  ) = 4 0 1 2 3 4 6 5 7 b(  ) = 2 0 1 2 3 4 5 6 7 b(  ) = 0 Reversal Distance and Breakpoints An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

52.  Each reversal eliminates at most 2 breakpoints.  This implies: d(  )  b(  )/2 i.e., reversal distance ≥ #breakpoints / 2 i.e., reversal distance ≥ #breakpoints / 2  = 2 3 1 4 6 5 0 2 3 1 4 6 5 7 b(  ) = 5 0 1 3 2 4 6 5 7 b(  ) = 4 0 1 2 3 4 6 5 7 b(  ) = 2 0 1 2 3 4 5 6 7 b(  ) = 0 Reversal Distance and Breakpoints An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

53. Sorting By Reversals: A Better Greedy Algorithm BreakPointReversalSort(  ) 1 while b(  ) > 0 2 Among all possible reversals, choose reversal  minimizing b(   ) choose reversal  minimizing b(   ) 3     (i, j) 4 output  5 return An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

54. Sorting By Reversals: A Better Greedy Algorithm BreakPointReversalSort(  ) 1 while b(  ) > 0 2 Among all possible reversals, choose reversal  minimizing b(   ) choose reversal  minimizing b(   ) 3     (i, j) 4 output  5 return Question: Will this algorithm terminate? (i.e., how do we know that eliminating one breakpoint doesn’t just introduce another?) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

55. Strips Strip: an interval between two consecutive breakpoints in a permutation Strip: an interval between two consecutive breakpoints in a permutation Decreasing strip: strip of elements in decreasing order (e.g. 6 5 and 3 2 ). Decreasing strip: strip of elements in decreasing order (e.g. 6 5 and 3 2 ). Increasing strip: strip of elements in increasing order (e.g. 7 8) Increasing strip: strip of elements in increasing order (e.g. 7 8) 0 1 9 4 3 7 8 2 5 6 10 0 1 9 4 3 7 8 2 5 6 10 A single-element strip can be declared either increasing or decreasing. We will choose to declare them as decreasing with exception of the strips with 0 and n+1 A single-element strip can be declared either increasing or decreasing. We will choose to declare them as decreasing with exception of the strips with 0 and n+1 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

56. Reducing the Number of Breakpoints Theorem 1: If permutation  contains at least one decreasing strip, then there exists a reversal  which decreases the number of breakpoints (i.e. b(   ) < b(  ) ) If permutation  contains at least one decreasing strip, then there exists a reversal  which decreases the number of breakpoints (i.e. b(   ) < b(  ) ) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

57. Things To Consider For  = 1 4 6 5 7 8 3 2 For  = 1 4 6 5 7 8 3 2 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Choose decreasing strip with the smallest element k in  ( k = 2 in this case) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

58. Things To Consider (cont’d) For  = 1 4 6 5 7 8 3 2 For  = 1 4 6 5 7 8 3 2 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Choose decreasing strip with the smallest element k in  ( k = 2 in this case) An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

59. Things To Consider (cont’d) For  = 1 4 6 5 7 8 3 2 For  = 1 4 6 5 7 8 3 2 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Find k – 1 in the permutation Find k – 1 in the permutation An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

60. Things To Consider (cont’d) For  = 1 4 6 5 7 8 3 2 For  = 1 4 6 5 7 8 3 2 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Choose decreasing strip with the smallest element k in  ( k = 2 in this case) Find k – 1 in the permutation Find k – 1 in the permutation Reverse the segment between k and k-1: Reverse the segment between k and k-1: 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 4 6 5 7 8 3 2 9 b(  ) = 5 0 1 2 3 8 7 5 6 4 9 b(  ) = 4 0 1 2 3 8 7 5 6 4 9 b(  ) = 4 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

61. Reducing the Number of Breakpoints Again If there is no decreasing strip, there may be no reversal  that reduces the number of breakpoints (i.e. b(   ) ≥ b(  ) for any reversal  ). If there is no decreasing strip, there may be no reversal  that reduces the number of breakpoints (i.e. b(   ) ≥ b(  ) for any reversal  ). By reversing an increasing strip ( # of breakpoints stay unchanged ), we will create a decreasing strip at the next step. Then the number of breakpoints will be reduced in the next step (theorem 1). By reversing an increasing strip ( # of breakpoints stay unchanged ), we will create a decreasing strip at the next step. Then the number of breakpoints will be reduced in the next step (theorem 1). An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

62. Things To Consider (cont’d) There are no decreasing strips in , for: There are no decreasing strips in , for:  = 0 1 2 5 6 7 3 4 8 b(  ) = 3   (6,7) = 0 1 2 5 6 7 4 3 8 b(  ) = 3  (6,7) does not change the # of breakpoints  (6,7) does not change the # of breakpoints  (6,7) creates a decreasing strip thus guaranteeing that the next step will decrease the # of breakpoints.  (6,7) creates a decreasing strip thus guaranteeing that the next step will decrease the # of breakpoints. An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

63. ImprovedBreakpointReversalSort ImprovedBreakpointReversalSort(  ) 1 while b(  ) > 0 2 if  has a decreasing strip 3 Among all possible reversals, choose reversal  that minimizes b(   ) that minimizes b(   ) 4 else 5 Choose a reversal  that flips an increasing strip in  6     7 output  8 return An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

64. ImprovedBreakPointReversalSort is an approximation algorithm with a performance guarantee of at most 4. Here’s why: ImprovedBreakPointReversalSort is an approximation algorithm with a performance guarantee of at most 4. Here’s why: It eliminates at least one breakpoint in every two steps, so there are at most 2b(  ) steps It eliminates at least one breakpoint in every two steps, so there are at most 2b(  ) steps Approximation ratio = 2b(  ) / d(  ) Approximation ratio = 2b(  ) / d(  ) Optimal algorithm eliminates at most 2 breakpoints in every step: d(  )  b(  ) / 2 Optimal algorithm eliminates at most 2 breakpoints in every step: d(  )  b(  ) / 2 Performance guarantee: Performance guarantee: ( 2b(  ) / d(  ) ) ?? [ 2b(  ) / (b(  ) / 2) ] ( 2b(  ) / d(  ) ) ?? [ 2b(  ) / (b(  ) / 2) ] ImprovedBreakpointReversalSort: Performance Guarantee An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

65. ImprovedBreakPointReversalSort is an approximation algorithm with a performance guarantee of at most 4. Here’s why: ImprovedBreakPointReversalSort is an approximation algorithm with a performance guarantee of at most 4. Here’s why: It eliminates at least one breakpoint in every two steps, so there are at most 2b(  ) steps It eliminates at least one breakpoint in every two steps, so there are at most 2b(  ) steps Approximation ratio = 2b(  ) / d(  ) Approximation ratio = 2b(  ) / d(  ) Optimal algorithm eliminates at most 2 breakpoints in every step: d(  )  b(  ) / 2 Optimal algorithm eliminates at most 2 breakpoints in every step: d(  )  b(  ) / 2 Performance guarantee: Performance guarantee: ( 2b(  ) / d(  ) )  [ 2b(  ) / (b(  ) / 2) ] = 4 ( 2b(  ) / d(  ) )  [ 2b(  ) / (b(  ) / 2) ] = 4 ImprovedBreakpointReversalSort: Performance Guarantee An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

66. Signed Permutations Up to this point, all permutations to sort were unsigned Up to this point, all permutations to sort were unsigned But genes have directions… so we should consider signed permutations But genes have directions… so we should consider signed permutations 5’5’ 3’3’  = 1 -2 - 3 4 -5 An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info

67. We should, but we won’t right now…

68. GRIMM Web Server http://nbcr.sdsc.edu/GRIMM/grimm.cgi An Introduction to Bioinformatics Algorithms (Jones and Pevzner) www.bioalgorithms.info Real genome architectures are represented by signed permutations Efficient algorithms to sort signed permutations have been developed GRIMM web server computes the reversal distances between signed permutations