S 2

Computation of Median Gene
Clusters
Marco Argiolas
Valentina Marioli
Introduzione al problema
Durante il corso dell'evoluzione, alcuni geni si sono persi
e altri si sono duplicati, provocando una divergenza tra
genomi che inizialmente avevano lo stesso ordine di geni
e lo stesso contenuto.
Introduzione al problema
Il confronto tra genoma, basato sull'ordine dei geni, è
l'approccio più comune, ma in alcuni casi può essere
utile identificare cluster di geni, ovvero insiemi di 2 o più
geni che occorrono in molti genomi.
Introduzione al problema
Il confronto tra genoma, basato sull'ordine dei geni, è
l'approccio più comune, ma in alcuni casi può essere
utile identificare cluster di geni, ovvero insiemi di 2 o più
geni che occorrono in molti genomi.
Introduzione al problema
Il confronto tra genoma, basato sull'ordine dei geni, è
l'approccio più comune, ma in alcuni casi può essere
utile identificare cluster di geni, ovvero insiemi di 2 o più
geni che occorrono in molti genomi.
Definizione di Gene Clusters
Un genoma S è una stringa di interi in cui ogni intero
rapprensenta un gene.
Geni che appartengono alla stessa famiglia vengono codificati
con lo stesso intero.
Definizione di Gene Clusters
Un genoma S è una stringa di interi in cui ogni intero
rapprensenta un gene.
Geni che appartengono alla stessa famiglia vengono codificati
con lo stesso intero.
1
2
3
4
5
6 7
8
Definizione di Gene Clusters
Un genoma S è una stringa di interi in cui ogni intero
rapprensenta un gene.
Geni che appartengono alla stessa famiglia vengono codificati
con lo stesso intero.
1
π1
8
π2
π3
π4
3
6
1
7
2
3
4
7
2
6
5
4
8
2
5
6 7
4
5
7
6
1
3
8
2
1
4
8
5
3
Gene cluster approssimato
In molte applicazioni la richiesta di avere le esatte
occorrenze del gene cluster in un genoma, risulta essere
troppo restrittiva.
Pertanto è preferibile estendere la definizione di gene
cluster permettendo piccole devianze.
Questo nuovo tipo di cluster viene chiamato gene cluster
approssimato.
Gene cluster approssimato
Rilassando il vincolo dell'uguaglianza, lo spazio di
ricerca di cluster di geni aumenta esponenzialmente
(dipende sia dal numero di confronti che dal numero
di deviazioni permesse).
Alcuni algoritmi risolutivi
Max-gap cluster
Permette un numero arbitrario di gaps nei clusters.
G1 = 1 * 2 3 4 * 5 6 * 7
G2 = 3 * 5 2 1 * 6 * * 7 4
*rappresenta i geni che possono non essere
condivisi tra i due genomi
Alcuni algoritmi risolutivi
Max-gap cluster
Non è in grado di trovare cluster approssimati.
La
complessità
di
questo
problema
cresce
esponenzialemente con il numero di sequenze e risulta
essere:
O(n2) per 2 sequenze, dove n è la lunghezza della sequenza
più lunga.
Alcuni algoritmi risolutivi
ILP
Cerchiamo locazioni perfette in un genoma
un'occorrenza approssimata in un'altra sequenza.
La complessità dell’algoritmo risulta essere:
O(n3 + |occ|) in tempo
O(n3) in spazio.
e
Alcuni algoritmi risolutivi
Quello che noi presenteremo è un algoritmo che risolve
questo problema in
O( n2 (1+ )2) in tempo
O(n2) in spazio,
dove  << n.
Introdurremo un nuovo concetto di cluster, chiamato
median gene cluster che permette di vincolare solo la
somma degli errori che possono essere presenti nelle
occorrenze approssimate di un gene cluster.
Definizioni di base:
intervallo comune
Gene cluster in cui sono permessi:
 ordine variabile dei geni
 occorrenze multiple dello stesso gene
