20121020 semi local-string_comparison_tiskin

Semi-local string comparison:
Algorithmic techniques and applications

Alexander Tiskin

Department of Computer Science
University of Warwick
http://go.warwick.ac.uk/alextiskin

Alexander Tiskin (Warwick) Semi-local string comparison 1 / 132

1 Introduction 7 Sparse string comparison

2 Matrix distance multiplication 8 Compressed string comparison

3 Semi-local string comparison 9 Beyond semi-locality

4 The seaweed method 10 Conclusions and future work

5 Periodic string comparison

6 The transposition network
method







method


Introduction

String matching: ﬁnding an exact pattern in a string
String comparison: ﬁnding similar patterns in two strings
Applications: computational biology, image recognition, . . .


Introduction

String matching: finding an exact pattern in a string
String comparison: finding similar patterns in two strings
Applications: computational biology, image recognition, . . .
Standard types of string comparison:
global: whole string vs whole string
local: substrings vs substrings
Main focus of this work:
semi-local: whole string vs substrings; prefixes vs suffixes
Closely related to approximate string matching (no relation to
approximation algorithms!)
Main tool: implicit unit-Monge matrices (a.k.a. seaweed matrices)


Introduction
Terminology and notation

x− = x − 1
2 x+ = x + 1
2
Integers: {. . . − 2, −1, 0, 1, 2, . . .}
Half-integers: . . . − 3 , − 1 , 1 , 2 , 2 , . . . = . . . (−2)+ , (−1)+ , 0+ , 1+ , 2+
2 2 2
3 5

(i, j) (i , j ) iﬀ i < i and j < j (i, j) (i , j ) iﬀ i > i and j < j
A permutation matrix is a 0/1 matrix with exactly one nonzero per row
and per column
 
0 1 0
1 0 0
0 0 1


Introduction

Given matrix D, its distribution matrix is made up of -dominance sums:


Introduction

Given matrix E , its density matrix is made up of quadrangle diﬀerences:
E (ˆ, ) = E (ˆ− , + ) − E (ˆ− , − ) − E (ˆ+ , + ) + E (ˆ+ , − )
ı ˆ ı ˆ ı ˆ ı ˆ ı ˆ
where D Σ , E over integers; D, E over half-integers


Introduction

E (ˆ, ) = E (ˆ− , + ) − E (ˆ− , − ) − E (ˆ+ , + ) + E (ˆ+ , − )
   
 Σ 0 1 2 3 0 1 2 3  
0 1 0 0 1 1 2 0 1 1 2 0 1 0
1 0 0 = 
0 0 0 1 = 1 0 0
    
0 0 0 1
0 0 1 0 0 1
0 0 0 0 0 0 0 0


Introduction

E (ˆ, ) = E (ˆ− , + ) − E (ˆ− , − ) − E (ˆ+ , + ) + E (ˆ+ , − )
   
 Σ 0 1 2 3 0 1 2 3  
0 1 0 0 1 1 2 0 1 1 2 0 1 0
1 0 0 = 
0 0 0 1 = 1 0 0
    
0 0 0 1
0 0 1 0 0 1
0 0 0 0 0 0 0 0
(D Σ ) = D for all D
Matrix E is simple, if (E )Σ = E ; equivalently, if it has all zeros in the left
column and bottom row


Introduction

Matrix E is Monge, if E is nonnegative
Intuition: boundary-to-boundary distances in a (weighted) planar graph
Matrix E is unit-Monge, if E is a permutation matrix
Intuition: boundary-to-boundary distances in a grid-like graph


Introduction

Matrix E is Monge, if E is nonnegative
Intuition: boundary-to-boundary distances in a (weighted) planar graph
Matrix E is unit-Monge, if E is a permutation matrix
Intuition: boundary-to-boundary distances in a grid-like graph
Simple unit-Monge matrix: P Σ , where P is a permutation matrix
Seaweed matrix: P used as an implicit representation of P Σ
 
 Σ 0 1 2 3
0 1 0 0
1 0 0 =  1 1 2 
0 0 0 1
0 0 1
0 0 0 0


Introduction
Implicit unit-Monge matrices

Eﬃcient P Σ queries: range tree on nonzeros of P [Bentley: 1980]
binary search tree by i-coordinate
under every node, binary search tree by j-coordinate
• • •
• −→ • −→ •
• • •
• • •
↓
• • •
• −→ • −→ •
• • •
• • •
↓
• • •
• −→ • −→ •
• • •
• • •


Introduction

Eﬃcient P Σ queries: (contd.)
Every node of the range tree represents a canonical range (rectangular
region), and stores its nonzero count
Overall, ≤ n log n canonical ranges are non-empty
A P Σ query is equivalent to -dominance counting: how many nonzeros
are -dominated by query point?
Answer: sum up nonzero counts in ≤ log2 n disjoint canonical ranges
Total size O(n log n), query time O(log2 n)


Introduction

Eﬃcient P Σ queries: (contd.)
Every node of the range tree represents a canonical range (rectangular
region), and stores its nonzero count
Overall, ≤ n log n canonical ranges are non-empty
A P Σ query is equivalent to -dominance counting: how many nonzeros
are -dominated by query point?
Answer: sum up nonzero counts in ≤ log2 n disjoint canonical ranges
Total size O(n log n), query time O(log2 n)
There are asymptotically more eﬃcient (but less practical) data structures
log n
Total size O(n), query time O log log n [J´J´+: 2004]
a a
[Chan, Pˇtra¸cu: 2010]
a s







method


Matrix distance multiplication
Seaweed braids

Distance algebra (a.k.a (min, +) or tropical algebra):
addition ⊕ given by min
multiplication given by +
Matrix -multiplication
A B=C C (i, k) = j A(i, j) B(j, k) = minj A(i, j) + B(j, k)
Matrix classes closed under -multiplication (for given n):
general numerical (integer, real) matrices
Monge matrices
simple unit-Monge matrices (!)


Seaweed braids

Recall that simple unit-Monge matrices are represented implicitly by
permutation (seaweed) matrices
Deﬁne PA Σ
PB = PC as PA Σ Σ
PB = PC
The seaweed monoid Tn :
simple unit-Monge matrices under
equivalently, permutation (seaweed) matrices under
Also known as the 0-Hecke monoid of the symmetric group H0 (Sn )


