diff --git a/TP2_hachage/Readme.md b/TP2_hachage/Readme.md
index 774dcd4ac8c16bdc46f5030d8a7836fc53b68362..34503183f0eb1c8e7018b097a2cb80991cfdb3d1 100644
--- a/TP2_hachage/Readme.md
+++ b/TP2_hachage/Readme.md
@@ -1,8 +1,6 @@
 # TP Hachage
 
 
-
- 
 # Partie 1 - Réaliser une fonction de hachage minimale parfaite 
 
 On travaillera sur `tp_2_miso_mphf.py`.
@@ -16,8 +14,58 @@ Vous devez
 
 Ecrivez vos réponses et commentaires dans ce document.
 
+# Explication de tableaux.append(tableau_principal)
+
+Cette ligne permet d'ajouter le tableau principal (actuel) à la liste des tableaux. 
+On fait cela car on va réduire la taille de la table de hachage à plusieurs reprise, nous allons donc stocker dans cette liste les table au fur et à mesure.
+
+# Explication de set_kmer_courant = collision.copy()
+
+Après un niveau il se peut qu'il y ait des k-mers en collision ceux-ci sont enregistré dans 'collision'.
+Ensuite set_kmer_courant est mis à jour pour qu'il contienne les k-mers qui ont subi une collison. 
+L'objectif est d'essayer d'insérer ces k-mer en collision pour les intégrer dans le prochain niveau de la table de hachage.
+
+#Explication de collision = set()
+
+Cette ligne permet de vider collision. En effet après avoir copié les valeurs de collision dans set_kmer_courant, 
+on va réinitialiser collision pour le prochain niveau de la table de hashage. 
+On recommence avec une liste collision qui contient les éléments à traiter.
+
+# Explication de grand_tableau.extend(tableau)
+
+Nous avons des tableaux crée à chaque niveau pour contenir les résultats intermédiaire du hachage.
+Cette ligne permet d'ajouter tout les éléments stockée dans tableau dans seul grand_tableau. Ca sert à regrouper toute les tables intermédiaires dans un seul grand tableau. 
+On va pouvoir ainsi récupérer les indices des k-mers dans un seul tableau.
+
+# Explication de:
+for kmer in set_kmer_courant:
+    max_rang += 1
+    h = abs(hash(kmer))
+    mphf.append([h, max_rang])
+
+Ce bloc permet de donner un rang aux k-mer qui sera donc unique pour les cas où par exemple des collisions persisterais après avoir terminé de diminuer la table.
+On parcours tous les kmers et on leurs attribut un rang +1 par au precedent.
+On recupère le hash du k-mer puis on l'ajoute avec le rang à la MPHF
+
+# Explication de pourquoi ici on ne mesure pas juste la taille en mémoire du tableau ? 
+table_size.append(sys.getsizeof(tableau) + sys.getsizeof(mphf))
+
+Cette ligne permet de calculer la taille de tableau qui contient les k-mers placé à la position de leurs hash respectif
+additioné à la taille de la mphf qui contient la fonction pour bien placer ces k-mers.
+Il nous faut donc pour avoir une bonne estimation de l'utilisation de la mémoire prendre le tableau et la mphf.
+Nous pourrons ensuite comparer avec la taille des dictionnaire python.
+
 Puis décommenter `compare_taille` à la fin et expliquer les résultats.
 
+# Explication du graphique mphf.png
+
+Ce graphique permet d'observer l'évolution de la taille mémoire utilisée par une table MPHF (en bleu) et un dictionnaire python en orange pour un nombre 'n' de k-mer.
+On observe que la courbe MPHF augmente progressivement de manière linéaire tandis que la courbe 'dict' augmente en escalier.
+La courbe augmente par palier brutalement vers 4100 k-mers.
+Cela pourrait s'expliquer par le fait que les dictionnaire python vont doubler la taille de la mémoire pour éviter les phénomènes de collision.
+Nous pouvons conclure que la MPHF consomme beaucoup moins de mémoire que le dictionnaire surtout pour les grandes valeurs.
+
+
 Bonus : faites varier `nb_niveaux` et `gamma`, voyez quelle influence ils peuvent avoir.
 
 # Partie 2 - Analyse de performance de dictionnaires en Python