Levenshtein distance

From Wikipedia, the free encyclopedia - View original article

 
Jump to: navigation, search

In information theory and computer science, the Levenshtein distance is a string metric for measuring the difference between two sequences. Informally, the Levenshtein distance between two words is the minimum number of single-character edits (insertion, deletion, substitution) required to change one word into the other. The phrase edit distance is often used to refer specifically to Levenshtein distance. It is named after Vladimir Levenshtein, who considered this distance in 1965.[1] It is closely related to pairwise string alignments.

Definition[edit]

Mathematically, the Levenshtein distance between two strings a, b is given by \operatorname{lev}_{a,b}(|a|,|b|) where

\qquad\operatorname{lev}_{a,b}(i,j) = \begin{cases}   \max(i,j) & \text{ if} \min(i,j)=0, \\   \min \begin{cases}           \operatorname{lev}_{a,b}(i-1,j) + 1 \\           \operatorname{lev}_{a,b}(i,j-1) + 1 \\           \operatorname{lev}_{a,b}(i-1,j-1) + 1_{(a_i \neq b_j)}        \end{cases} & \text{ otherwise.} \end{cases}

where 1_{(a_i \neq b_j)} is the indicator function equal to 0 when a_i = b_j and 1 otherwise.

Note that the first element in the minimum corresponds to deletion (from a to b), the second to insertion and the third to match or mismatch, depending on whether the respective symbols are the same.

Example[edit]

For example, the Levenshtein distance between "kitten" and "sitting" is 3, since the following three edits change one into the other, and there is no way to do it with fewer than three edits:

  1. kitten → sitten (substitution of "s" for "k")
  2. sitten → sittin (substitution of "i" for "e")
  3. sittin → sitting (insertion of "g" at the end).

Upper and lower bounds[edit]

The Levenshtein distance has several simple upper and lower bounds. These include:

Applications[edit]

In approximate string matching, the objective is to find matches for short strings in many longer texts, in situations where a small number of differences is to be expected. The short strings could come from a dictionary, for instance. Here, one of the strings is typically short, while the other is arbitrarily long. This has a wide range of applications, for instance, spell checkers, correction systems for optical character recognition, and software to assist natural language translation based on translation memory.

The Levenshtein distance can also be computed between two longer strings, but the cost to compute it, which is roughly proportional to the product of the two string lengths, makes this impractical. Thus, when used to aid in fuzzy string searching in applications such as record linkage, the compared strings are usually short to help improve speed of comparisons.

Relationship with other edit distance metrics[edit]

There are other popular measures of edit distance, which are calculated using a different set of allowable edit operations. For instance,

Edit distance is usually defined as a parametrizable metric calculated with a specific set of allowed edit operations, and each operation is assigned a cost (possibly infinite). This is further generalized by DNA sequence alignment algorithms such as the Smith–Waterman algorithm, which make an operation's cost depend on where it is applied.

Computing Levenshtein distance[edit]

Recursive[edit]

A straightforward recursive implementation LevenshteinDistance function takes two strings, s and t, and returns the Levenshtein distance between them:

 // len_s and len_t are the number of characters in string s and t respectively int LevenshteinDistance(string s, int len_s, string t, int len_t) {   /* test for degenerate cases of empty strings */   if (len_s == 0) return len_t;   if (len_t == 0) return len_s;     /* test if last characters of the strings match */   if (s[len_s-1] == t[len_t-1]) cost = 0;   else                          cost = 1;     /* return minimum of delete char from s, delete char from t, and delete char from both */   return minimum(LevenshteinDistance(s, len_s - 1, t, len_t    ) + 1,                  LevenshteinDistance(s, len_s    , t, len_t - 1) + 1,                  LevenshteinDistance(s, len_s - 1, t, len_t - 1) + cost); } 

Unfortunately, the straightforward recursive implementation is very inefficient because it recomputes the Levenshtein distance of the same substrings many times. A better method would never repeat the same distance calculation. For example, the Levenshtein distance of all possible prefixes might be stored in an array d[][] where d[i][j] is the distance between the first i characters of string s and the first j characters of string t. The table is easy to construct one row at a time starting with row 0. When the entire table has been built, the desired distance is d[len_s][len_t]. While this technique is significantly faster, it will consume len_s * len_t more memory than the straightforward recursive implementation.

Iterative with full matrix[edit]

Note: This section uses 1-based strings instead of 0-based strings

Computing the Levenshtein distance is based on the observation that if we reserve a matrix to hold the Levenshtein distances between all prefixes of the first string and all prefixes of the second, then we can compute the values in the matrix in a dynamic programming fashion, and thus find the distance between the two full strings as the last value computed.

This algorithm, an example of bottom-up dynamic programming, is discussed, with variants, in the 1974 article The String-to-string correction problem by Robert A. Wagner and Michael J. Fischer.[2]

