diff --git a/COMPTE_RENDU.md b/COMPTE_RENDU.md
index 2c8903f..a8c6457 100644
--- a/COMPTE_RENDU.md
+++ b/COMPTE_RENDU.md
@@ -12,35 +12,15 @@ On vérifie ensuite le résultat avec la règle pratique **M = décisions + 1**.
 
 ![Graphe C2](Graphe/C2.jpg)
 
-| Nœud | Contenu |
-|---|---|
-| 1 | `somme = 0 ; i = 0` |
-| 2 | décision `i < n` |
-| 3 | `somme += t[i]` |
-| 4 | `i++` (arête de retour vers 2) |
-| 5 | décision `n > 0` (ternaire) |
-| 6 | `somme / n` |
-| 7 | `0` |
-| 8 | sortie (`return`) |
-
 - N = 8, E = 9, P = 1
 - **M = 9 − 8 + 2 × 1 = 3**
-- Vérification : 1 `for` + 1 ternaire `?:` + 1 = 3
 
 ### C4 – `nom_jour` (C)
 
 ![Graphe C4](Graphe/C4.jpg)
 
-| Nœud | Contenu |
-|---|---|
-| 1 | `switch (jour)` |
-| 2 à 8 | `case 1` à `case 7` : `return "lundi"` … `return "dimanche"` |
-| 9 | `default` : `return "inconnu"` |
-| 10 | sortie |
-
 - N = 10, E = 16 (8 arêtes du `switch` vers chaque branche + 8 arêtes des branches vers la sortie), P = 1
 - **M = 16 − 10 + 2 × 1 = 8**
-- Vérification : 7 `case` + 1 = 8 (le `default` ne compte pas : c'est le « sinon » du `switch`)
 
 ### J2 – `estDisponible` (Java)
 
@@ -48,16 +28,8 @@ On vérifie ensuite le résultat avec la règle pratique **M = décisions + 1**.
 
 La méthode ne contient aucun `if`, mais les `&&` sont évalués paresseusement : chaque opérande est une décision (si `livre.emprunte` est vrai, on sort directement sans évaluer la suite).
 
-| Nœud | Contenu |
-|---|---|
-| 1 | décision `!livre.emprunte` |
-| 2 | décision `!livre.reserve` |
-| 3 | décision `!livre.abime` |
-| 4 | sortie (`return`) |
-
 - N = 4, E = 5, P = 1
 - **M = 5 − 4 + 2 × 1 = 3**
-- Vérification : 2 opérateurs `&&` + 1 = 3
 
 ### J6 – `importer` (Java)
 
@@ -65,48 +37,15 @@ La méthode ne contient aucun `if`, mais les `&&` sont évalués paresseusement
 
 Les nœuds de décision sont en jaune, et la condition de la boucle `for` est en bleu.
 
-| Nœud | Contenu |
-|---|---|
-| 1 | `importes = 0` |
-| 2 | décision `for` : reste-t-il une ligne ? |
-| 3 | décision `ligne.isBlank()` |
-| 4 | décision `ligne.startsWith("#")` (le `\|\|`) |
-| 5 | `continue` |
-| 6 | `champs = ligne.split(";")` |
-| 7 | décision `champs.length != 4` |
-| 8 | `System.err.println(...)` + `continue` |
-| 9 | `try` : `annee = Integer.parseInt(...)` |
-| 10 | décision `annee > 0` |
-| 11 | décision `annee <= 2026` (le `&&`) |
-| 12 | `livres.add(...)` + `importes++` |
-| 13 | décision `catch` : `NumberFormatException` levée ? |
-| 14 | `System.err.println("Année invalide ...")` |
-| 15 | sortie (`return importes`) |
-
-Arêtes : 1→2, 2→3, 2→15, 3→4, 3→5, 4→5, 4→6, 5→2, 6→7, 7→8, 7→9, 8→2, 9→10, 10→11, 10→13, 11→12, 11→13, 12→13, 13→2, 13→14, 14→2.
-
 - N = 15, E = 21, P = 1
 - **M = 21 − 15 + 2 × 1 = 8**
-- Vérification : 1 `for` + 1 `if` + 1 `||` + 1 `if` + 1 `if` + 1 `&&` + 1 `catch` = 7 décisions, + 1 = 8
-
-> Cas particuliers : le `||` et le `&&` comptent chacun comme une décision (évaluation paresseuse), et le `catch` aussi, puisqu'il crée un second chemin de sortie du `try`. Les `continue` ne comptent pas : ils renvoient simplement vers la condition de la boucle.
 
 ### P2 – `signe` (Python)
 
 ![Graphe P2](Graphe/P2.jpg)
 
-| Nœud | Contenu |
-|---|---|
-| 1 | décision `x > 0` |
-| 2 | `return 1` |
-| 3 | décision `x < 0` (`elif`) |
-| 4 | `return -1` |
-| 5 | `return 0` |
-| 6 | sortie |
-
 - N = 6, E = 7, P = 1
 - **M = 7 − 6 + 2 × 1 = 3**
-- Vérification : 1 `if` + 1 `elif` + 1 = 3
 
 ### P3 – `notes_valides` (Python)
 
@@ -114,19 +53,8 @@ Arêtes : 1→2, 2→3, 2→15, 3→4, 3→5, 4→5, 4→6, 5→2, 6→7, 7→8,
 
 La compréhension de liste cache une boucle et un filtre : elle se lit comme un `for` contenant un `if`.
 
-| Nœud | Contenu |
-|---|---|
-| 1 | initialisation de la liste résultat |
-| 2 | décision : reste-t-il un élément `n` dans `notes` ? |
-| 3 | décision `0 <= n <= 20` |
-| 4 | ajout de `n` au résultat (retour vers 2) |
-| 5 | sortie (`return`) |
-
 - N = 5, E = 6, P = 1
 - **M = 6 − 5 + 2 × 1 = 3**
-- Vérification : 1 `for` + 1 `if` (dans la compréhension) + 1 = 3
-
-> Remarque : `0 <= n <= 20` est une comparaison chaînée, équivalente à `0 <= n and n <= 20`. Si on compte ce `and` implicite comme une décision, on obtient M = 4. Nous l'avons compté comme une seule condition, comme le font la plupart des outils (aucun opérateur `and` n'apparaît dans le code).
 
 ### Récapitulatif
 
diff --git a/Graphe/J6.png b/Graphe/J6.png
new file mode 100644
index 0000000..8af34db
Binary files /dev/null and b/Graphe/J6.png differ