1

Genome Rearrangements

(Lecture for CS498-CXZ Algorithms in Bioinformatics)

Dec. 6, 2005

ChengXiang ZhaiDepartment of Computer Science

University of Illinois, Urbana-Champaign

2

Outline

• The Problem of Genome Rearrangements

• Sorting By Reversals

• Greedy Algorithm for Sorting by Reversals– Position-based – Breakpoint-based

3

Genome Rearrangements Example I:Turnip vs Cabbage

• Although cabbages and turnips share a recent common ancestor, they look and taste different

4

Turnip vs Cabbage: Comparing Gene Sequences Yields No Evolutionary Information

5

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

• 99% similarity between genes

• These surprisingly identical gene sequences differed in gene order

• This study helped pave the way to analyzing genome rearrangements in molecular evolution

6

Turnip vs Cabbage: Different mtDNA Gene Order

• Gene order comparison:

7

Turnip vs Cabbage: Different mtDNA Gene Order

• Gene order comparison:

8

Turnip vs Cabbage: Different mtDNA Gene Order

• Gene order comparison:

9

Turnip vs Cabbage: Different mtDNA Gene Order

• Gene order comparison:

10

Turnip vs Cabbage: Different mtDNA Gene Order

• Gene order comparison:

Before

After

Evolution is manifested as the divergence in gene order

11

Transforming Cabbage into Turnip

12

•What are the similarity blocks and how to find them?

•What is the architecture of the ancestral genome?

•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 Example II:Human vs. Mouse

13

History of Chromosome X

Rat Consortium, Nature, 2004

14

Mouse vs Human Genome

• Humans and mice have similar genomes, but their genes are ordered differently

• ~245 rearrangements– Reversal, fusion,

fission, translocation

• Reversal: flipping a block of genes within a genomic sequence

15

Types of Rearrangements

Reversal1 2 3 4 5 6 1 2 -5 -4 -3 6

Translocation1 2 3 44 5 6

1 2 6 4 5 3

1 2 3 4 5 6

1 2 3 4 5 6

Fusion

Fission

Chromosome 1:Chromosome 2:

Chromosome 1:Chromosome 2:

16

Reversals

• Blocks represent conserved genes.

• In the course of evolution blocks 1,…,10 could be misread as 1, 2, 3, -8, -7, -6, -5, -4, 9, 10.

• Rearrangements occurred about once-twice every million years on the evolutionary path between human and mouse.

1 32

4

10

56

89

71, 2, 3, 4, 5, 6, 7, 8, 9, 10

17

Reversals1 32

4

10

56

89

71, 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.

Reversals occurred one-two times every million years on the evolutionary path between human and mouse.

18

Reversals1 32

4

10

56

89

71, 2, 3, -8, -7, -6, -5, -4, 9, 10

The reversion introduced two breakpoints(disruptions in order).

19

Reversals