Seaweed braids

PA PB = PC can be seen as combing of seaweed braids

• • •
• • •
• • •
• • •
• • •
• • •
PA PB PC


Seaweed braids


• • •
• • •
• • •
• • •
• • •
• • •
PA PB PC

PA

PB


Seaweed braids


• • •
• • •
• • •
• • •
• • •
• • •
PA PB PC

PA

PC

PB


Seaweed braids

The seaweed monoid Tn :

n! elements (permutations of size n)
n − 1 generators g1 , g2 , . . . , gn−1 (elementary crossings)

Idempotence:
gi2 = gi for all i =

Far commutativity:
gi gj = gj gi j − i > 1 ··· = ···

Braid relations:
gi gj gi = gj gi gj j − i = 1 =


Seaweed braids

Identity: 1 x =x
 
• · · ·
· • · ·
· · • · =
1= 

· · · •

Zero: 0 x =0
 
· · · •
· · • ·
0=
· • · · =


• · · ·


Seaweed braids

Related structures:
positive braids: far comm; braid relations
braids: gi gi−1 = 1; far comm; braid relations
Coxeter’s presentation of Sn : gi2 = 1; far comm; braid relations
locally free idempotent monoid: idem; far comm [Vershik+: 2000]
Generalisations:
general 0-Hecke monoids [Fomin, Greene: 1998; Buch+: 2008]
Coxeter monoids [Tsaranov: 1990; Richardson, Springer: 1990]
J -trivial monoids [Denton+: 2011]


Seaweed braids

Computation in the seaweed monoid: a conﬂuent rewriting system can be
obtained by software (Semigroupe, GAP)


Seaweed braids

T3 : 1, a = g1 , b = g2 ; ab, ba, aba = 0

aa → a bb → b bab → 0 aba → 0


Seaweed braids

T3 : 1, a = g1 , b = g2 ; ab, ba, aba = 0


T4 : 1, a = g1 , b = g2 , c = g3 ; ab, ac, ba, bc, cb, aba, abc, acb, bac,
bcb, cba, abac, abcb, acba, bacb, bcba, abacb, abcba, bacba, abacba = 0

aa → a ca → ac bab → aba cbac → bcba
bb → b cc → c cbc → bcb abacba → 0


Seaweed braids

T3 : 1, a = g1 , b = g2 ; ab, ba, aba = 0


T4 : 1, a = g1 , b = g2 , c = g3 ; ab, ac, ba, bc, cb, aba, abc, acb, bac,
bcb, cba, abac, abcb, acba, bacb, bcba, abacb, abcba, bacba, abacba = 0

aa → a ca → ac bab → aba cbac → bcba
bb → b cc → c cbc → bcb abacba → 0

Easy to use, but not an eﬃcient algorithm


Seaweed matrix multiplication

The implicit unit-Monge matrix -multiplication problem
Given permutation matrices PA , PB , compute PC , such that
Σ Σ Σ
PA PB = PC (equivalently, PA PB = PC )



The implicit unit-Monge matrix -multiplication problem
Given permutation matrices PA , PB , compute PC , such that
Σ Σ Σ
PA PB = PC (equivalently, PA PB = PC )

Matrix -multiplication: running time
type time
general O(n3 ) standard
3 3
O n (log log n)
log2 n
[Chan: 2007]
Monge O(n2 ) via [Aggarwal+: 1987]
implicit unit-Monge O(n1.5 ) [T: 2006]
O(n log n) [T: 2010]



PB
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• •
• • •
• •
•
••
••
•
•• ?
• •
• •
PA PC



PB,lo , PB,hi
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• •
• • •
• •
•
••
•• ••
• •
• •
•
PA,lo , PA,hi



PB,lo , PB,hi
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• • ••
• • • •
• • • •
•
••
•• •• • •
• • •
• • •
• •
PA,lo , PA,hi



PB,lo , PB,hi
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• • •
• • • •
• • •
• • •
•• •
•• •• • •
• • •
• • •
•
PA,lo , PA,hi



PB,lo , PB,hi
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• • •• •
•
• • • •
• • • •
• •
•• • • •
•• •• • • • •
• • •
• • • ••
• •
PA,lo , PA,hi PC ,lo + PC ,hi



PB,lo , PB,hi
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• • •• •
• • • • • •
• • ••
• • •
•• •
•• •• • • • •
• • •
• • • ••
• •
PA,lo , PA,hi PC



PB
••
• ••
•• •
• •
• •
• •
•• • •
• •

•• • •• •
• • • • • •
• • ••
• • •
•• •
•• •• • • • •
• • •
• • • ••
• •
PA PC



Implicit unit-Monge matrix -multiplication: the algorithm
Σ Σ Σ
PC (i, k) = minj PA (i, j) + PB (j, k)
Divide-and-conquer on the range of j
Divide PA horizontally, PB vertically: two subproblems of eﬀective size n/2
Σ
PA,lo Σ Σ
PB,lo = PC ,lo Σ
PA,hi Σ Σ
PB,hi = PC ,hi
Conquer:
-low nonzeros of PC ,lo and -high nonzeros of PC ,hi appear in PC
The remaining nonzeros of PC ,lo and PC ,hi are “wrong”, and need to be
corrected to obtain the remaining nonzeros of PC
Correction can be done in time O(n) using the unit-Monge property
Overall time O(n log n)


Bruhat order

Comparing permutations by the “degree of sortedness”
Bruhat order
Permutation A is lower (“more sorted”) than permutation B in the Bruhat
order (A B), if B can be transformed to A by successive pairwise sorting
between arbitrary pairs of elements.

Permutation matrices: PA PB , if PB can be transformed to PA by
successive submatrix substitution: ( 0 1 )
10 (1 0)
01


Bruhat order

Bruhat comparability: running time
O(n2 ) folklore
O(n log n) [T: NEW]

PA PB iﬀ PA ≤ PB elementwise, time O(n2 )
Σ Σ folklore
R R
PA PB iﬀ PA PB = Id , time O(n log n) [T: NEW]
where P R denotes clockwise rotation of matrix P







method


Semi-local string comparison
Semi-local LCS and edit distance

