Distance de Levenshtein

On appelle distance de Levenshtein entre deux chaînes M et P le coût minimal pour transformer M en P en effectuant les seules opérations élémentaires (au niveau d'un caractère) suivantes (on agit exclusivement sur M et successivement sur ses transformés) :

• substitution ;
• insertion (ou ajout) ;
• suppression (ou effacement).

Formellement, on définit cette distance, avec deux chaînes ${\displaystyle a}$ et ${\displaystyle b}$, ${\displaystyle |a|}$ le cardinal de ${\displaystyle a}$ (ou son nombre de lettres), et ${\displaystyle a-1}$ la chaînes ${\displaystyle a}$ tronquée de sa 1^re lettre ${\displaystyle a[0]}$:

${\displaystyle \qquad \operatorname {lev} (a,b)={\begin{cases}\max(|a|,|b|)&{\text{ si }}\min(|a|,|b|)=0,\\\operatorname {lev} (a-1,b-1)&{\text{ si }}a[0]=b[0],\\1+\min {\begin{cases}\operatorname {lev} (a-1,b)\\\operatorname {lev} (a,b-1)\\\operatorname {lev} (a-1,b-1)\end{cases}}&{\text{ sinon.}}\end{cases}}}$

On associe à chacune de ces opérations un coût. Généralement, le coût est égal à 1 pour les trois opérations. La distance est la somme des coûts des opérations effectuées. On peut montrer que définir une distance au sens mathématique du terme entre les caractères d'un alphabet, entraine que la distance de Levenshtein soit aussi une distance au sens mathématique du terme, sur l'ensemble des chaines construites sur l'alphabet.

Si M = « examen » et P = « examen », alors ${\displaystyle \operatorname {lev} (M,P)=0}$, parce qu'aucune opération n'a été réalisée.

Si M = « examen » et P = « examan », alors ${\displaystyle \operatorname {lev} (M,P)=1}$, parce qu’il y a eu une substitution (changement du e en a), et que l'on ne peut pas en faire moins.

L’algorithme ci-dessous, dû à Wagner et Fischer (1974), permet de calculer la distance de Levenshtein entre deux chaînes de caractères courtes. Cet algorithme est un exemple de programmation dynamique (solution de type du bas en haut), qui utilise une matrice de dimension ${\displaystyle (n+1)\times (m+1)}$ où n et m sont les dimensions des deux chaînes de caractères. Dans le pseudo-code suivant, la chaîne chaine1 est de longueur longueurChaine1 et chaine2, de longueur longueurChaine2. Cet algorithme renvoie un entier positif ou nul. Par définition d'une distance au sens mathématique du terme, l'algorithme renvoie 0, si et seulement si les deux chaînes sont égales. Pour deux chaînes de longueurs données, la valeur maximale de la distance est la longueur de la chaîne la plus longue.

 entier DistanceDeLevenshtein(caractere chaine1[1..longueurChaine1],
                              caractere chaine2[1..longueurChaine2])
   // D est un tableau de longueurChaine1+1 rangées et longueurChaine2+1 colonnes
   // D est indexé à partir de 0, les chaînes à partir de 1
   déclarer entier D[0..longueurChaine1, 0..longueurChaine2]
   // i et j itèrent sur chaine1 et chaine2
   déclarer entier i, j, coûtSubstitution
 
   pour i de 0 à longueurChaine1
       ${\displaystyle D[i,0]]:=i}$
   pour j de 0 à longueurChaine2
       ${\displaystyle D[0,j]]:=j}$
 
   pour i de 1 à longueurChaine1
      pour j de 1 à longueurChaine2
          si chaine1[i] = chaine2[j] alors coûtSubstitution := 0
          sinon coûtSubstitutionn:= 1    
          ${\displaystyle D[i,j]]:=}$ minimum(
             D[i-1, j  ] + 1,                 // effacement du nouveau caractère de chaine1
             D[i,   j-1] + 1,                 // insertion dans chaine2 du nouveau caractère de chaine1
             D[i-1, j-1] + coûtSubstitution   // substitution
          )
 
   renvoyer D[longueurChaine1, longueurChaine2]

L’invariant est qu’on peut transformer le segment initial chaine1[1..i] en chaine2[1..j] en utilisant un nombre minimal de D[i, j] opérations. L’algorithme achevé, la solution est contenue dans la dernière position à droite de la rangée du bas de la matrice.