sono noti come: intervalli comuni.
Definizioni di base:
intervallo comune
Un intervallo comune di S1,...,Sk si ha quando
sottostringhe (S1[i1,j1], ..., Sk[ik,jk]) di due o più stringhe
hanno lo stesso insieme di caratteri.
π1
π2
π3
π4
1
2
3
4
5
6
7
8
8
7
6
4
5
2
1
3
3
1
2
5
8
7
6
4
6
7
4
2
1
3
8
5
Definizioni di base:
intervallo comune
Un intervallo comune di S1,...,Sk si ha quando
sottostringhe (S1[i1,j1], ..., Sk[ik,jk]) di due o più stringhe
hanno lo stesso insieme di caratteri.
π1
π2
π3
π4
1
2
3
4
5
6
7
8
8
7
6
4
5
2
1
3
3
1
2
5
8
7
6
4
6
7
4
2
1
3
8
5
Definizioni di base:
intervallo comune
Un intervallo comune di S1,...,Sk si ha quando
sottostringhe (S1[i1,j1], ..., Sk[ik,jk]) di due o più stringhe
hanno lo stesso insieme di caratteri.
π1
π2
π3
π4
1
2
3
4
5
6
7
8
8
7
6
4
5
2
1
3
3
1
2
5
8
7
6
4
6
7
4
2
1
3
8
5
Definizioni di base:
character set
Data:
Una stringa S su un alfabeto finito Σ
Notatione: S[i] = il i-esmio carattere di S
S[i,j] = sottostringa di S che inizia da i e
finisce in j
Definizione:
Esempio:
Un character set CS(S[i,j]) := {S[k] | i ≤ k ≤ j}
è l'insieme di tutti i caratteri che occorrono
in S[i,j].
S: 3 1 2 3 1 5 2 6
1
2
3
4
5
6
7
8
CS(S[2,5]) := {1,2,3}
Definizioni di base: cs-location
Dato:
Un sottoinsieme C  Σ
Definizione: (i, j) è una CS-location di C in S, sse
CS(S[i,j]) = C
Esempio:
S: 3 1 2 3 1 5 2 6
1
2
3
4
5
6
7
8
la coppia (3,5) è una CS-location di un insieme
C={1,2,3}, perchè CS(S[3,5]) = {1,2,3}.
Definizioni di base: massimale
Un sottoinsieme C  Σ e una stringa S
Dato:
Definizione:
S[i,j] è
massimale-sinistro = S[i-1]  CS(S[i,j])
massimale-destro = S[j+1]  CS(S[i,j])
massimale
= massimale-destro e
massimale-sinistro
Esempio:
S: 3 1 2 3 1 5 2 6
1
2
3
4
5
6
7
8
S[3,5] non è massimale sinistro:
S[2]=1 CS(S[3,5]),
ma è massimale destro:
S[6]=5  CS(S[3,5]).
Definizioni di base:
distanza simmetrica
Dati:
Due insiemi di caratteri C,C'  Σ
Definizione: la distanza simmetrica tra insiemi è data da
D(C,C')=|C\C'|+|C'\C|
Esempio:
S1 : 3 1 2 3 1 5 2 6
S2 : 2 1 4 4 1 2 5 7
C1={1,2,3,5,6} , C2={1,2,4,5,7}
|C1\C2|= |{3,6}|=2
|C2\C1|= |{4,7}|=2
D(C1,C2) = 2+2= 4
Definizioni di base: d-location
Un insieme di caratteri C Σ e una stringa S
Dati:
Definizione: una d-location è una sottostringa S[i,j] tale che
D(C,CS(S[i,j])) ≤ d
Esempio:
S: 3 1 2 3 1 5 2 6
1
2
3
4
5
6
7
8
C={1,2,3} e d= 3
CS(S[4,8])={1,2,3,5,6}
D(C,CS(S[4,8])) = 2 ≤ d
quindi S[4,8] è una 3-locazione
Definizioni di base:
la mediana in statistica
In statistica la mediana indica il numero che occupa la posizione
centrale in un insieme di numeri, ovvero la metà dei numeri ha
un valore superiore rispetto alla mediana, mentre l'altra metà ha
un valore inferiore.
Per definire la mediana di un insieme di caratteri, sfrutteremo
una sua importante proprietà:
la mediana rende minima la somma dei valori assoluti degli
scarti.
Definizioni di base:
mediana di un insieme
Dati:
degli insiemi di caratteri C, C1,....Ck Σ
Definizione:
C è una mediana dei k set di caratteri C1,....Ck
se e solo se
per ogni C' 
Definizioni di base:
mediana di un insieme
La mediana di un insieme non è necessariamente unica,
infatti, se k è pari, un carattere che occorre nella mediana
può occorrere in esattamente k insiemi di caratteri.
Pertanto se andiamo a rimuovere quel carattere della
mediana, la distanza totale dagli insiemi C1,..,Ck rimane
inalterata e i caratteri rimanenti formeranno una mediana
alternativa.
Esempio:
C: {1,2,3,4}
C1 : {1,2,6}
C2 : {2,4,5,7,8}
C3 : {1,3,8,9}
C4 : {3,4,10,11}
D(C,C1) = 3
D(C,C2) = 5
D(C,C3) = 4
D(C,C4) = 4
Definizioni di base:
mediana di un insieme
La mediana di un insieme non è necessariamente unica,
infatti, se k è pari, un carattere che occorre nella mediana
può occorrere in esattamente k insiemi di caratteri.
Pertanto se andiamo a rimuovere quel carattere della
mediana, la distanza totale dagli insiemi C1,..,Ck rimane
inalterata e i caratteri rimanenti formeranno una mediana
alternativa.
Esempio:
C: {1,2,3,4}
C1 : {1,2,6}
C2 : {2,4,5,7,8}
C3 : {1,3,8,9}
C4 : {3,4,10,11}
D(C,C1) = 3
D(C,C2) = 5
D(C,C3) = 4
D(C,C4) = 4
Definizioni di base:
mediana di un insieme
La mediana di un insieme non è necessariamente unica,
infatti, se k è pari, un carattere che occorre nella mediana
può occorrere in esattamente k insiemi di caratteri.
Pertanto se andiamo a rimuovere quel carattere della
mediana, la distanza totale dagli insiemi C1,..,Ck rimane
inalterata e i caratteri rimanenti formeranno una mediana
alternativa.
Esempio:
C1 : {1,2,6}
C2 : {2,5,7,8}
C: {1,2,3}
C3 : {1,3,8,9}
E’ ancora una mediana.
C4 : {3,10,11}
D(C,C1) = 3 – 1 = 2
D(C,C2) = 5 + 1 = 6
D(C,C3) = 4 – 1 = 3
D(C,C4) = _4 + 1 = 5
_
16
16
Definizioni del problema
Date k sequenze S1,...,Sk, una dimensione minima di
cluster s e una soglia , vogliamo calcolare tutti gli insiemi
C  Σ con |C| ≥ s per i quali esistono S1[i1,j1], ..., Sk[ik,jk] e
C è una mediana di CS(S1[i1,j1]), ..., CS(Sk[ik,jk]) con
Un tale insieme C viene chiamato median gene cluster di
S1,...,Sk.
Lemma: Premesse
Siano date le sequenze S1….Sk , aventi come sottostringhe
S1[i1,j1],…,Sk[ik,jk], tali che per una data soglia di tolleranza
δ ≥ 0 esista un Character Set C appartenente all’alfabeto ∑,
e la sommatoria
D(C, CS (S[il,jl]) ≤ δ
Lemma: Conclusioni
Con queste premesse possiamo dire che esiste almeno una
sottostringa Sm[im,jm], dove 1 ≤ m ≤ k, con C' = CS (Sm[im,jm]
e che esiste la sommatoria
D(C', CS (Sl[il,jl]) ≤ 2
δ
Lemma: Dimostrazione
Tra le sottostringhe S1[i1,j1],…,Sk[ik,jk], prendiamo la sottostringa
Sm[im,jm], dove 1 ≤ m ≤ k, tale che D(C, CS (Sm[im,jm])) ≤
Dalla disuguaglianza triangolare possiamo dire che:
.
Lemma: Considerazioni
 Il character set che abbiamo indicato con C' viene utilizzato
per filtrare lo spazio di ricerca di un potenziale Median
Gene Cluster e quindi viene chiamato Cluster Filter;
 Il Lemma ci fornisce l’approccio per definire i passi
dell’algoritmo Median Gene Cluster.
Median Gene Cluster: Approccio
1.
Calcolare l’insieme dei Cluster Filters C' per le sequenze
S1….Sk;
2.
Calcolare, per ogni C', k-tuple in forma S1[i1,j1],…,Sk[ik,jk],
dove almeno uno degli elementi sia una locazione di C' e
soddisfi le condizioni del Lemma;
3.
Calcolare per ogni k-tupla la mediana del corrispondente
Character Set (CS). Una mediana che soddisfa il Lemma è
detta Median Gene Cluster
Calcolo dei Cluster Filter (Passo 1)
 In k sequenze di lunghezza n possiamo avere O(kn2)
sottostringhe.
 Un algoritmo naif può determinare tutti i cluster filter in
O(k2n4) confrontando le differenze tra le coppie di tutte le
sottostringhe.
 Presentiamo ora due approcci diversi basati sull’algoritmo
Connecting Intervals per diminuire la complessità.
Algoritmo Connecting Intervals (CI)
 L’algoritmo Connecting Intervals trova gli intervalli
comuni tra sequenze S1….Sk, di lunghezza n, appartenenti
all’alfabeto ∑
 Ha un passo di preprocessing dove crea un’array POS e una
tabella NUM.
 Vediamo un’esempio di esecuzione dell’algoritmo con:
k = 2
∑ = {1,2,3,4,5,6}
 S1= (2,4,5)
 S2= (1,3,5,2,4,5,2,4,3,6,2,5)
Preprocessing: Array POS
L’array POS è lungo |∑| e serve per elencare, per ogni
carattere c appartenente a ∑, tutte le posizioni in cui
occorrono in
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
POS[1] = 1
POS[3] = 2, 9
POS[5] = 3, 6, 12
POS[2] = 4, 7, 11
POS[4] = 5, 8
POS[6] = 10
Preprocessing: Array POS
L’array POS è lungo |∑| e serve per elencare, per ogni
carattere c appartenente a ∑, tutte le posizioni in cui
occorrono in
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
POS[1] = 1
POS[3] = 2, 9
POS[5] = 3, 6, 12
POS[2] = 4, 7, 11
POS[4] = 5, 8
POS[6] = 10
Preprocessing: Array POS
L’array POS è lungo |∑| e serve per elencare, per ogni
carattere c appartenente a ∑, tutte le posizioni in cui
occorrono in
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
POS[1] = 1
POS[3] = 2, 9
POS[5] = 3, 6, 12
POS[2] = 4, 7, 11
POS[4] = 5, 8
POS[6] = 10
Preprocessing: Tabella NUM
La tabella NUM è grande |S2| x |S2| e ogni sua entry
contiene il numero di caratteri diversi che occorrono in
ogni sottosequenza S2[i,j]
S2[2,5] = (3,5,2,4)
S2[2,7] = (3,5,2,4,5,2)
NUM[2,5] = 4
NUM[2,7] = 4
Preprocessing: Tabella NUM
La tabella NUM è grande |S2| x |S2| e ogni sua entry
contiene il numero di caratteri diversi che occorrono in
ogni sottosequenza S2[i,j]
S2[2,5] = (3,5,2,4)
S2[2,7] = (3,5,2,4,5,2)
NUM[2,5] = 4
NUM[2,7] = 4
Preprocessing: Tabella NUM
La tabella NUM è grande |S2| x |S2| e ogni sua entry
contiene il numero di caratteri diversi che occorrono in
ogni sottosequenza S2[i,j]
S2[2,5] = (3,5,2,4)
S2[2,7] = (3,5,2,4,5,2)
NUM[2,5] = 4
NUM[2,7] = 4
Algoritmo CI: Esecuzione
Considera tutte le sottostringhe massimali di S1;
2. Marca, utilizzando l’array POS, le posizioni che
contengono i simboli di S1[i,j] nella sequenza S2 in
maniera iterativa;
3. Trova gli intervalli comuni confrontando i simboli della
sottostringa S1[i,j] con quelli marcati in S2.
1.
Algoritmo CI: Esempio
Supponiamo che i = 1 e j = 3:
S1[1,3]= (2,4,5)
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
Algoritmo CI: Esempio
Supponiamo che i = 1 e j = 3:
S1[1,3]= (2,4,5)
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
Algoritmo CI: Considerazioni
 Ad ogni passo dell’algoritmo, il CS degli intervalli marcati
in S2 è un sottoinsieme del CS di ogni S1[i,j]. Questo può
essere verificato tenendo traccia del numero dei caratteri
diversi in un array OCC e confrontandoli con la tabella
NUM, usando il valore per la entry corrispondente.
 L’algoritmo considera solo gli intervalli estesi durante
l’ultima iterazione.
Algoritmo CI: Esempio
S1 = (2,4,5)
|OCC| = 3
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
NUM[3,8] = 3
NUM[11,12] = 2
Algoritmo CI: Esempio
S1 = (2,4,5)
|OCC| = 3
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
NUM[3,8] = 3
NUM[11,12] = 2
Algoritmo CI: Esempio
S1 = (2,4,5)
|OCC| = 3
S2= (1,3,5,2,4,5,2,4,3,6,2,5)
NUM[3,8] = 3
NUM[11,12] = 2
Algoritmo CI: Considerazioni
 Ogni carattere è al più |S1| volte l’ultimo carattere della
sottostringa di S1 e ogni posizione in S2 può essere marcata
al più |S1| volte. Questo perché per ogni ciclo ho una i fissa
e la j che incrementa di una posizione.
 Ad ogni ciclo viene esteso un intervallo, vengono fusi due
intervalli oppure vengono creati nuovi intervalli.
 Ci sono al più |S1| x |S2| estensioni di intervalli e lo stesso
numero di confronti di character set.
Algoritmo CI: Complessità
La complessità dell’algoritmo risulta essere:
 O(n2) in tempo (confronti tra sottostringhe)
 O(n2) in spazio (costruzione array POS e tabella NUM)
Algoritmo CI: Problema
L’algoritmo Connecting Intervals considera solo le
sottosequenze che hanno esattamente gli stessi geni.
Quindi non può essere usato per trovare sequenze che
differiscano di qualche simbolo.
Algoritmo Connecting Intervals
with Errors (CIE)
 Questo algoritmo ci consente di trovare Cluster Filters che
differiscano al massimo di un valore δ arbitrario.
 Per semplicità confrontiamo 2 sequenze (k=2).
 Quindi per il Lemma abbiamo che
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Algoritmo CIE: Pseudocodice
Differenza con CI
La differenza sostanziale con l’algoritmo CI è il calcolo e
l’utilizzo di l e r
Differenza con CI
La differenza sostanziale con l’algoritmo CI è il calcolo e
l’utilizzo di l e r
Calcolo di l e r
 Indichiamo con p come una posizione marcata in S2
 lx(p) = max({l | S2[l, p] contenente x differenti simboli non
marcati} U {0})
 ry(p) = min({r | S2[p, r] contenente x differenti simboli non
marcati} U {|S2| + 1})
 x, y ≥ 1
Uso di l e r
 Per costruzione, gli intervalli S2[lx+1, ry-1] contengono al più
x+y-2 simboli non presenti in S1[i,j] e sono massimali
 per ogni i e j, con i ≤ j, l’uso di l e r serve per determinare il
numero di simboli diversi all’interno dell’intervallo
corrente (dist).
Uso di l e r
 La variabile dist viene confrontata con quella minDist e
quella più piccola viene confrontata con il valore di soglia δ
 Se minDist è inferiore a δ allora la coppia i, j viene inserita
nel resultSet che contiene i Cluster Filter
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
\
1 2 3 4 5 6 7 8 9 10 11 12
p=7
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
1 2 3 4 5 6 7 8 9 10 11 12
p=7
l1(7) = 6
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
1 2 3 4 5 6 7 8 9 10 11 12
p=7
l1(7) = 6
l2(7) = 1
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
1 2 3 4 5 6 7 8 9 10 11 12
p=7
l1(7) = 6
r1(7) = 10
l2(7) = 1
Algoritmo CIE: Esempio
S1 = (1,3,4,2)
S1 [2,4]= (3,4,2)
δ=1
S2= (1, 3, 5, 2, 4, 5, 2, 4, 3, 6, 2, 5)
1 2 3 4 5 6 7 8 9 10 11 12
p=7
l1(7) = 6
r1(7) = 10
l2(7) = 1
r2(7) = 12
Algoritmo CIE: Esempio
Quindi devo considerare le sottostringhe
S2 [2,9]= (3,5,2,4,5,2,4,3)
2. S2 [2,11]= (3,5,2,4,5,2,4,3,6,2)
3. S2 [7,9]= (2,4,3)
4. S2 [7,11]= (2,4,3,6,2)
1.
Algoritmo CIE: Esempio
Quindi devo considerare le sottostringhe
S2 [2,9]= (3,5,2,4,5,2,4,3)
2. S2 [2,11]= (3,5,2,4,5,2,4,3,6,2)
3. S2 [7,9]= (2,4,3)
4. S2 [7,11]= (2,4,3,6,2)
1.
Algoritmo CIE: Esempio
Quindi devo considerare le sottostringhe
S2 [2,9]= (3,5,2,4,5,2,4,3)
2. S2 [2,11]= (3,5,2,4,5,2,4,3,6,2)
3. S2 [7,9]= (2,4,3)
4. S2 [7,11]= (2,4,3,6,2)
1.
Algoritmo CIE: Esempio
Quindi devo considerare le sottostringhe
S2 [2,9]= (3,5,2,4,5,2,4,3)
2. S2 [2,11]= (3,5,2,4,5,2,4,3,6,2)
3. S2 [7,9]= (2,4,3)
4. S2 [7,11]= (2,4,3,6,2)
1.
Algoritmo CIE: Esempio
Quindi devo considerare le sottostringhe
S2 [2,9]= (3,5,2,4,5,2,4,3)
2. S2 [2,11]= (3,5,2,4,5,2,4,3,6,2)
3. S2 [7,9]= (2,4,3)
4. S2 [7,11]= (2,4,3,6,2)
1.
Le sottostringhe 1,3,4 vengono inserite in ResultSet
La sottostringa 2 non viene inserita
Algoritmo CIE: Complessità
 O(n2) in tempo (operazione di marcatura)
 O(n) in tempo (calcolo di l e r)
 O((δ+1) 2) (verificare della distanza di ogni coppia)
 O(n2) in spazio (costruzione array POS e tabella NUM)
L’algoritmo CIE costa in totale O(n2(n+δ2)) in tempo e
O(n2) in spazio
Algoritmo CIE: Variazione
Possiamo limitare il numero delle ripetizioni di un simbolo
in S2 con il valore b. In questo modo:
 il numero di passi per la determinazione di l e r viene
limitato da O(min{bδ})
 la complessità diventa O(n2(1+ min{bδ} + δ2)).
Questa variazione risulta particolarmente importante in
certe sequenze genetiche che hanno un valore b molto
basso.
Preprocessing: Rank
Posso ridurre a O(n2(1+2)) il tempo avendo a
disposizione uno spazio di O(n).
L'osservazione chiave è che per ogni posizione p nella
sequenza S2 i valori di lx e rx sono gli stessi per tutti gli
intervalli S1[i,j] con un bordo sinistro comune.
Preprocessing: Rank
I valori lx e rx sono memorizzati in due tabelle L e R di
dimensioni  x |S2| ciascuna.
Il valori di questi array deve essere aggiornato ogni volta
che il bordo sinistro i in S1 è mosso a destra e questo accade
O(n) volte.
Preprocessing: rinomino con Rank
Passi per l’inizializzazione e l’aggiornamento delle tabelle L
e R:
1)Per poter creare le tabelle L e R è necessario rinominare i
caratteri delle sequenze S1 e S2 con il rango della prima
occorrenza nella concatenazione della stringa S1[i,|S1|]S2,
inizialmente per i=1 e poi per ogni incremento di i.
Preprocessing: rinomino con Rank
Calcoliamo RANK: ∑→{1, ...., |∑|}.
Esempio :
S1
i
S2
S1[i,|S1|]S2 : 2 4 2 3 4 1 4 5 4 3 6 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
RANK[1] = ?4
RANK[2] = 1
1
2
3
RANK[3] = 3
4
RANK[4] = 2
5
6
RANK[5] = 5
RANK[6] = 6
Preprocessing: rinomino con Rank
Esempio: Rinominiamo i caratteri di S2 con il loro rango.
RANK[1] = 4
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
RANK[2] = 1
RANK[3] = 3
RANK[4] = 2
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
RANK[5] = 5
RANK[6] = 6
Preprocessing: creo L e R
2) Inizializziamo le tabelle L e R nel seguente modo:
Per ogni posizione p in S2 andiamo alla sua sinistra (e poi
alla sua destra) e cerchiamo i primi +1 caratteri che hanno
un rank maggiore del Rank(S2(p)).
Memorizziamo come l1, ......, l+1 ( e r1, ......, r+1)le posizioni
in cui un nuovo carattere diverso viene individuato.
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0 1
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0 1 0
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0 1 0
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0 1 0 3
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella L.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
l1 : 0 1 0 3 3 0 6 6 6 0 10 10
l2 : 0 0 0 2 2 0 5 2 1 0 9 0
l3 : 0 0 0 1 1 0 2 1 0 0 8 0
Tabella L
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella R.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
r1 :
r2 :
r3 :
3
Preprocessing: Creo L e R
Esempio:
Inizializziamo la tabella R.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
r1 :
r2 :
r3 :
3 3
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella R.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
r1 :
r2 :
r3 :
3 3 10
Preprocessing: creo L e R
Esempio:
Inizializziamo la tabella R.
S2 : 1 3 5 2 4 5 2 4 3 6 2 5
1
2
3
4
5
6
7
8
9 10 11 12
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
r1 :
3 3 10 5 6 10 8 8 10 13 12 13
r2 : 10 10 13
6 9 13 9 10 12 13 13 13
r3 : 13 13 13
9 10 13 10 12 13 13 13 13
Tabella R
Preprocessing: aggiorno il Rank
3)Aggiornamento del rank
Quando il bordo sinistro di una sottostringa di S1 viene
shiftato da i a i+1, il rank di tutti i caratteri che occorrono tra
i e la successiva occorrenza del carattere S1[i] decresce di uno,
mentre il rank di cold=S1[i] aumenta del numero di caratteri
differenti tra le due occorrenze.
Esempio:
i
S1: 2 4 2 3 4 1 4 5 4 3 6
1
2
3
4
5
6
7
8
9 10 11
RANK[2] = 1 + 1 = 2
RANK[4] = 2 - 1 = 1
Preprocessing: aggiorno il Rank
3)Aggiornamento del rank
Aggiorno le entry delle tabelle L e R con il nuovo valore
di cold .
Esempio:
S'2 : 4 3 5 1 2 5 1 2 3 6 1 5
RANK[2] = 1 + 1 = 2
RANK[4] = 2 - 1 = 1
S''2 : 4 3 5 2 1 5 2 1 3 6 2 5
Preprocessing: aggiorno il Rank
3)Aggiornamento del rank
Per le posizioni in S2 con caratteri differenti da cold le entry
delle tabelle L e R cambiano solo se il rank del carattere è più
piccolo del nuovo valore di cold .
Esempio:
1
2
3
4
5
6
7
8
9 10 11 12
S''2 : 4 3 5 2 1 5 2 1 3 6 2 5
l1 : 0 1 0 3 3 0 6 6 6 0 10 10
l2 : 0 0 0 2 2 0 5 2 1 0 9 0
l3 : 0 0 0 1 1 0 2 1 0 0 8 0
Preprocessing: aggiorno il Rank
3)Aggiornamento del rank
Per le posizioni in S2 con caratteri differenti da cold le entry
delle tabelle L e R cambiano solo se il rank del carattere è più
piccolo del nuovo valore di cold .
Esempio:
1
2
3
4
5
6
7
8
9 10 11 12
S''2 : 4 3 5 2 1 5 2 1 3 6 2 5
l1 : 0 1 0 3 4 0 6 6 6 0 10 10
l2 : 0 0 0 2 2 0 5 2 1 0 9 0
l3 : 0 0 0 1 1 0 2 1 0 0 8 0
Preprocessing: aggiorno il Rank
3)Aggiornamento del rank
Per le posizioni in S2 con caratteri differenti da cold le entry
delle tabelle L e R cambiano solo se il rank del carattere è più
piccolo del nuovo valore di cold .
Esempio:
1
2
3
4
5
6
7
8
9 10 11 12
S''2 : 4 3 5 2 1 5 2 1 3 6 2 5
l1 : 0 1 0 3 4 0 6 7 6 0 10 10
l2 : 0 0 0 2 3 0 5 6 1 0 9 0
l3 : 0 0 0 1 2 0 2 2 0 0 8 0
Preprocessing: Complessità
L’inizializzazione richiede O(n2) in tempo e
l’aggiornamento O(n) in tempo ad ogni incremento di i.
Con tali modifiche, l’algoritmo CIE costa:
O(n2 +n2(1+  2)) = O(n2(1+  2)) in tempo
O(n +n2) = O(n2) in spazio.
Estensione a genomi multipli
D
Dovremo considerare tutti i possibili cluster filter C’,
di ogni possibile sottostringa di S1, …, Sk.
Un intervallo Sl[i,j] sara’ un cluter filter se la somma
delle distanze minime dalle altre k-1 sequenze non
eccede
Tra ogni coppia dovra’ ancora essere rispettata la
distanza δ, altrimenti nella somma totale non
sarebbe rispettata la disuguaglianza triangolare del
lemma 1.
Estensione a genomi multipli
1) Per ogni carattere Sl[j] dobbiamo esaminare tutte le
tutte le sue occorrenze nelle altre k-1 sequenze.
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
Esempio:
Esaminiamo tutte le tutte le occorrenze del
carattere S1[2] nelle altre 3 sequenze.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
Esempio:
Esaminiamo tutte le tutte le occorrenze del
carattere S1[2] nelle altre 3 sequenze.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
2) Per ogni occorrenza del carattere Sl[j] dobbiamo
calcolarci lx e rx nelle altre k-1 sequenze, per poter poi
calcolare D(CS(Sl[i,j]), CS(Sj[lx+1,ry-1]))
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
2) Per ogni occorrenza del carattere Sl[j] dobbiamo
calcolarci lx e rx nelle altre k-1 sequenze, per poter poi
calcolare D(CS(Sl[i,j]), CS(Sj[lx+1,ry-1]))
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
2) Per ogni occorrenza del carattere Sl[j] dobbiamo
calcolarci lx e rx nelle altre k-1 sequenze, per poter poi
calcolare D(CS(Sl[i,j]), CS(Sj[lx+1,ry-1]))
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
2) Per ogni occorrenza del carattere Sl[j] dobbiamo
calcolarci lx e rx nelle altre k-1 sequenze, per poter poi
calcolare D(CS(Sl[i,j]), CS(Sj[lx+1,ry-1]))
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Genomi multipli: esempio
3) Calcoliamo il valore di mindist in maniera separata
per ogni sequenza S1, ..., Sk.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
mindist1
S2 : 1 2 4 1 2 1 3
mindist2
S3 : 1 3 3 1 2 1 2
mindist3
S4 : 1 4 1 1
mindist4
1
2
3
4
5
6
7
8
Genomi multipli: esempio
3) Calcoliamo il valore di mindist in maniera separata
per ogni sequenza S1, ..., Sk.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
mindist1
S2 : 1 2 4 1 2 1 3
mindist 2 = [1,2]
S3 : 1 3 3 1 2 1 2
mindist3
S4 : 1 4 1 1
mindist4
1
2
3
4
5
6
7
8
Genomi multipli: esempio
3) Calcoliamo il valore di mindist in maniera separata
per ogni sequenza S1, ..., Sk.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
mindist1
S2 : 1 2 4 1 2 1 3
mindist 2 = [1,2]
S3 : 1 3 3 1 2 1 2
mindist3 = [4,7]
S4 : 1 4 1 1
mindist4= [3,4]
1
2
3
4
5
6
7
8
Genomi multipli: esempio
4) Se
mindisti ≤ d
allora ho trovato un cluster filter.
j
S1 [2]
S1 : 1 2 1 3 1 4 1 5
mindist1
S2 : 1 2 4 1 2 1 3
mindist 2 = [1,2]
S3 : 1 3 3 1 2 1 2
mindist3 = [4,7]
S4 : 1 4 1 1
mindist4= [3,4]
1
2
3
4
5
6
7
8
Genomi multipli: Complessità
O(k2) in tempo, per ognuno
precedentemente presentati;
O(kn2) in spazio.
degli
algoritmi
Collezione di locazioni (Passo 2)
Ora che abbiamo calcolato tutti i possibili cluster
filter, li useremo per farci guidare nella ricerca dei
nostri Median Gene Cluster.
Per ogni cluster filter C', calcoleremo le sue massime
δ-locazioni di ogni sequenza S1, ..., Sk in modo da
formare k-tuple (S1[i1,j1], ..., Sk[ik,jk]), tali che gli
insiemi di caratteri di ogni coppia soddisfi:
Collezione di locazioni (Passo 2)
Esempio:
Calcoliamo le massime 3-locazioni di ogni sequenza S1,...,Sk
per il cluster filter C'={1,2} tali che soddisfino il lemma.
Ricordiamo che una δ-locazione di un insieme di caratteri
C in una stringa S è una sottosequenza S[i,j] tale che:
D(C, CS(S[i,j])) ≤ δ.
S1 : 1 2 1 3 1 4 1 5
S2 : 1 2 4 1 2 1 3
S3 : 1 3 3 1 2 1 2
S4 : 1 4 1 1
1
2
3
4
5
6
7
8
Collezione di locazioni (Passo 2)
Esempio:
Verifichiamo se il lemma è soddisfatto per d=10:
D(C', CS(S1[1,2])) + D(C', CS(S2[1,6])) + D(C', CS(S3[4,7])) +
D(C', CS(S4[1,4])) = 3 + 2 +1 +2 = 8 ≤ d
E’ soddisfatto. Abbiamo dunque individuato le k-tuple che
useremo nel prossimo passo.
S1 : 1 2 1 3 1 4 1 5
S1[1,2]
S2 : 1 2 4 1 2 1 3
S2[1,6]
S3 : 1 3 3 1 2 1 2
S3[4,7]
S4 : 1 4 1 1
S4[1,4]
1
2
3
4
5
6
7
8
C'={1,2}
Collezione di locazioni (Passo 2)
Il numero delle δ-locazioni massimali è O(kn2),
mentre il numero di k-tuple può essere esponenziale
in k.
Tuttavia per sequenze di geni, dove |∑| è Θ(n)
l'esperienza mostra che questo approccio è flessibile
per valori ragionevoli di δ.
Calcolo dei Median Gene
Clusters tra k-tuple (Passo 3)
Per individuare una mediana:
1. Esaminare le k-tuple ricavate dal Passo 2;
2. Contare le occorrenze di ogni gene in ognuna di esse;
3. Se un gene occorre in totale k/2 volte diventa un
elemento di una mediana
Verifica di una mediana
Ogni mediana ricavata deve soddisfare le condizioni del
Lemma.
In questo caso viene classificata come mediana del gene
cluster.
Possono esserci varie mediane da testare
Numero delle mediane
Una mediana esiste solo se il numero di geni in comune è
inferiore o uguale a
, per il fatto che che ogni gene
aggiunge k / 2 alla somma delle distanze.
In questo caso, esistono 2 possibili mediane.
Esempio
S1 = (1 2 1 3 1 4 1 5)
S2 = (1 2 4 1 2 1 3)
S3 = (1 3 3 1 2 1 2)
S4 = (1 4 1 1)
δ =3
C = {1, 2}
cluster filter
Esempio
S1 = (1 2 1 3 1 4 1 5)
S2 = (1 2 4 1 2 1 3)
S3 = (1 3 3 1 2 1 2)
S4 = (1 4 1 1)
δ =3
C = {1, 2}
cluster filter
Esempio
S1 = (1 2 1 3 1 4 1 5)
S2 = (1 2 4 1 2 1 3)
S3 = (1 3 3 1 2 1 2)
S4 = (1 4 1 1)
δ =3
C = {1, 2}
cluster filter
Esempio
S1 = (1 2 1 3 1 4 1 5)
S2 = (1 2 4 1 2 1 3)
S3 = (1 3 3 1 2 1 2)
S4 = (1 4 1 1)
δ =3
C = {1, 2}
cluster filter
Esempio
S1 = (1 2 1 3 1 4 1 5)
S2 = (1 2 4 1 2 1 3)
S3 = (1 3 3 1 2 1 2)
S4 = (1 4 1 1)
δ =3
C = {1, 2}
cluster filter
Quindi le mediane risultanti sono {1,2} e {1,2,4}
Verifica Lemma
Le mediane sono {1, 2} e {1, 2, 4} per le quali il Lemma è
verificato
Possibili duplicati
In base alle varie k-tuple potrebbero esserci dei duplicati
tra i median gene clusters.
L’algoritmo, in questo caso, elimina i duplicati.
Costo Totale
 L’algoritmo MGC costa:
 O(n2 +n2(1+  2)) = O(n2(1+ )2) in tempo
 O(n +n2) = O(n2) in spazio.
Confronto con Max-Gap
Clusters
Vantaggi di MGC su modello max-gap clusters:
1. Non ci sono problemi in caso di bassa densità dei
cluster;
2. Non è necessario specificare un determinato gap;
3. MGC è in grado di trovare cluster approssimati
(importante per particolare confronti di genomi).
Confronto con ILP
Vantaggi di MGC su modello ILP per la ricerca di gene
cluster approssimati:
1. Più efficiente per il calcolo dei cluster, anche se i cluster
risultanti sono simili;
2. Vantaggio superiore nell’applicazione a genomi multipli.
Risultati degli Esperimenti
Entrambi gli approcci presentati sono applicabili a più
genomi, ma non sono stati indicati risultati sperimentali in
nessuna pubblicazione sul confronto di più di due genomi.
Risultati degli Esperimenti
Per dimostrare l'applicabilità dell’MGC sui genomi
multipli, abbiamo cercato di approssimare i gene cluster in
tre genomi di batteri: Bacillus subtilis, Buchnera aphidicola
ed Escherichia coli, con diverse combinazioni di size s e
soglia δ
Risultati degli Esperimenti
Per trovare gene clusters è necessario fissare s e
incrementare δ. Fissando s = 13 e δ = 10, troviamo 5 cluster
distinti tra cui il seguente
Conclusioni
 In
questa presentazione abbiamo introdotto il
concetto di Median Gene Cluster (MGC) per
l’individuazione di gene cluster approssimati in un
insieme di k genomi.
 Abbiamo ottenuto un’individuazione più veloce dei
gene cluster grazie a un metodo di filtraggio per
limitare lo spazio di ricerca di potenziali cluster.
Conclusioni
I risultati degli esperimenti hanno mostrato che
l’individuazione di genomi multipli è fattibile, ma in effetti
le combinazioni di k-tuple, risultanti dal passo 2, non si
presentano con una scelta di dati reali e con parametri
scelti in maniera ragionevole (s, δ).
Conclusioni
Una più ampia analisi dell’algoritmo comunque è ancora in
corso, in particolare sull’influenza del numero di sequenze
S1….Sk da analizzare e dal valore della soglia.
Conclusioni
Il metodo risulta essere più veloce quanto più δ è piccolo.
Per applicazioni pratiche si potrebbe incrementare
iterativamente δ per s fissata fino a che i cluster individuati
non siano potenzialmente significativi.
Possibili sviluppi futuri
Possibili estensione dell’algoritmo:
1. Estenderlo per individuare i median gene cluster che
occorrono solamente in un sottoinsieme di genomi di
input;
2. Effettuare un’analisi statistica dei cluster individuati per
classificarli in base alla loro rilevanza.