Consider strings (= sequences) over an alphabet of size σ
Distinguish contiguous substrings and not necessarily contiguous
subsequences
Special cases of substring: preﬁx, suﬃx
Notation: strings a, b of length m, n respectively
Assume where necessary: m ≤ n; m, n reasonably close



Consider strings (= sequences) over an alphabet of size σ
Distinguish contiguous substrings and not necessarily contiguous
subsequences
Special cases of substring: preﬁx, suﬃx
Notation: strings a, b of length m, n respectively
Assume where necessary: m ≤ n; m, n reasonably close
The longest common subsequence (LCS) score:
length of longest string that is a subsequence of both a and b
equivalently, alignment score, where score(match) = 1 and
score(mismatch) = 0
In biological terms, “loss-free alignment” (unlike “lossy” BLAST)



The LCS problem
Give the LCS score for a vs b



The LCS problem
Give the LCS score for a vs b

LCS: running time
O(mn) [Wagner, Fischer: 1974]
mn
O log2 n σ = O(1) [Masek, Paterson: 1980]
[Crochemore+: 2003]
mn(log log n)2
O log2 n
[Paterson, Danˇ´cık: 1994]
[Bille, Farach-Colton: 2008]

Running time varies depending on the RAM model version
We assume word-RAM with word size log n (where it matters)



LCS on the alignment graph (directed, acyclic)
B A A B C A B C A B A C A blue = 0
B red = 1
A
A
B
C
B
C
A
score(“BAABCBCA”, “BAABCABCABACA”) = len(“BAABCBCA”) = 8
LCS = highest-score path from top-left to bottom-right



LCS: dynamic programming [WF: 1974]
Sweep cells in any -compatible order
Cell update: time O(1)
Overall time O(mn)



‘Begin at the beginning,’ the King said
gravely, ‘and go on till you come to the end:
then stop.’
L. Carroll, Alice in Wonderland
(The standard approach in dynamic
programming)



Sometimes dynamic programming can be run from both ends for extra
ﬂexibility



Sometimes dynamic programming can be run from both ends for extra
ﬂexibility
Is there a better, fully ﬂexible alternative (e.g. for comparing compressed
strings, comparing strings dynamically or in parallel, etc.)?



LCS: micro-block dynamic programming [MP: 1980; BF: 2008]
Sweep cells in micro-blocks, in any -compatible order
Micro-block size:
t = O(log n) when σ = O(1)
log n
t=O log log n otherwise
Micro-block interface:
O(t) characters, each O(log σ) bits, can be reduced to O(log t) bits
O(t) small integers, each O(1) bits
Micro-block update: time O(1), by precomputing all possible interfaces
mn mn(log log n)2
Overall time O log2 n
when σ = O(1), O log2 n
otherwise



The semi-local LCS problem
Give the (implicit) matrix of O (m + n)2 LCS scores:
string-substring LCS: string a vs every substring of b
prefix-suffix LCS: every prefix of a vs every suffix of b
suffix-prefix LCS: every suffix of a vs every prefix of b
substring-string LCS: every substring of a vs string b



The semi-local LCS problem
Give the (implicit) matrix of O (m + n)2 LCS scores:
string-substring LCS: string a vs every substring of b
prefix-suffix LCS: every prefix of a vs every suffix of b
suffix-prefix LCS: every suffix of a vs every prefix of b
substring-string LCS: every substring of a vs string b

Cf.: dynamic programming gives prefix-prefix LCS



Semi-local LCS on the alignment graph
B red = 1
A
A
B
C
B
C
A
score(“BAABCBCA”, “CABCABA”) = len(“ABCBA”) = 5
String-substring LCS: all highest-score top-to-bottom paths
Semi-local LCS: all highest-score boundary-to-boundary paths


Score matrices and seaweed matrices

The score matrix H
0 1 2 3 4 5 6 6 7 8 8 8 8 8 a = “BAABCBCA”
-1 0 1 2 3 4 5 5 6 7 7 7 7 7
-2 -1 0 1 2 3 4 4 5 6 6 6 6 7
b = “BAABCABCABACA”
-3 -2 -1 0 1 2 3 3 4 5 5 6 6 7 H(i, j) = score(a, b i : j )
-4 -3 -2 -1 0 1 2 2 3 4 4 5 5 6
H(4, 11) = 5
-5 -4 -3 -2 -1 0 1 2 3 4 4 5 5 6
-6 -5 -4 -3 -2 -1 0 1 2 3 3 4 4 5 H(i, j) = j − i if i > j
-7 -6 -5 -4 -3 -2 -1 0 1 2 2 3 3 4
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 3 4
-9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0



Semi-local LCS: output representation and running time
size query time
O(n2 ) O(1) trivial
O(m1/2 n) O(log n) string-substring [Alves+: 2003]
O(n) O(n) string-substring [Alves+: 2005]
O(n log n) O(log2 n) [T: 2006]
. . . or any 2D orthogonal range counting data structure
running time
O(mn2 ) naive
O(mn) string-substring [Schmidt: 1998; Alves+: 2005]
O(mn) [T: 2006]
mn
O log0.5 n [T: 2006]
mn(log log n)2
O log2 n
[T: 2007]



The score matrix H and the seaweed matrix P
H(i, j): the number of matched characters for a vs substring b i : j
j − i − H(i, j): the number of unmatched characters
Properties of matrix j − i − H(i, j):
simple unit-Monge
therefore, = P Σ , where P = −H is a permutation matrix
P is the seaweed matrix, giving an implicit representation of H
Range tree for P: memory O(n log n), query time O(log2 n)



0 1 2 3 4 5 6 6 7 8 8 8 8 8 a = “BAABCBCA”
-1 0 1 2 3 4 5 5 6 7 7 7 7 7
• b = “BAABCABCABACA”
-2 -1 0 1 2 3 4 4 5 6 6 6 6 7
•
-3 -2 -1 0 1 2 3 3 4 5 5 6 6 7 H(i, j) = score(a, b i : j )
-4 -3 -2 -1 0 1 2 2 3 4 4 5 5 6
• H(4, 11) = 5
-5 -4 -3 -2 -1 0 1 2 3 4 4 5 5 6
-6 -5 -4 -3 -2 -1 0 1 2 3 3 4 4 5 H(i, j) = j − i if i > j
-7 -6 -5 -4 -3 -2 -1 0 1 2 2 3 3 4
•
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 3 4
•
-9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0



