Algorithmes et structures probabilistes

Conception d’algorithmes et applications (LI325)
Cours 10: Algorithmes et structures probabilistes
Ana Bušić
http://www.di.ens.fr/~busic/LI325.html
[email protected]
Algorithmes Probabilistes
Algorithme probabiliste est un algorithme dans lequel on utilise
l’instruction de la forme
“tirer un entier selon la loi uniforme entre 1 et n”.
Algorithmes Probabilistes
Algorithme probabiliste est un algorithme dans lequel on utilise
l’instruction de la forme
“tirer un entier selon la loi uniforme entre 1 et n”.
Deux usages principaux du aléatoire :
I
RandQuickSort : pour assurer que sur toute instance la complexité
moyenne est égale à la complexité moyenne (sous l’hypothèse
uniforme) d’un algorithme déterministe correspondant. Technique de
randomisation.
Algorithmes Probabilistes
Algorithme probabiliste est un algorithme dans lequel on utilise
l’instruction de la forme
“tirer un entier selon la loi uniforme entre 1 et n”.
Deux usages principaux du aléatoire :
I
RandQuickSort : pour assurer que sur toute instance la complexité
moyenne est égale à la complexité moyenne (sous l’hypothèse
uniforme) d’un algorithme déterministe correspondant. Technique de
randomisation.
I
RandMinCut : algorithme plus simple que l’algorithme déterministe
pour le même problème.
Algorithmes Probabilistes
Algorithme probabiliste est un algorithme dans lequel on utilise
l’instruction de la forme
“tirer un entier selon la loi uniforme entre 1 et n”.
Deux usages principaux du aléatoire :
I
RandQuickSort : pour assurer que sur toute instance la complexité
moyenne est égale à la complexité moyenne (sous l’hypothèse
uniforme) d’un algorithme déterministe correspondant. Technique de
randomisation.
I
RandMinCut : algorithme plus simple que l’algorithme déterministe
pour le même problème.
L’analyse faite est valable sur toutes les instances du problème (pas
d’hypothèse probabiliste sur les instances).
Las Vegas vs. Monte Carlo
Deux types d’algorithmes probabilistes :
I
Las Vegas : donne un résultat toujours correct.
Exemple : RandQuickSort.
La complexité est une variable aléatoire.
I
Monte Carlo : donne un résultat qui peut être incorrect.
Exemple : RandMinCut.
Il est impératif de majorer la probabilité d’erreur.
Las Vegas vs. Monte Carlo
Deux types d’algorithmes probabilistes :
I
Las Vegas : donne un résultat toujours correct.
Exemple : RandQuickSort.
La complexité est une variable aléatoire.
I
Monte Carlo : donne un résultat qui peut être incorrect.
Exemple : RandMinCut.
Il est impératif de majorer la probabilité d’erreur.
Un algorithme Monte Carlo d’erreur λ : si pour toute entrée la
probabilité qu’il retourne un résultat faux est au plus λ.
Algorithmes Monte Carlo
Dans le cas des problèmes de décision (la réponse OUI ou NON) deux
sous-classes :
I
Algorithme Monte Carlo à erreur unilatérale : pour toute instance
pour laquelle la réponse est OUI, l’algorithme répond OUI avec
probabilité 1.
I
Algorithme Monte Carlo à erreur bilatérale : pour au moins une
instance positive et au moins une instance négative la probabilité
qu’il réponde OUI est strictement comprise entre 0 et 1.
Algorithmes Monte Carlo
Dans le cas des problèmes de décision (la réponse OUI ou NON) deux
sous-classes :
I
Algorithme Monte Carlo à erreur unilatérale : pour toute instance
pour laquelle la réponse est OUI, l’algorithme répond OUI avec
probabilité 1.
I
Algorithme Monte Carlo à erreur bilatérale : pour au moins une
instance positive et au moins une instance négative la probabilité
qu’il réponde OUI est strictement comprise entre 0 et 1.
RandMinCut (avec répetition) transformé en algorithme de décision (en
ajoutant à l’entrée un entier k et en demandant de décider si toute coupe
du graphe a un poids strictement supérieur à k) est un algorithme à
l’erreur unilaterale.
Algorithmes Monte Carlo
Dans le cas des problèmes de décision (la réponse OUI ou NON) deux
sous-classes :
I
Algorithme Monte Carlo à erreur unilatérale : pour toute instance
pour laquelle la réponse est OUI, l’algorithme répond OUI avec
probabilité 1.
I
Algorithme Monte Carlo à erreur bilatérale : pour au moins une
instance positive et au moins une instance négative la probabilité
qu’il réponde OUI est strictement comprise entre 0 et 1.
RandMinCut (avec répetition) transformé en algorithme de décision (en
ajoutant à l’entrée un entier k et en demandant de décider si toute coupe
du graphe a un poids strictement supérieur à k) est un algorithme à
l’erreur unilaterale.
La probabilité d’erreur peut être rendue aussi petite que l’on veut en
changeant le nombre de répetitions.
Chiffrement RSA
RSA (Rivest, Shamir et Adleman, 1977) :
système cryptographique à clé publique dont la sécurité est fondée sur la
difficulté de la factorisation des grands entiers.
I
Soit n = pq, où p et q sont deux nombres premiers impairs distincts.
Soient a, b tels que ab ≡ 1 (mod φ(n)), où φ(n) = (p − 1)(q − 1).
Notons K = (n, p, q, a, b).
I
Chiffrement :
eK (x) = x b mod n, x ∈ Zn .
I
Dechiffrement :
dK (y ) = y a mod n, y ∈ Zn .
I
Les valeurs n et b forment la clé publique et les valeurs p, q et a la
clé privée.
Exemple
I
Supposons que Bob choisisse p = 101 et q = 113. On a n = 11413
et φ(n) = 100 × 112 = 11200.
I
Soient a = 6597 et b = 3533. Alors :
ab = 23307201 = 2081 × 11200 + 1,
donc on a bien ab ≡ 1 (mod φ(n)).
I
K = (n, p, q, a, b) = (11413, 101, 113, 6597, 3533).
Exemple
I
Supposons que Bob choisisse p = 101 et q = 113. On a n = 11413
et φ(n) = 100 × 112 = 11200.
I
Soient a = 6597 et b = 3533. Alors :
ab = 23307201 = 2081 × 11200 + 1,
donc on a bien ab ≡ 1 (mod φ(n)).
I
K = (n, p, q, a, b) = (11413, 101, 113, 6597, 3533).
I
Bob publie n = 11413 et b = 3533.
Exemple
I
Supposons que Bob choisisse p = 101 et q = 113. On a n = 11413
et φ(n) = 100 × 112 = 11200.
I
Soient a = 6597 et b = 3533. Alors :
ab = 23307201 = 2081 × 11200 + 1,
donc on a bien ab ≡ 1 (mod φ(n)).
I
K = (n, p, q, a, b) = (11413, 101, 113, 6597, 3533).
I
Bob publie n = 11413 et b = 3533.
I
Si Alice souhaite chiffrer le message 9726 pour l ’envoyer à Bob, elle
calcule :
97263533 mod 11413 = 5761
et envoie le message chiffré 5761.
Exemple
I
Supposons que Bob choisisse p = 101 et q = 113. On a n = 11413
et φ(n) = 100 × 112 = 11200.
I
Soient a = 6597 et b = 3533. Alors :
ab = 23307201 = 2081 × 11200 + 1,
donc on a bien ab ≡ 1 (mod φ(n)).
I
K = (n, p, q, a, b) = (11413, 101, 113, 6597, 3533).
I
Bob publie n = 11413 et b = 3533.
I
Si Alice souhaite chiffrer le message 9726 pour l ’envoyer à Bob, elle
calcule :
97263533 mod 11413 = 5761
et envoie le message chiffré 5761.
I
Lorsque Bob reçoit 5761, il calcule : 57616597 mod 11413 = 9726.
Sécurité de RSA
Repose sur la clé privée a. Supposons que Martin intercepte le message
chiffré 5761 :
Sécurité de RSA
Repose sur la clé privée a. Supposons que Martin intercepte le message
chiffré 5761 :
I
S’il connait a, il peut obtenir le message clair comme Bob :
57616597 mod 11413 = 9726.
Sécurité de RSA
Repose sur la clé privée a. Supposons que Martin intercepte le message
chiffré 5761 :
I
S’il connait a, il peut obtenir le message clair comme Bob :
57616597 mod 11413 = 9726.
I
S’il connait φ(n), il peut calculer a = b −1 mod φ(n).
Calcul d’inverse par l’algorithme d’Euclide étendu en O(k 2 ) où
k = log(max(a, b)).
Sécurité de RSA
Repose sur la clé privée a. Supposons que Martin intercepte le message
chiffré 5761 :
I
S’il connait a, il peut obtenir le message clair comme Bob :
57616597 mod 11413 = 9726.
I
S’il connait φ(n), il peut calculer a = b −1 mod φ(n).
Calcul d’inverse par l’algorithme d’Euclide étendu en O(k 2 ) où
k = log(max(a, b)).
I
S’il connait p et q, alors φ(n) = (p − 1)(q − 1).
La sécurité de RSA est donc fondée sur la difficulté de la factorisation
de n. Les nombres premiers p et q doivent être très grands (512 bits).
Test de primalité de Miller-Rabin
I
Test de Miller-Rabin (1976) : un algorithme probabiliste du type
Monte Carlo à erreur unilatérale 1/4.
I
Idée : l’algorithme cherche une preuve de non-primalité et s’il n’en
trouve pas déclare le nombre premier.
Test de primalité de Miller-Rabin
I
Test de Miller-Rabin (1976) : un algorithme probabiliste du type
Monte Carlo à erreur unilatérale 1/4.
I
Idée : l’algorithme cherche une preuve de non-primalité et s’il n’en
trouve pas déclare le nombre premier.
I
Repose sur la propriété suivante :
Soit p un nombre premier impair et a ∈ {1, ..., p − 1}, on note r
l’unique entier impair tel que p − 1 = 2s r alors :
I
I
soit ar = 1 mod p
j
soit a2 r = −1 mod p pour un entier j, 0 ≤ j ≤ s − 1.
Témoins forts de non-primalité
I
Soient n impair et a ∈ {1, ..., n − 1}. Alors n − 1 = 2s r , où r impair.
6 1
On dit que a est un témoin fort de non-primalité pour n, si ar =
j
mod n et ∀j, 0 ≤ j ≤ s − 1, a2 r 6= −1 mod n.
I
Un nombre premier n’a donc pas de témoin fort de non-primalité.
I
Propriété : Tout entier n, impair et non premier, a au moins
3(n − 1)/4 témoins forts de non-primalité.
I
Le test de Miller-Rabin cherche des témoins de non-primalité forts :
si n est un entier impair et non premier alors un entier
a ∈ {1, . . . , n − 1} choisi de manière uniforme a une probabilité d’au
moins 3/4 d’être un témoin fort de non-primalité.
1
2
3
4
5
6
7
Test de Miller-Rabin
Entrées : Un entier n impair.
Sorties : Composé ou (probablement) Premier
r := n − 1 ; s := 0 ;
tant que r est pair faire
r := r /2 ; s := s + 1 ;
Tirer un entier a uniformément dans {1, ..., n − 1};
x := ar mod n;
si x = 1 ou x = n − 1 alors
retourner Premier
13
j := 1;
tant que j < s faire
x := x 2 mod n;
si x = n − 1 alors retourner Premier ;
si x = 1 alors retourner Composé;
j := j + 1;
14
retourner Composé
8
9
10
11
12
Introduction
Un ensemble S d’objets. A chaque x ∈ S on associe une clé k(x).
On suppose que toutes les clés sont distinctes et que l’ensemble K de
clés est totalement ordonné.
Les opérations élémentaires :
I
creer(S) : crée un nouvel ensemble vide S ;
I
trouver(k, S) : retourne l’objet de clé k de l’ensemble S, s’il
existe ;
I
inserer(k, S) : ajoute l’objet de clé k à l’ensemble S ;
I
supprimer(k, S) : retire l’objet de clé k de l’ensemble S.
Autres opérations : union, separer, premier, suivant . . .
Introduction
Un ensemble S d’objets. A chaque x ∈ S on associe une clé k(x).
On suppose que toutes les clés sont distinctes et que l’ensemble K de
clés est totalement ordonné.
Les opérations élémentaires :
I
creer(S) : crée un nouvel ensemble vide S ;
I
trouver(k, S) : retourne l’objet de clé k de l’ensemble S, s’il
existe ;
I
inserer(k, S) : ajoute l’objet de clé k à l’ensemble S ;
I
supprimer(k, S) : retire l’objet de clé k de l’ensemble S.
Autres opérations : union, separer, premier, suivant . . .
Question : quelle structure de données pour représenter S ?
Arbres binaires de recherche
I
Un arbre binaire de recherche (ABR) est un arbre binaire étiqueté
dont les étiquettes vérifient :
Pour tout noeud x, la clé de x est supérieure à toutes les clés du
sous-arbre gauche de x et inférieure à toutes les clés du sous-arbre
droit de x.
I
La complexité des opérations élémentaires :
creer : en Θ(1) ; trouver, inserer, supprimer : en O(h) où h
est la hauteur de l’arbre.
Problème : pire cas h = |S|.
Arbres binaires de recherche
I
Un arbre binaire de recherche (ABR) est un arbre binaire étiqueté
dont les étiquettes vérifient :
Pour tout noeud x, la clé de x est supérieure à toutes les clés du
sous-arbre gauche de x et inférieure à toutes les clés du sous-arbre
droit de x.
I
La complexité des opérations élémentaires :
creer : en Θ(1) ; trouver, inserer, supprimer : en O(h) où h
est la hauteur de l’arbre.
Problème : pire cas h = |S|.
I
Solution deterministe : les ABR auto-équilibrants.
Exemples : arbres AVL, arbres rouge et noir, arbres splay.
trouver, inserer, supprimer : en O(log |S|)
(dans le pire des cas pour les arbres AVL et les arbres rouge et noir ;
en analyse amortie pour les arbres splay).
Nécessitent d’effectuer des rééquilibrages.
Treaps
En anglais : tree (arbre) & heap (tas).
Rappels :
I
un arbre binaire de recherche (ABR) est un arbre binaire étiqueté
dont les étiquettes vérifient :
Pour tout noeud x, la clé de x est supérieure à toutes les clés du
sous-arbre gauche de x et inférieure à toutes les clés du sous-arbre
droit de x.
I
un tas est un arbre étiqueté dont les étiquettes vérifient :
Pour tout noeud x, la clé de x est la plus grande clé parmi toutes les
clés du sous-arbre dont la racine est x.
Treaps
Treap : un arbre binaire tel que
I
7, 30
chaque noeud interne contient 2
informations : une clé k(u) et
une priorité p(u) ;
I
les clés forment un ABR ;
I
les priorités forment un tas.
4, 26
2, 13
On suppose les clés et les priorités distinctes.
11, 27
6, 19
9, 14
12, 22
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
I
n = 0 évident.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
I
n = 0 évident.
I
Supposons la propriété (d’existence et d’unicité) vraie pour tout
m ≤ n. Soit S un ensemble de taille n + 1.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
I
n = 0 évident.
I
Supposons la propriété (d’existence et d’unicité) vraie pour tout
m ≤ n. Soit S un ensemble de taille n + 1.
Soit (k, p) l’élément de S de priorité maximale et soient
S< = {(k 0 , p 0 ) : k 0 < k} et S> = {(k 0 , p 0 ) : k 0 > k}.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
I
n = 0 évident.
I
Supposons la propriété (d’existence et d’unicité) vraie pour tout
m ≤ n. Soit S un ensemble de taille n + 1.
Soit (k, p) l’élément de S de priorité maximale et soient
S< = {(k 0 , p 0 ) : k 0 < k} et S> = {(k 0 , p 0 ) : k 0 > k}.
S< et S> sont de taille au plus n et admettent chacun un unique
treap (T< et T> ). L’arbre binaire T avec racine (k, p), sous-arbre
gauche T< et sous-arbre droit T> est un treap pour S.
Existence et unicité
Soit S ⊂ K × P un ensemble fini de couples (ki , pi ) où K et P sont
totalement ordonnés, avec des éléments distincts. Alors il existe un
unique treap dont les sommets sont étiquetés par les éléments de S.
Preuve. Par récurrence sur n = |S|.
I
n = 0 évident.
I
Supposons la propriété (d’existence et d’unicité) vraie pour tout
m ≤ n. Soit S un ensemble de taille n + 1.
Soit (k, p) l’élément de S de priorité maximale et soient
S< = {(k 0 , p 0 ) : k 0 < k} et S> = {(k 0 , p 0 ) : k 0 > k}.
S< et S> sont de taille au plus n et admettent chacun un unique
treap (T< et T> ). L’arbre binaire T avec racine (k, p), sous-arbre
gauche T< et sous-arbre droit T> est un treap pour S.
T est unique treap pour S.
Operations élémentaires
I
I
trouver(k,S) : de la même manière que dans un ABR ;
inserer(k,S) : en 2 étapes
Etape 1 (comme dans un ABR) : effectuer un trouver(k,S) puis
ajouter le nouveau nœud interne à la place de la feuille où la
recherche se termine par un échec.
Operations élémentaires
I
I
trouver(k,S) : de la même manière que dans un ABR ;
inserer(k,S) : en 2 étapes
Etape 1 (comme dans un ABR) : effectuer un trouver(k,S) puis
ajouter le nouveau nœud interne à la place de la feuille où la
recherche se termine par un échec.
Etape 2 (si la condition de tas n’est pas verifiée après l’insertion) :
effectuer des rotations successives pour remonter le nouveau nœud
de clé k, tant que sa priorité est supérieure de celle de son père.
Rotations élémentaires
b
a
a
b
C
A
B
A
B
C
Operations élémentaires
I
supprimer(k,S) :
effectuer une rotation entre le nœud de clé k et celui de ses fils qui a
la plus grande priorité ;
répéter cette opération jusqu’à ce que le sommet de clé k n’ait que
des feuilles comme fils ;
puis éliminer le nœud de clé k et le remplacer par une feuille.
Operations élémentaires
I
supprimer(k,S) :
effectuer une rotation entre le nœud de clé k et celui de ses fils qui a
la plus grande priorité ;
répéter cette opération jusqu’à ce que le sommet de clé k n’ait que
des feuilles comme fils ;
puis éliminer le nœud de clé k et le remplacer par une feuille.
I
Opérations trouver(k,S), inserer(k,S) et supprimer(k,S) en
temps O(h), où h la hauteur de l’arbre.
Treap probabiliste
La priorité associée à un objet :
I
est une variable aléatoire uniforme sur [0, 1], indépendante des
autres priorités (et de la clé !) ;
I
est fixée lors de l’insertion et n’est pas modifiée tant que l’objet
reste dans l’arbre.
Treap probabiliste
La priorité associée à un objet :
I
est une variable aléatoire uniforme sur [0, 1], indépendante des
autres priorités (et de la clé !) ;
I
est fixée lors de l’insertion et n’est pas modifiée tant que l’objet
reste dans l’arbre.
Propriété d’unicité implique que :
I
le treap obtenu après une suite d’insertions/suppressions ne dépend
que des priorités des objets qui restent dans l’arbre (et non pas de
l’ordre de ces opérations ni des objets supprimés).
I
en particulier, le treap obtenu est identique à celui que l’on aurait
obtenu en insérant les clés dans l’ordre décroissant des priorités
(note : dans cet ordre il n’y a pas de rotations).
Complexité des opérations élémentaires
I
Les priorités sont choisies indépendaments des clés.
I
En regardant que les clés :
un ABR aléatoire = ABR obtenu en insérant les clés dans un ordre
aléatoire avec toutes les permutations équiprobables.
I
Toute grandeur probabiliste calculée sur un ABR aléatoire reste vrai
pour le modèle de treaps.
Complexité des opérations élémentaires
I
Les priorités sont choisies indépendaments des clés.
I
En regardant que les clés :
un ABR aléatoire = ABR obtenu en insérant les clés dans un ordre
aléatoire avec toutes les permutations équiprobables.
I
Toute grandeur probabiliste calculée sur un ABR aléatoire reste vrai
pour le modèle de treaps.
I
Propriété. La hauteur hn d’un ABR aléatoire de n nœuds vérifie :
E(hn ) = O(log(n)).
Complexité des opérations élémentaires
I
Les priorités sont choisies indépendaments des clés.
I
En regardant que les clés :
un ABR aléatoire = ABR obtenu en insérant les clés dans un ordre
aléatoire avec toutes les permutations équiprobables.
I
Toute grandeur probabiliste calculée sur un ABR aléatoire reste vrai
pour le modèle de treaps.
I
Propriété. La hauteur hn d’un ABR aléatoire de n nœuds vérifie :
E(hn ) = O(log(n)).
I
Dans le treap probabiliste de n objets, les opérations élémentaires
trouver, inserer et supprimer s’effectuent en temps moyen
O(log(n)).
(note : ne dépend pas des clés !)
Structures de données probabiliste
I
La représentation en mémoire de la structure n’est pas une fonction
déterministe de la séquence d’opérations qui ont servi à sa création.
I
La partie aléatoire sert à “éviter” les cas pathologiques.
Bien évidemment, ils sont toujours possibles, mais cela ne dépend
plus de la séquence d’opérations donnée : on a le même
comportement en moyenne pour tout ensemble S de taille n.
Hachage
I
U l’univers des clés et K l’ensemble des clés utilisées pour les objets
dans S. Soit m = |S|.
I
Soit h une fonction d’hachage h : U → {0, . . . , n − 1}.
I
Hypothèse : hachage uniforme simple
a) pour tout x ∈ U, probabilité que h(x) = j égale à 1/n, 0 ≤ j ≤ n ;
b) les valeurs de h(x) sont indépendantes pour des x différents.
(note : pour un x donné, la valeur de h(x) est deterministe !)
I
Si n < m on a toujours des collisions (clés k1 6= k2 et
h(k1 ) = h(k2 )).
Hachage avec chaı̂nage
U
K
Hachage avec chaı̂nage
U
K
trouver(k,S)
Nombre moyen d’objets dans la même “boı̂te” :
I
si x 6∈ K : m/n ;
I
si x ∈ K : 1 + (m − 1)/n.
Hachage avec chaı̂nage
U
K
trouver(k,S)
Nombre moyen d’objets dans la même “boı̂te” :
I
si x 6∈ K : m/n ;
I
si x ∈ K : 1 + (m − 1)/n.
Si m = n, alors le temps moyen en O(1). Pire de cas ?
Hachage avec chaı̂nage
U
K
trouver(k,S)
Nombre moyen d’objets dans la même “boı̂te” :
I
si x 6∈ K : m/n ;
I
si x ∈ K : 1 + (m − 1)/n.
Si m = n, alors le temps moyen en O(1). Pire de cas ?
Complexité en espace mémoire : O(m).
Hachage par empreintes
Exemple : le dictionnaire des mots de passe trop faibles.
I
La valeur h(x) est une empreinte de x. Ex. un mot de 32 bits.
I
Pour chaque mot dans x ∈ S, calculer son empreinte h(x). On garde
les empreintes des mots dans x ∈ S dans une liste triée L
(la recherche en O(log m)).
I
Pour verifier si un mot de passe est trop faible :
calculer son empreinte h(x),
puis chercher h(x) dans L.
I
Plusieurs mots peuvent avoir la même empreinte (collisions) !
Erreur unilatérale (si l’empreinte du mot x n’est pas dans L, alors
x 6∈ S).
Probabilité d’erreur
I
Soit b le nombre de bits utilisés pour les empreintes.
I
Soit x ∈ S fixé. La probabilité qu’un élément y 6∈ S a la même
empreinte que le mot x est 1/2b .
Probabilité d’erreur
I
Soit b le nombre de bits utilisés pour les empreintes.
I
Soit x ∈ S fixé. La probabilité qu’un élément y 6∈ S a la même
empreinte que le mot x est 1/2b .
I
Il y a m mots dans S. La probabilité d’erreur :
m
b
1
1− 1− b
≈ 1 − e −m/2 .
2
Probabilité d’erreur
I
Soit b le nombre de bits utilisés pour les empreintes.
I
Soit x ∈ S fixé. La probabilité qu’un élément y 6∈ S a la même
empreinte que le mot x est 1/2b .
I
Il y a m mots dans S. La probabilité d’erreur :
m
b
1
1− 1− b
≈ 1 − e −m/2 .
2
I
Si on veut une probabilité d’erreur p, alors on doit prendre b tel que
b
e −m/2 ≥ 1 − p,
m
b ≥ log2
ln(1/(1 − p))
i.e. b = Θ(log m) bits.
Filtres de Bloom
I
Soit A un tableau de n bits. A[0], . . . , A[n − 1] initialisés à 0.
I
h1 , . . . , hk fonctions d’hachage indépendantes
hi : U → {0, . . . , n − 1}.
I
Soit S = {s1 , . . . , sm } un ensemble de m éléments de U
(note : |U| >> m).
I
Pour chaque s ∈ S, les bits A[hi (s)] sont mis à 1, pour 1 ≤ i ≤ k.
I
Pour vérifier si x ∈ S, vérifier si tous les A[hi (x)] sont égaux à 1. Si
oui, alors on suppose que x ∈ S.
I
Erreur unilatérale possible (il est possible que x 6∈ S soit declaré
dans S, mais pas le contraire).
Probabilité d’erreur
I
La probabilité qu’un bit fixé est toujours à 0 après qu’on a considéré
les m éléments dans S :
km
1
≈ e −km/n .
1−
n
I
Pour vérifier si un x ∈ U est dans S on fait k tests. La probabilité
qu’il sont tous à 1 (la probabilité d’erreur) peut être approximée par :
perr =
1
1− 1−
n
km !k
Note : Pour perr fixé, n = Θ(m).
k
≈ 1 − e −km/n
Remarques
I
Si m %, alors perr %.
I
Si n %, alors perr &.
I
Si k % ?
Pour m et n fixés :
plus k est grand plus la probabilité qu’un bit reste à 0 est petite,
mais aussi dans trouver(x, S) on a plus de tests “est-ce que
A[hi (x)] = 1 ?” à faire (et donc plus de chance qu’un donne 0)...
Optimisation : k =
elle est égale à
n
m
ln 2 donne la probabilité d’erreur minimale et
perr = 2−k ≈ 0.6185n/m .
I
Pour avoir une probabilité d’erreur perr fixée :
n=−
m ln perr
.
(ln 2)2
(sous condition d’utiliser le k optimal)