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]
O(n log2 n) [T: NEW]

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


20121020 semi local-string_comparison_tiskin

20121020 semi local-string_comparison_tiskin

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (9)

Similar to 20121020 semi local-string_comparison_tiskin

Similar to 20121020 semi local-string_comparison_tiskin (20)

More from Computer Science Club

More from Computer Science Club (20)

20121020 semi local-string_comparison_tiskin