0 1 2 3 4 5 6 6 7 8 8 8 8 8 a = “BAABCBCA”
-1 0 1 2 3 4 5 5 6 7 7 7 7 7
-2 -1 0 1 2 3 4 4 5 6 6 6 6 7
•
-3 -2 -1 0 1 2 3 3 4 5 5 6 6 7 H(i, j) = score(a, b i : j )
-4 -3 -2 -1 0 1 2 2 3 4 4 5 5 6
• H(4, 11) = 5
-5 -4 -3 -2 -1 0 1 2 3 4 4 5 5 6
-6 -5 -4 -3 -2 -1 0 1 2 3 3 4 4 5 H(i, j) = j − i if i > j
-7 -6 -5 -4 -3 -2 -1 0 1 2 2 3 3 4
• blue: diﬀerence in H is 0
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 3 4
• red: diﬀerence in H is 1
-9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0



0 1 2 3 4 5 6 6 7 8 8 8 8 8 a = “BAABCBCA”
-1 0 1 2 3 4 5 5 6 7 7 7 7 7
-2 -1 0 1 2 3 4 4 5 6 6 6 6 7
•
-3 -2 -1 0 1 2 3 3 4 5 5 6 6 7 H(i, j) = score(a, b i : j )
-4 -3 -2 -1 0 1 2 2 3 4 4 5 5 6
• H(4, 11) = 5
-5 -4 -3 -2 -1 0 1 2 3 4 4 5 5 6
-6 -5 -4 -3 -2 -1 0 1 2 3 3 4 4 5 H(i, j) = j − i if i > j
-7 -6 -5 -4 -3 -2 -1 0 1 2 2 3 3 4
• blue: diﬀerence in H is 0
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 3 4
• red: diﬀerence in H is 1
-9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 green: P(i, j) = 1
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 H(i, j) = j − i − P Σ (i, j)
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0



a = “BAABCBCA”
•
H(4, 11) =
• 11 − 4 − P Σ (i, j) =
11 − 4 − 2 = 5

•
•



The seaweed braid in the alignment graph
B A A B C A B C A B A C A a = “BAABCBCA”
B
A b = “BAABCABCABACA”
A H(4, 11) =
B 11 − 4 − P Σ (i, j) =
C 11 − 4 − 2 = 5
B
C
A
P(i, j) = 1 corresponds to seaweed top i bottom j



The seaweed braid in the alignment graph
B A A B C A B C A B A C A a = “BAABCBCA”
B
A b = “BAABCABCABACA”
A H(4, 11) =
B 11 − 4 − P Σ (i, j) =
C 11 − 4 − 2 = 5
B
C
A
P(i, j) = 1 corresponds to seaweed top i bottom j
Also deﬁne top right, left right, left bottom seaweeds
Gives bijection between top-left and bottom-right graph boundaries



Seaweed braid: a highly symmetric object (element of the 0-Hecke monoid
of the symmetric group)
Can be built recursively by assembling subbraids from separate parts
Highly ﬂexible: local alignment, compression, parallel computation. . .


Weighted alignment

The LCS problem is a special case of the weighted alignment score
problem with weighted matches (wM ), mismatches (wX ) and gaps (wG )

LCS score: wM = 1, wX = wG = 0
Levenshtein score: wM = 2, wX = 1, wG = 0


Weighted alignment



Alignment score is rational, if wM , wX , wG are rational numbers
Equivalent to LCS score on blown-up strings


Weighted alignment



Alignment score is rational, if wM , wX , wG are rational numbers
Equivalent to LCS score on blown-up strings
Edit distance: minimum cost to transform a into b by weighted character
edits (insertion, deletion, substitution)
Corresponds to weighted alignment score with wM = 0, insertion/deletion
weight −wG , substitution weight −wX


Weighted alignment

Weighted alignment graph
B red (solid) = 2
A red (dotted) = 1
A
B
C
B
C
A
Levenshtein score(“BAABCBCA”, “CABCABA”) = 11


Weighted alignment

Alignment graph for blown-up strings
$B $A $A $B $C $A $B $C $A $B $A $C $A blue = 0
$B red = 0.5 or 1
$A
$A
$B
$C
$B
$C
$A
Levenshtein score(“BAABCBCA”, “CABCABA”) = 2 · 5.5


Weighted alignment

Rational-weighted semi-local alignment reduced to semi-local LCS
$B $A $A $B $C $A $B $C $A $B $A $C $A
$B
$A
$A
$B
$C
$B
$C
$A

Let wM = 1, wX = µ , wG = 0
ν
Increase × ν 2 in complexity (can be reduced to ν)







method


The seaweed method
Seaweed combing

B A A B C A B C A B A C A
B
A
A
B
C
B
C
A


The seaweed method
Seaweed combing

B
A
A
B
C
B
C
A


The seaweed method
Seaweed combing

Semi-local LCS: seaweed combing [T: 2006]
Initialise seaweed braid: crossings in all mismatch cells
Sweep cells in any -compatible order
Match cell: two seaweeds uncrossed; skip
Mismatch cell: two seaweeds cross
if the same seaweeds crossed before, uncross them
otherwise skip, keep seaweeds crossed
Overall time O(mn)


The seaweed method
Micro-block seaweed combing

B
A
A
B
C
B
C
A


The seaweed method

B
A
A
B
C
B
C
A


The seaweed method

Semi-local LCS: micro-block seaweed combing [T: 2007]
Sweep cells in micro-blocks, in any -compatible order
log n
Micro-block size: t = O log log n
Micro-block interface:
O(t) characters, each O(log σ) bits, can be reduced to O(log t) bits
O(t) integers, each O(log n) bits, can be reduced to O(log t) bits
Micro-block update: time O(1), by precomputing all possible interfaces
mn(log log n)2
Overall time O log2 n


The seaweed method
Cyclic LCS

The cyclic LCS problem
Give the maximum LCS score for a vs all cyclic rotations of b


The seaweed method
Cyclic LCS

The cyclic LCS problem
Give the maximum LCS score for a vs all cyclic rotations of b

Cyclic LCS: running time
mn 2
O log n naive
O(mn log m) [Maes: 1990]
O(mn) [Bunke, B¨hler: 1993; Landau+: 1998; Schmidt: 1998]
u
2
O mn(log 2log n)
log n
[T: 2007]