A straightforward implementation, as pseudocode for a function LevenshteinDistance that takes two strings, s of length m, and t of length n, and returns the Levenshtein distance between them:

 int LevenshteinDistance(char s[1..m], char t[1..n]) {   // for all i and j, d[i,j] will hold the Levenshtein distance between   // the first i characters of s and the first j characters of t;   // note that d has (m+1)*(n+1) values   declare int d[0..m, 0..n]     clear all elements in d // set each element to zero     // source prefixes can be transformed into empty string by   // dropping all characters   for i from 1 to m     {       d[i, 0] := i     }     // target prefixes can be reached from empty source prefix   // by inserting every characters   for j from 1 to n     {       d[0, j] := j     }     for j from 1 to n     {       for i from 1 to m         {           if s[i] = t[j] then             d[i, j] := d[i-1, j-1]       // no operation required           else             d[i, j] := minimum                     (                       d[i-1, j] + 1,  // a deletion                       d[i, j-1] + 1,  // an insertion                       d[i-1, j-1] + 1 // a substitution                     )         }     }     return d[m, n] } 

Note that this implementation does not fit the definition precisely: it always prefers matches, even if insertions or deletions provided a better score. This is equivalent; it can be shown that for every optimal alignment (which induces the Levenshtein distance) there is another optimal alignment that prefers matches in the sense of this implementation.[3]

Two examples of the resulting matrix (hovering over a number reveals the operation performed to get that number):

kitten
0123456
s1123456
i2212345
t3321234
t4432123
i5543223
n6654332
g7765443
Saturday
012345678
S101234567
u211223456
n322233456
d433334345
a543444434
y654455543

The invariant maintained throughout the algorithm is that we can transform the initial segment s[1..i] into t[1..j] using a minimum of d[i,j] operations. At the end, the bottom-right element of the array contains the answer.

Proof of correctness[edit]

As mentioned earlier, the invariant is that we can transform the initial segment s[1..i] into t[1..j] using a minimum of d[i,j] operations. This invariant holds since:

This proof fails to validate that the number placed in d[i,j] is in fact minimal; this is more difficult to show, and involves an argument by contradiction in which we assume d[i,j] is smaller than the minimum of the three, and use this to show one of the three is not minimal.

Possible modifications[edit]

Possible modifications to this algorithm include:

Iterative with two matrix rows[edit]

It turns out that only two rows of the table are needed for the construction: the previous row and the current row (the one being calculated).

The Levenshtein distance may be calculated iteratively using the following algorithm:[8]

 int LevenshteinDistance(string s, string t) {     // degenerate cases     if (s == t) return 0;     if (s.Length == 0) return t.Length;     if (t.Length == 0) return s.Length;       // create two work vectors of integer distances     int[] v0 = new int[t.Length + 1];     int[] v1 = new int[t.Length + 1];       // initialize v0 (the previous row of distances)     // this row is A[0][i]: edit distance for an empty s     // the distance is just the number of characters to delete from t     for (int i = 0; i <= v0.Length; i++)         v0[i] = i;       for (int i = 0; i < s.Length; i++)     {         // calculate v1 (current row distances) from the previous row v0           // first element of v1 is A[i+1][0]         //   edit distance is delete (i+1) chars from s to match empty t         v1[0] = i + 1;           // use formula to fill in the rest of the row         for (int j = 0; j < t.Length; j++)         {             var cost = (s[i] == t[j]) ? 0 : 1;             v1[j + 1] = Minimum(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);         }           // copy v1 (current row) to v0 (previous row) for next iteration         for (int j = 0; j < v0.Length; j++)             v0[j] = v1[j];     }       return v1[t.Length]; } 

See also[edit]

References[edit]

  1. ^ В.И. Левенштейн (1965). "Двоичные коды с исправлением выпадений, вставок и замещений символов". Доклады Академий Наук СCCP 163 (4): 845–8.  Appeared in English as: Levenshtein VI (1966). "Binary codes capable of correcting deletions, insertions, and reversals". Soviet Physics Doklady 10: 707–10. 
  2. ^ Wagner, Robert A.; Fischer, Michael J. (1974), "The String-to-String Correction Problem", Journal of the ACM 21 (1): 168–173, doi:10.1145/321796.321811 
  3. ^ Micro-optimisation for edit distance computation: is it valid?
  4. ^ Gusfield, Dan (1997). Algorithms on strings, trees, and sequences: computer science and computational biology. Cambridge, UK: Cambridge University Press. pp. 263–264. ISBN 0-521-58519-8. 
  5. ^ Navarro, Gonzalo (March 2001). "A guided tour to approximate string matching". ACM Computing Surveys 33 (1): 31–88. doi:10.1145/375360.375365. 
  6. ^ Bruno Woltzenlogel Paleo. An approximate gazetteer for GATE based on levenshtein distance. Student Section of the European Summer School in Logic, Language and Information (ESSLLI), 2007.
  7. ^ Allison, L. (September 1992). "Lazy Dynamic-Programming can be Eager". Inf. Proc. Letters 43 (4): 207–12. doi:10.1016/0020-0190(92)90202-7. 
  8. ^ Hjelmqvist, Sten (26 Mar 2012), Fast, memory efficient Levenshtein algorithm 

External links[edit]