diff --git a/COMPTE_RENDU.md b/COMPTE_RENDU.md
new file mode 100644
index 0000000..4d203ed
--- /dev/null
+++ b/COMPTE_RENDU.md
@@ -0,0 +1,91 @@
+# Compte rendu – TD Complexité cyclomatique (R5.A.04)
+
+## Partie 1 – Graphes de flot de contrôle
+
+Pour chaque fonction, on construit le graphe de flot de contrôle (un nœud = un bloc sans branchement, une décision = un nœud à deux sorties, un seul nœud de sortie), puis on applique :
+
+**M = E − N + 2P** (E = arêtes, N = nœuds, P = 1 pour une fonction)
+
+On vérifie ensuite le résultat avec la règle pratique **M = décisions + 1**.
+
+### C2 – `moyenne` (C)
+
+![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
+
+### J2 – `estDisponible` (Java)
+
+![Graphe J2](Graphe/J2.png)
+
+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
+
+### 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)
+
+![Graphe P3](Graphe/P3.jpg)
+
+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
+
+| Fonction | N | E | M | Classe |
+|---|---|---|---|---|
+| C2 `moyenne` | 8 | 9 | 3 | Simple |
+| J2 `estDisponible` | 4 | 5 | 3 | Simple |
+| P2 `signe` | 6 | 7 | 3 | Simple |
+| P3 `notes_valides` | 5 | 6 | 3 | Simple |