The seaweed method
Cyclic LCS

Cyclic LCS: the algorithm
mn(log log n)2
Micro-block seaweed combing on a vs bb, time O log2 n
Make n string-substring LCS queries, time negligible


The seaweed method
Longest repeating subsequence

The longest repeating subsequence problem
Find the longest subsequence of a that is a square (a repetition of two
identical strings)


The seaweed method

The longest repeating subsequence problem
Find the longest subsequence of a that is a square (a repetition of two
identical strings)

Longest repeating subsequence: running time
O(m3 ) naive
O(m2 ) [Kosowski: 2004]
2 log 2
O m (log 2 m m)
log
[T: 2007]


The seaweed method

Longest repeating subsequence: the algorithm
m2 (log log m)2
Micro-block seaweed combing on a vs a, time O log2 m
Make m − 1 suﬃx-preﬁx LCS queries, time negligible


The seaweed method
Approximate matching

The approximate pattern matching problem
Give the substring closest to a by alignment score, starting at each
position in b

Assume rational alignment score
Approximate pattern matching: running time
O(mn) [Sellers: 1980]
mn
O log n σ = O(1) via [Masek, Paterson: 1980]
mn(log log n)2
O log2 n
via [Bille, Farach-Colton: 2008]


The seaweed method
Approximate matching

Approximate pattern matching: the algorithm
Micro-block seaweed combing on a vs b (with blow-up), time
2
O mn(log 2log n)
log n
The implicit semi-local edit score matrix:
an anti-Monge matrix
approximate pattern matching ∼ row minima
Row minima in O(n) element queries [Aggarwal+: 1987]
Each query in time O(log2 n) using the range tree representation,
combined query time negligible
mn(log log n)2
Overall running time O log2 n
, same as [Bille, Farach-Colton: 2008]







method


Periodic string comparison
Wraparound seaweed combing

The periodic string-substring LCS problem
Give (implicit) LCS scores for a vs each substring of b = . . . uuu . . . = u ±∞

Let u be of length p
May assume that every character of a occurs in u
Only substrings of b of length at most mp (otherwise LCS score is m)



B
A
A
B
C
B
C
A



Periodic string-substring LCS: Wraparound seaweed combing
Sweep cells row-by-row: each row starts at match cell, wraps at boundary
Match cell: two seaweeds uncrossed; skip
Mismatch cell: two seaweeds cross
if the same seaweeds crossed before (with wrapping), uncross them
otherwise skip, keep seaweeds crossed
Overall time O(mn)
String-substring LCS score: count seaweeds with multiplicities



The tandem LCS problem
Give LCS score for a vs b = u k

We have n = kp; may assume k ≤ m
Tandem LCS: running time
O(mkp) naive
O m(k + p) [Landau, Ziv-Ukelson: 2001]
O(mp) [T: 2009]

Direct application of wraparound seaweed combing



The tandem alignment problem
Give the substring closest to a by alignment score among certain
substrings of b = u ±∞ :
global: substrings u k of length kp across all k
cyclic: substrings of length kp across all k
local: substrings of any length

Tandem alignment: running time
O(m2 p) all naive
O(mp) global [Myers, Miller: 1989]
O(mp log p) cyclic [Benson: 2005]
O(mp) cyclic [T: 2009]
O(mp) local [Myers, Miller: 1989]



Cyclic tandem alignment: the algorithm
Periodic seaweed combing for a vs b (with blow-up), time O(mp)
For each k ∈ [1 : m]:
solve tandem LCS (under given alignment score) for a vs u k
obtain scores for a vs p successive substrings of b of length kp by LCS
batch query: time O(1) per substring
Running time O(mp)







method


The transposition network method
Transposition networks

Comparison network: a circuit of comparators
A comparator sorts two inputs and outputs them in prescribed order
Comparison networks traditionally used for non-branching merging/sorting

Classical comparison networks
# comparators
merging O(n log n) [Batcher: 1968]
sorting O(n log2 n) [Batcher: 1968]
O(n log n) [Ajtai+: 1983]



Comparison network: a circuit of comparators
A comparator sorts two inputs and outputs them in prescribed order
Comparison networks traditionally used for non-branching merging/sorting

Classical comparison networks
# comparators
merging O(n log n) [Batcher: 1968]
sorting O(n log2 n) [Batcher: 1968]
O(n log n) [Ajtai+: 1983]

Comparison networks are visualised by wire diagrams
Transposition network: all comparisons are between adjacent wires



Seaweed combing as a transposition network
−7
−5
−3
−1
A B C A +1
A +3
+5
C +7

B −7
C −1
+3
−3
−5
+7
+5
+1

Character mismatches correspond to comparators
Inputs anti-sorted (sorted in reverse); each value traces a seaweed



Global LCS: transposition network with binary input
0
0
0
0
A B C A 1
A 1
1
C 1

B 0
0
C 1
0
0
1
1
1

Inputs still anti-sorted, but may not be distinct
Comparison between equal values is indeterminate


Parameterised string comparison

String comparison sensitive e.g. to
low similarity: small λ = LCS(a, b)
high similarity: small κ = dist LCS (a, b) = m + n − 2λ
Can also use weighted alignment score or edit distance

Assume m = n, therefore κ = 2(n − λ)



Low-similarity comparison: small λ
sparse set of matches, may need to look at them all
preprocess matches for fast searching, time O(n log σ)
High-similarity comparison: small κ
set of matches may be dense, but only need to look at small subset
no need to preprocess, linear search is OK
Flexible comparison: sensitive to both high and low similarity, e.g. by both
comparison types running alongside each other



Parameterised string comparison: running time
Low-similarity, after preprocessing in O(n log σ)
O(nλ) [Hirschberg: 1977]
[Apostolico, Guerra: 1985]
[Apostolico+: 1992]
High-similarity, no preprocessing
O(n · κ) [Ukkonen: 1985]
[Myers: 1986]
Flexible
O(λ · κ · log n) no preproc [Myers: 1986; Wu+: 1990]
O(λ · κ) after preproc [Rick: 1995]



Parameterised string comparison: the waterfall algorithm
Low-similarity: O(n · λ) High-similarity: O(n · κ)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 0
1 1 1 0
1 0 1 0
1 1 1 0
1 1 1 1
1 0 1 1
1 1 1 1
1 1 1 0