• Let’s first assume that genes in genome do not have direction

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 the elements from i to j in and transforms into `

,j)

20

Reversals: Example

• Example:

= 1 2 3 4 5 6 7 8

(3,5) ’= 1 2 5 4 3 6 7 8

21

Reversal Distance Problem

• Goal: Given two permutations, find the shortest series of reversals that transforms one into another

• Input: Permutations and

• Output: A series of reversals 1,…t transforming into such that t is minimum

• t - reversal distance between and

• d(, ) - smallest possible value of t, given and

22

Sorting By Reversals Problem[(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

• Output: A series of reversals 1, … t transforming into the identity permutation such that t is minimum

23

Sorting By Reversals: Example

• t =d( ) - reversal distance between and • Example : input: = 3 4 2 1 5 6 7 10 9 8 output: 4 3 2 1 5 6 7 10 9 8 4 3 2 1 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 So d( ) = 3

24

Sorting by reversals

Step 0: 2 -4 -3 5 -8 -7 -6 1Step 1: 2 3 4 5 -8 -7 -6 1Step 2: 2 3 4 5 6 7 8 1Step 3: 2 3 4 5 6 7 8 -1Step 4: -8 -7 -6 -5 -4 -3 -2 -1Step 5: 1 2 3 4 5 6 7 8

25

Sorting by reversalsMost parsimonious scenarios

Step 0: 2 -4 -3 5 -8 -7 -6 1Step 1: 2 3 4 5 -8 -7 -6 1Step 2: -5 -4 -3 -2 -8 -7 -6 1Step 3: -5 -4 -3 -2 -1 6 7 8Step 4: 1 2 3 4 5 6 7 8

The reversal distance is the minimum number of reversals required to transform into .Here, the reversal distance is d=4.

26

Sorting By Reversals: A Greedy Algorithm

• If sorting permutation = 1 2 3 6 4 5, the first three numbers are already in order so it does not make any sense to break them. These already sorted numbers of will be defined as prefix()– prefix() = 3

• This results in an idea for a greedy algorithm: increase prefix() at every step

27

• Doing so, can be sorted

1 2 3 6 4 5

1 2 3 4 6 5 1 2 3 4 5 6• d() = 2• Number of steps to sort permutation of length n

is at most (n – 1)

Greedy Algorithm: An Example

28

Greedy Algorithm: Pseudocode

SimpleReversalSort()1 for i 1 to n – 12 j position of element i in (i.e., j = i)3 if j != i4 * (i, j)5 output 6 if is the identity permutation 7 return

Progress is ensured by moving forward in the position

29

Analyzing SimpleReversalSort

• Greedy algorithm; does not guarantee the smallest number of reversals

• For example, let = 6 1 2 3 4 5

• SimpleReversalSort() takes five steps:• Step 1: 1 6 2 3 4 5• Step 2: 1 2 6 3 4 5 • Step 3: 1 2 3 6 4 5• Step 4: 1 2 3 4 6 5• Step 5: 1 2 3 4 5 6

30

• But it can be done in two steps: = 6 1 2 3 4 5 – Step 1: 5 4 3 2 1 6 – Step 2: 1 2 3 4 5 6

• So, SimpleReversalSort() is not optimal

Analyzing SimpleReversalSort (cont’d)

31

= 23…n-1n

• A pair of elements i and i + 1 are adjacent if

i+1 = i + 1

• For example: = 1 9 3 4 7 8 2 6 5

• (3, 4) or (7, 8) and (6,5) are adjacent pairs

Breakpoints

32

There is a breakpoint between any pair of non-adjacent elements:

= 1 9 3 4 7 8 2 6 5

• Pairs (1,9), (9,3), (4,7), (8,2) and (2,5) form breakpoints of permutation

Breakpoints: An Example

33

• We put two elements 0 and n + 1 at the ends of

0 = 0 and n + 1 = n + 1– This gives us the goal to sort the

elements between the end blocks to the identity permutation

– Example:

Extending with 0 and 10

Note: A new breakpoint was created after extending

Extending Permutations

= 1 9 3 4 7 8 2 6 5

= 0 1 9 3 4 7 8 2 6 5 10

34

b() = number of breakpoints Each reversal eliminates at most 2 breakpoints.

This implies that d() >= b() / 2 = 2 3 1 4 6 5

0 2 3 1 4 6 5 7 b() = 50 1 3 2 4 6 5 7 b() = 40 1 2 3 4 6 5 7 b() = 20 1 2 3 4 5 6 7 b() = 0

Reversal Distance and Breakpoints

35

Sorting By Reversals: A Better Greedy Algorithm

BreakPointReversalSort()1 while b() > 02 Among all possible reversals,

choose minimizing b( • )3 • (i, j)4 output 5 return

36

– Strip: an interval between two consecutive breakpoints in

– Decreasing strips: strips that are in decreasing order (e.g. 6 5 and 3 2 ).

– Increasing strips: strips that are in increasing order (e.g. 7 8)

– A single-element strip can be declared either increasing or decreasing. We will choose to declare them as decreasing with possible exception of the strips with 0 and n+1

Strips

37

Strips: An Example

• For permutation 1 9 3 4 7 8 2 5 6:– There are 7 strips:

0 1 9 4 3 7 8 2 5 6 10

38

Things To Consider

• Fact 1:– If permutation contains at least one

decreasing strip, then there exists a reversal which decreases the number of breakpoints (i.e. b(• ) < b() )

39

Things To Consider (cont’d)

• For = 1 4 6 5 7 8 3 2

• 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) – Find k – 1 in the permutation, reverse the

segment between k and k-1:– 0 1 4 6 5 7 8 3 2 9 b() = 5

– 0 1 2 3 8 7 5 6 4 9 b() = 4

40

Things To Consider (cont’d)

• Fact 2:– If there is no decreasing strip, there may

be no reversal that reduces the number of breakpoints (i.e. b(•) = b() ).

– By reversing an increasing strip ( # of breakpoints stay unchanged ), we will create a decreasing strip at the next step. Then (fact 1) the number of breakpoints will be reduced in the next step.

41

Things To Consider (cont’d)

• There are no decreasing strips in , for:

= 0 1 2 5 6 7 3 4 8 b() = 3

• (3,4) = 0 1 2 5 6 7 4 3 8 b() = 3

(3,4) does not change the # of breakpoints(3,4) creates a decreasing strip, guaranteeing that

the next step will decrease the # of breakpoints.

42

ImprovedBreakpointReversalSortImprovedBreakpointReversalSort()1 while b() > 02 if has a decreasing strip3 Among all possible reversals, choose that

minimizes b( • )4 else5 Choose a reversal that flips an increasing strip

in 6 • 7 output 8 return

43

• ImprovedBreakPointReversalSort is an approximation algorithm with a performance guarantee of at most 4– It eliminates at least one breakpoint in

every two steps; at most 2b() steps– Approximation ratio: 2b() / d()– Optimal algorithm eliminates 2 breakpoints

in every step: d() b() / 2– Performance guarantee:

• ( 2b() / d() ) [ 2b() / (b() / 2) ] = 4

ImprovedBreakpointReversalSort: Performance Guarantee

44

Signed Permutations

• Up to this point, all permutations to sort were unsigned

• But genes have directions… so we should consider signed permutations

5’ 3’

= 1 -2 3 -4

45

GRIMM Web Server

• 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:

http://nbcr.sdsc.edu/GRIMM/grimm.cgi

46

GRIMM Web Server

http://www-cse.ucsd.edu/groups/bioinformatics/GRIMM

47

What You Should Know

• What is genome rearrangement?

• How does the problem of sorting by reversal capture genome rearrangements?

• How do the two greedy algorithms work?