| Levenshtein distance | |
| Class: | measuring the difference between two sequences |
In information theory, linguistics, and computer science, the Levenshtein distance is a string metric for measuring the difference between two sequences. The Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other. It is named after Soviet mathematician Vladimir Levenshtein, who defined the metric in 1965.[1]
Levenshtein distance may also be referred to as edit distance, although that term may also denote a larger family of distance metrics known collectively as edit distance.[2] It is closely related to pairwise string alignments.
The Levenshtein distance between two strings
a,b
|a|
|b|
\operatorname{lev}(a,b)
\operatorname{lev}(a,b)=\begin{cases} |a|&if|b|=0,\\ |b|&if|a|=0,\\ \operatorname{lev}(\operatorname{tail}(a),\operatorname{tail}(b))&if\operatorname{head}(a)=\operatorname{head}(b),\\ 1+min\begin{cases} \operatorname{lev}(\operatorname{tail}(a),b)\\ \operatorname{lev}(a,\operatorname{tail}(b))\\ \operatorname{lev}(\operatorname{tail}(a),\operatorname{tail}(b))\\ \end{cases}&otherwise \end{cases}
\operatorname{tail}
x
x
\operatorname{tail}(x0x1...xn)=x1x2...xn
\operatorname{head}(x)
x
\operatorname{head}(x0x1...xn)=x0
x[n]
xn
n
x
\operatorname{head}(x)=x0=x[0]
The first element in the minimum corresponds to deletion (from
a
b
This definition corresponds directly to the naive recursive implementation.
For example, the Levenshtein distance between "kitten" and "sitting" is 3, since the following 3 edits change one into the other, and there is no way to do it with fewer than 3 edits:
A simple example of a deletion can be seen with "uninformed" and "uniformed" which have a distance of 1:
The Levenshtein distance has several simple upper and lower bounds. These include:
An example where the Levenshtein distance between two strings of the same length is strictly less than the Hamming distance is given by the pair "flaw" and "lawn". Here the Levenshtein distance equals 2 (delete "f" from the front; insert "n" at the end). The Hamming distance is 4.
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.
In linguistics, the Levenshtein distance is used as a metric to quantify the linguistic distance, or how different two languages are from one another.[3] It is related to mutual intelligibility: the higher the linguistic distance, the lower the mutual intelligibility, and the lower the linguistic distance, the higher the mutual intelligibility.
See main article: Edit distance. 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 parameterizable 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.
This is a straightforward, but inefficient, recursive Haskell implementation of a lDistance function that takes two strings, s and t, together with their lengths, and returns the Levenshtein distance between them:
This implementation is very inefficient because it recomputes the Levenshtein distance of the same substrings many times.
A more efficient method would never repeat the same distance calculation. For example, the Levenshtein distance of all possible suffixes might be stored in an array
M
M[i][j]
i
s and the last j
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 in the table in the last row and column, representing the distance between all of the characters in s and all the characters in t.See main article: Wagner–Fischer algorithm.
This section uses 1-based strings rather than 0-based strings. If m is a matrix,
m[i,j]
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.
This is a straightforward pseudocode implementation for a function LevenshteinDistance that takes two strings, s of length m, and t of length n, and returns the Levenshtein distance between them:
d[i, j] := minimum(d[i-1, j] + 1, // deletion d[i, j-1] + 1, // insertion d[i-1, j-1] + substitutionCost) // substitution return d[m, n]
Two examples of the resulting matrix (hovering over a tagged number reveals the operation performed to get that number):
| k | i | t | t | e | n | |||
|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | ||
| s | 1 | 2 | 3 | 4 | 5 | 6 | ||
| i | 2 | 2 | 2 | 3 | 4 | 5 | ||
| t | 3 | 3 | 2 | 2 | 3 | 4 | ||
| t | 4 | 4 | 3 | 2 | 2 | 3 | ||
| i | 5 | 5 | 4 | 3 | 2 | 3 | ||
| n | 6 | 6 | 5 | 4 | 3 | 3 | ||
| g | 7 | 7 | 6 | 5 | 4 | 4 |
| S | a | t | u | r | d | a | y | |||
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | ||
| S | 1 | 3 | 4 | 5 | 6 | 7 | ||||
| u | 2 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | ||
| n | 3 | 2 | 2 | 2 | 3 | 4 | 5 | 6 | ||
| d | 4 | 3 | 3 | 3 | 3 | 4 | 4 | 5 | ||
| a | 5 | 4 | 3 | 4 | 4 | 4 | 4 | 4 | ||
| y | 6 | 5 | 4 | 4 | 5 | 5 | 5 | 4 |
The invariant maintained throughout the algorithm is that we can transform the initial segment into using a minimum of operations. At the end, the bottom-right element of the array contains the answer.
It turns out that only two rows of the table the previous row and the current row being calculated are needed for the construction, if one does not want to reconstruct the edited input strings.
The Levenshtein distance may be calculated iteratively using the following algorithm:[4]
// initialize v0 (the previous row of distances) // this row is A[0][i]: edit distance from an empty s to t; // that distance is the number of characters to append to s to make t. for i from 0 to n: v0[i] = i
for i from 0 to m - 1: // 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 j from 0 to n - 1: // calculating costs for A[i + 1][j + 1] deletionCost := v0[j + 1] + 1 insertionCost := v1[j] + 1 if s[i] = t[j]: substitutionCost := v0[j] else: substitutionCost := v0[j] + 1
v1[j + 1] := minimum(deletionCost, insertionCost, substitutionCost)
// copy v1 (current row) to v0 (previous row) for next iteration // since data in v1 is always invalidated, a swap without copy could be more efficient swap v0 with v1 // after the last swap, the results of v1 are now in v0 return v0[n]
Hirschberg's algorithm combines this method with divide and conquer. It can compute the optimal edit sequence, and not just the edit distance, in the same asymptotic time and space bounds.[5]
Levenshtein automata efficiently determine whether a string has an edit distance lower than a given constant from a given string.[6]
The Levenshtein distance between two strings of length can be approximated to within a factor
(logn)O(1/\varepsilon),
where is a free parameter to be tuned, in time .[7]
It has been shown that the Levenshtein distance of two strings of length cannot be computed in time for any ε greater than zero unless the strong exponential time hypothesis is false.[8]