0 0 1 1 0 0 1 0 1 1 1 0 1 1 0 0

Trace 0s through network in contiguous blocks and gaps


Dynamic string comparison

The dynamic LCS problem
Maintain current LCS score under updates to one or both input strings

Both input strings are streams, updated on-line:
appending characters at left or right
deleting characters at left or right
Assume for simplicity m ≈ n, i.e. m = Θ(n)
Goal: linear time per update
O(n) per update of a (n = |b|)
O(m) per update of b (m = |a|)


Dynamic string comparison

Dynamic LCS in linear time: update models
left right
– app+del standard DP [Wagner, Fischer: 1974]
app app a ﬁxed [Landau+: 1998], [Kim, Park: 2004]
app app [Ishida+: 2005]
app+del app+del [T: NEW]

Main idea:
for append only, maintain seaweed matrix Pa,b
for append+delete, maintain partial seaweed layout by tracing a
transposition network


Bit-parallel string comparison

String comparison using standard instructions on words of size w

Bit-parallel string comparison: running time
O(mn/w ) [Allison, Dix: 1986; Myers: 1999; Crochemore+: 2001]



Bit-parallel string comparison: binary transposition network
In every cell: input bits s, c; output bits s , c ; match/mismatch ﬂag µ
c s 0 1 0 1 0 1 0 1
µ ¬ c 0 0 1 1 0 0 1 1
µ 0 0 0 0 1 1 1 1
s s s 0 1 1 1 0 0 1 1
c 0 0 0 1 0 1 0 1

c
c s 0 1 0 1 0 1 0 1
µ
∧ c 0 0 1 1 0 0 1 1
µ 0 0 0 0 1 1 1 1
s + s s 0 1 1 0 0 0 1 1
c 0 0 0 1 0 1 0 1

c



Bit-parallel string comparison: binary transposition network
In every cell: input bits s, c; output bits s , c ; match/mismatch ﬂag µ
c s 0 1 0 1 0 1 0 1
µ ¬ c 0 0 1 1 0 0 1 1
µ 0 0 0 0 1 1 1 1
s s s 0 1 1 1 0 0 1 1
c 0 0 0 1 0 1 0 1

c
c s 0 1 0 1 0 1 0 1
µ
∧ c 0 0 1 1 0 0 1 1
µ 0 0 0 0 1 1 1 1
s + s s 0 1 1 0 0 0 1 1
c 0 0 0 1 0 1 0 1

c

2c + s ← (s + (s ∧ µ) + c) ∨ (s ∧ ¬µ)
S ← (S + (S ∧ M)) ∨ (S ∧ ¬M), where S, M are words of bits s, µ






method


Sparse string comparison
Semi-local LCS between permutations

The LCS problem on permutation strings
Give LCS score for a vs b
In each of a, b all characters distinct: total m = n matches
Equivalent to
longest increasing subsequence (LIS) in a string
maximum clique in a permutation graph
maximum planar matching in an embedded bipartite graph

LCS on permutation strings: running time
O(n log n) implicit in [Erd¨s, Szekeres:
o 1935]
[Robinson: 1938; Knuth: 1970; Dijkstra: 1980]
O(n log log n) unit-RAM [Chang, Wang: 1992]
[Bespamyatnikh, Segal: 2000]



The semi-local LCS problem on permutation strings
Give semi-local LCS scores of a vs b
In each of a, b all characters distinct: total m = n matches
Equivalent to
longest increasing subsequence (LIS) in every substring of a string

Semi-local LCS on permutation strings: running time
O(n2 log n) naive
O(n2 ) restricted [Albert+: 2003; Chen+: 2005]
O(n1.5 log n) randomised, restricted [Albert+: 2007]
O(n1.5 ) [T: 2006]
O(n log2 n) [T: NEW]



D E H C B A F G
C
F
A
E
D
H
G
B



Semi-local LCS on permutation strings: the algorithm
Divide-and-conquer on the alignment graph
Divide graph (say) horizontally; two subproblems of eﬀective size n/2
Conquer: seaweed matrix -multiplication, time O(n log n)
Overall time O(n log2 n)


Longest piecewise monotone subsequences

A k-increasing sequence: a concatenation of k increasing sequences
A k-modal sequence: a concatenation of k alternating increasing and
decreasing sequences

The longest k-increasing (k-modal) subsequence problem
Give the longest k-increasing (k-modal) subsequence of string b

Longest k-increasing (k-modal) subsequence: running time
O(nk log n) k-modal [Demange+: 2007]
O(nk log n) via [Hunt, Szymanski: 1977]

Main idea: LCS for id k (respectively, (idid)k/2 ) vs b



Longest k-increasing subsequence: algorithm A
Sparse LCS for id k vs b: time O(nk log n)



Longest k-increasing subsequence: algorithm A
Sparse LCS for id k vs b: time O(nk log n)

Longest k-increasing subsequence: algorithm B
Compute seaweed matrix for id vs b: time O(n log2 n)
Extract three-way seaweed submatrix
Compute three-way seaweed submatrix for id k vs b by log k instances of
seaweed matrix -square/multiply: time log k · O(n log n) = O(n log2 n)
Query the LCS score for id k vs b: time negligible
Overall time O(n log2 n)

Algorithm B faster than Algorithm A for k ≥ log n


Maximum clique in a circle graph

The maximum clique problem in a circle graph
Given a circle with n chords, ﬁnd the maximum-size subset of pairwise
intersecting chords

S



The maximum clique problem in a circle graph
Given a circle with n chords, ﬁnd the maximum-size subset of pairwise
intersecting chords

S

Standard reduction to an interval model: cut the circle and lay it out on
the line; chords become intervals (here drawn as square diagonals)
Chords intersect iﬀ intervals overlap, i.e. intersect without containment


Maximum clique in a circle graph: running time
exp(n) naive
O(n3 ) [Gavril: 1973]
O(n2 ) [Rotem, Urrutia: 1981; Hsu: 1985]
[Masuda+: 1990; Apostolico+: 1992]
O(n1.5 ) [T: 2006]