Pour comprendre le fonctionnement de cet algorithme, prenons un exemple :

Soit chaine1 = « NICHE ».
Soit chaine2 = « CHIENS ».

On veut transformer « NICHE » en « CHIENS » avec un coût minimal.

Fonctionnement

Soit n la longueur de la chaîne1 (ici 'NICHE', n=5).
Soit m la longueur de la chaîne2 (ici 'CHIENS', m=6).

Si n=0 alors retourner d=m et quitter.
Si m=0 alors retourner d=n et quitter.

Construire une matrice D de n+1 lignes et m+1 colonnes.
Initialiser la première ligne par la matrice ligne [0, 1, …, m - 1, m] et la première colonne par la matrice colonne [0, 1, ..., n - 1, n].

Matrice D

		C	H	I	E	N	S
	0	1	2	3	4	5	6
N	1	0	0	0	0	0	0
I	2	0	0	0	0	0	0
C	3	0	0	0	0	0	0
H	4	0	0	0	0	0	0
E	5	0	0	0	0	0	0

Soit Cout[i, j] = 0 si a[i] = b[j] et Cout[i, j] = 1 si a[i] != b[j]. C'est le coût de substitution.
On a donc ici la matrice Cout:

Matrice Cout

	C	H	I	E	N	S
N	1	1	1	1	0	1
I	1	1	0	1	1	1
C	0	1	1	1	1	1
H	1	0	1	1	1	1
E	1	1	1	0	1	1

On remplit ensuite la matrice D en utilisant la règle suivante  D[i, j] est égale au minimum entre les éléments suivants :

• L’élément directement au-dessus et on ajoute 1 (effacement) : D[i-1, j] + 1.
• L’élément directement avant et on ajoute 1 (insertion) : D[i, j-1] + 1.
• L’élément diagonal précédent et on ajoute le coût (substitution) : D[i-1, j-1] + Cout[i-1, j-1].

Attention ! Il s'agit de Cout[i-1, j-1] et non de Cout[i, j] car la matrice Cout est moins grande que la matrice D, ce qui entraîne un décalage.

Dans notre cas, le remplissage de la première ligne donne alors :

Matrice D

		C	H	I	E	N	S
	0	1	2	3	4	5	6
N	1	1	2	3	4	4	5
I	2	0	0	0	0	0	0
C	3	0	0	0	0	0	0
H	4	0	0	0	0	0	0
E	5	0	0	0	0	0	0

Nous réitérons cette opération jusqu'à remplir la matrice :

Matrice D

		C	H	I	E	N	S
	0	1	2	3	4	5	6
N	1	1	2	3	4	4	5
I	2	2	2	2	3	4	5
C	3	2	3	3	3	4	5
H	4	3	2	3	4	4	5
E	5	4	3	3	3	4	5

La distance de Levenshtein entre les 2 chaînes est en D[n, m], c'est-à-dire en bas à droite.

Ici, on retrouve bien les 5 opérations trouvées de manière intuitive.

La matrice D fournit aussi explicitement les suites d'opérations possibles permettant de passer d'une chaîne de caractères à l'autre (Il existe ici 6 suites possibles). On part du 5 en bas à droite et on examine les trois cases du quartier supérieur gauche ; (4,4,5) dans le sens d'une montre. On suit la ou les valeurs minimums. Ici on a deux 4 qui donnent donc deux chemins (une bifurcation), et ainsi de suite on crée un arbre par récurrence. Aller au dessus s’interprète comme détruire la lettre de la colonne; aller en diagonale est substituer la lettre de la ligne par la lettre de la colonne (ou pas si elles sont égales) ; aller à gauche est ajouter la lettre de la colonne. Bien sur à la fin, il faut lire les étapes à l'envers.

En remplaçant chaîne de caractères par séquence de symboles, les symboles étant comparables par un opérateur d'égalité, on peut définir une distance d'édition fonctionnant sur d'autres types que des chaînes de caractères.

On peut citer d'autres distances similaires : la distance de Damerau-Levenshtein, la distance de Hamming, la distance d'édition sur les arbres, la distance de Jaro-Winkler et la distance de Jaccard.