Maximum clique in a circle graph: the algorithm
Helly property: if any set of intervals intersect pairwise, then they all
intersect at a common point
Compute seaweed matrix, build range tree: time O(n log2 n)
Run through all 2n + 1 possible common intersection points
For each point, find a maximum subset of covering overlapping segments
by a prefix-suffix LCS query: time (2n + 1) · O(log2 n) = O(n log2 n)
Overall time O(n log2 n) + O(n log2 n) = O(n log2 n)



Parameterised maximum clique in a circle graph
The maximum clique problem in a circle graph, sensitive e.g. to
the number e of edges
the size l of maximum clique
the thickness d of interval model (the maximum number of intervals
covering a point)

We have l ≤ d ≤ n, e ≤ n2
Parameterised maximum clique in a circle graph: running time
O(n log n + e) [Apostolico+: 1992]
O(n log n + nl log(n/l)) [Apostolico+: 1992]
O(n log n + n log2 d) NEW



Parameterised maximum clique in a circle graph: the algorithm
For each diagonal block of size d, compute seaweed matrix, build range
tree: time n/d · O(d log2 d) = O(n log2 d)
Extend each diagonal block to a quadrant: time O(n log2 d)
Run through all 2n + 1 possible common intersection points
For each point, find a maximum subset of covering overlapping segments
by a prefix-suffix LCS query: time O(n log2 d)
Overall time O(n log2 d)







method


Compressed string comparison
Grammar compression

Notation: pattern p of length m; text t of length n
A GC-string (grammar-compressed string) t is a straight-line program
(context-free grammar) generating t = tn by n assignments of the form
¯ ¯
tk = α, where α is an alphabet character
tk = ti tj , where i, j < k
In general, n = O(2n )
¯

Example: Fibonacci string “ABAABABAABAAB”
t1 = ‘B’ t2 = ‘A’
t3 = t2 t1 t4 = t3 t2 t5 = t4 t3 t6 = t5 t4 t7 = t6 t5


Grammar compression

Grammar-compression covers various compression types, e.g. LZ78, LZW
(not LZ77 directly)
Simplifying assumption: arithmetic up to n runs in O(1)
This assumption can be removed by careful index remapping


Extended substring-string LCS on GC-strings

LCS: running time (r = m + n, ¯ = m + n)
r ¯ ¯
p t
plain plain O(mn) [Wagner, Fischer: 1974]
mn
O log2 m [Masek, Paterson: 1980]
[Crochemore+: 2003]
plain GC O(m3 n + . . .)
¯ gen. CFG [Myers: 1995]
O(m ¯1.5 n) ext subs-s [T: 2008]
O(m log m · n) ¯ ext subs-s [T: 2010]
GC GC NP-hard [Lifshits: 2005]
O(r 1.2¯1.4 )
r R weights [Hermelin+: 2009]
O(r log r · ¯)
r [T: 2010]
O r log(r /¯) · ¯
r r [Hermelin+: 2010]
O r log1/2 (r /¯) · ¯
r r [Gawrychowski: NEW]


Extended substring-string LCS on GC-strings

Extended substring-string LCS (plain pattern, GC text): the algorithm
For every k, compute by recursion the appropriate part of seaweed matrix
Pp,tk , using matrix -multiplication: time O(m log m · n)
¯
Overall time O(m log m · n)
¯


Subsequence recognition on GC-strings

The global subsequence recognition problem
Does pattern p appear in text t as a subsequence?

Global subsequence recognition: running time
p t
plain plain O(n) greedy
plain GC O(m¯)
n greedy



The local subsequence recognition problem
Find all minimally matching substrings of t with respect to p

Substring of t is matching, if p is a subsequence of t
Matching substring of t is minimally matching, if none of its proper
substrings are matching



Local subsequence recognition: running time ( + output)
p t
plain plain O(mn) [Mannila+: 1995]
mn
O log m [Das+: 1997]
O(c m + n) [Boasson+: 2001]
O(m + nσ) [Troniˇek: 2001]
c
plain GC O(m2 log m¯)
n [C´gielski+: 2006]
e
1.5 n)
O(m ¯ [T: 2008]
O(m log m · n)
¯ [T: NEW]



0 ˆ0+
ı ˆ1+
ı ˆ2+
ı n n

0+
ˆ 1+
ˆ  2+
ˆ

b i : j matching iﬀ box [i : j] not pierced left-to-right
-maximal seaweeds: -chain ˆ0+ , 0+
ı ˆ ˆ1+ , 1+
ı ˆ ··· ˆs − , s −
ı ˆ
b i : j minimally matching iﬀ (i, j) is in the interleaved -chain
ˆ− , +
ı1+ ˆ1− ˆ− , +
ı2+ ˆ2− ··· ˆ− + , + −
ı(s−1) ˆ(s−1)



−m

0
×
ˆ0+
ı •
•

×
ˆ1+
ı •
×
ˆ2+
ı •
•

n ×
n 0+
ˆ 1+
ˆ 2+
ˆ n m+n



Local subsequence recognition (plain pattern, GC text): the algorithm
¯



¯
Given an assignment t = t t , count by recursion
minimally matching substrings in t



¯
Given an assignment t = t t , count by recursion
Then, ﬁnd -chain of -maximal seaweeds in time n · O(m) = O(m¯)
¯ n
The interleaved -chain deﬁnes minimally matching substrings in t
overlapping both t and t
Overall time O(m log m · n) + O(m¯) = O(m log m · n)
¯ n ¯


Threshold approximate matching

The threshold approximate matching problem
Find all matching substrings of t with respect to p, according to a
threshold k

Substring of t is matching, if the edit distance for p vs t is at most k



Threshold approximate matching: running time ( + output)
p t
plain plain O(mn) [Sellers: 1980]
O(mk) [Landau, Vishkin: 1989]
4
O(m + n + nk )
m [Cole, Hariharan: 2002]
plain GC O(m¯k 2 )
n [K¨rkk¨inen+: 2003]
a a
O(m¯k + n log n)
n ¯ [LV: 1989] via [Bille+: 2010]
O(m¯ + nk 4 + n log n)
n ¯ ¯ [CH: 2002] via [Bille+: 2010]
O(m log m · n)
¯ [T: NEW]

(Also many specialised variants for LZ compression)



Threshold approx matching (plain pattern, GC text): the algorithm
Algorithm structure similar to local subsequence recognition by matrix
-multiplication and seaweed -chains
Extra ingredients:
the blow-up technique: reduction of edit distances to LCS scores
implicit matrix searching, replaces -chain interleaving
Monge row minima: “SMAWK” O(m) [Aggarwal+: 1987]
Implicit unit-Monge row minima O(m log log m) [T: NEW]
O(m) [Gawrychowski: NEW]
replaces -chain interleaving
Overall time O(m log m · n) + O(m¯) = O(m log m · n)
¯ n ¯



0 ˆ0+ ˆ1+
ı ı ˆ2+
ı ˆ3+ ˆ4+
ı ı n
˜ n
˜

0+ 1+ 2+ 3+
ˆ ˆ ˆ ˆ  4+
ˆ

Blow up: weighted alignment on strings p, t of size m, n equivalent to
LCS on strings p , ˜ of size m = νm, n = νn
˜ t ˜ ˜



−m
˜

0
× × × × × ×
ˆ0+
ı •
× × × × × ×
ˆ1+
ı •
× × × × × ×
ˆ2+
ı •
× × × × × ×
ˆ3+
ı •
× × × × × ×
ˆ4+
ı •
n
˜ × × × × × ×
n
˜ 0+ 1+ 2+ 3+
ˆ ˆ ˆ ˆ 4+
ˆ n
˜ m+˜
˜ n







method


Beyond semi-locality
Window-local LCS and alignment plots

Given window length w
The window-local LCS problem
Give semi-local LCS score for every w -substring of a vs whole b



Given window length w
The window-local LCS problem
Give semi-local LCS score for every w -substring of a vs whole b

Window-local LCS: running time
O(mn3 w ) naive
O(mnw ) multiple seaweed
O(mn) [Krusche, T: 2010]



Quasi-local LCS: the algorithm
Compute seaweed matrices for canonical substrings of a against b
Build seaweed matrices for windows of a against b recursively
Both stages use matrix -multiplication, overall time O(mn)



The window-window LCS problem
Give semi-local LCS score for every w -substring of a vs every w -substring b

Provides an alignment plot: loss-free local comparison of genome
sequences, important for studying conservation in the genome



The window-window LCS problem
Give semi-local LCS score for every w -substring of a vs every w -substring b

Provides an alignment plot: loss-free local comparison of genome
sequences, important for studying conservation in the genome
Window-window LCS: running time
O(mnw 2 ) naive
O(mnw ) multiple seaweed
O(mn) [Krusche, T: 2010]



An implementation of alignment plots [Krusche: 2010]
Based on the O(mnw ) multiple seaweed combing, using some ideas from
the optimal O(mn) algorithm
Resulting theoretical complexity O(mnw 0.5 )
Alignment weights (match 1, mismatch 0, gap −0.5): ×4 slowdown
C++, Intel assembly (x86, x86 64, MMX/SSE2 data parallelism)
SMP parallelism (currently two processors)



Krusche’s implementation used at Warwick Systems Biology Centre to
study weak conservation in plant genomes (BLAST too inaccurate)
Speedup on one processor:
×10 over heavily optimised, bit-parallel naive algorithm
×7 over biologists’ heuristics
Speedup on two processors: extra ×2, near-perfect parallelism



Publications:
[Picot+: 2010] Evolutionary Analysis of Regulatory Sequences (EARS) in
Plants. Plant Journal.
[Baxter+: accepted] Conserved Noncoding Sequences Highlight Shared
Components of Regulatory Networks in Dicotyledonous Plants. Plant Cell.
Web service: http://wsbc.warwick.ac.uk/ears
Future work: genomic repeats; genome-scale comparison


Quasi-local LCS and sparse spliced alignment

Given m (possibly overlapping) prescribed substrings in a

The quasi-local LCS problem
Give semi-local LCS score for every prescribed substring of a vs whole b



Given m (possibly overlapping) prescribed substrings in a

The quasi-local LCS problem
Give semi-local LCS score for every prescribed substring of a vs whole b

Quasi-local LCS: running time
O(m2 n) multiple seaweed
O(mn log2 m) [T: unpublished]



Window-local LCS: the algorithm
Compute seaweed matrices for canonical substrings of a against b
Build seaweed matrices for prescribed substrings of a against b recursively
Both stages use matrix -multiplication, time O(mn log2 m)



The sparse spliced alignment problem
Give the chain of non-overlapping prescribed substrings in a, closest to b
by alignment score

Describes gene assembly: unknown gene from candidate exons, given a
known similar gene



The sparse spliced alignment problem
Give the chain of non-overlapping prescribed substrings in a, closest to b
by alignment score

Describes gene assembly: unknown gene from candidate exons, given a
known similar gene
Assume m = n; let s = total size of prescribed substrings
Sparse spliced alignment: running time
O(ns) = O(n3 ) [Gelfand+: 1996]
O(n2.5 ) [Kent+: 2006]
O(n2 log2 n) [T: unpublished]
O(n2 log n) [Sakai: 2009]







method


Conclusions and future work

Implicit unit-Monge matrices:
the seaweed monoid
distance multiplication in time O(n log n)
next: lower bound?
Semi-local LCS problem:
representation by implicit unit-Monge matrices
generalisation to rational alignment scores
next: real alignment scores?
Seaweed combing and micro-block speedup:
a simple algorithm for semi-local LCS
semi-local LCS in time o(mn)
improvements on related problems


Transposition networks:
simple interpretation of high-similarity and dissimilarity LCS
dynamic LCS
simple interpretation of bit-parallel LCS
Sparse string comparison:
fast LCS on permutation strings
fast max-clique in a circle graph
next: lower bound? or even faster max-clique
Sparse string comparison:
semi-local LCS on permutations in time O(n log2 n)
maximum clique in a circle graph in time O(n log2 n)
improvements on related problems


Compressed string comparison:
three-way semi-local LCS on GC text against plain pattern
subsequence recognition in GC-strings
next: approximate matching in GC-strings
Beyond semi-locality:
quasi-local string comparison
sparse spliced alignment
next: full locality


20121020 semi local-string_comparison_tiskin

More Related Content

What's hot

Viewers also liked

Similar to 20121020 semi local-string_comparison_tiskin

More from Computer Science Club

20121020 semi local-string_comparison_tiskin