diff --git a/representation_base/chapitre_2/README.md b/representation_base/chapitre_2/README.md
index 77882d5..2abef0e 100644
--- a/representation_base/chapitre_2/README.md
+++ b/representation_base/chapitre_2/README.md
@@ -44,6 +44,27 @@ Les opérations ci dessous manipulent des nombres représentés en binaire, cod
 
 **_À votre avis, que donne cette dernière opération ?_**
 
+
+
+ Autre exemple : calculer 1000₂ − 0011₂ (soit 8 − 3 = 5)
+$$
+\begin{align*}
+1000 - 0011 &= ? \\
+\end{align*}
+$$
+On part du bit de droite (bit de poids faible, ou LSB) vers la gauche :
+	•	Colonne 0 : 0 − 1 → impossible, on emprunte
+on fait 0 + 2 − 1 = 1, et on place un emprunt pour la colonne suivante.
+	•	Colonne 1 : on doit faire 0 − 1 − 1(emprunt) = 0 − 2 → on emprunte
+0 + 2 − 2 = 0, emprunt pour la colonne suivante.
+	•	Colonne 2 : 0 − 0 − 1(emprunt) = −1 → on emprunte
+0 + 2 − 1 = 1, emprunt pour la colonne suivante.
+	•	Colonne 3 : 1 − 0 − 1(emprunt) = 0 → pas d’emprunt.
+
+Résultat : 0101₂ soit 5<sub>10</sub> 
+
+
+
 ## 1. La représentation binaire signée
 
 La première méthode utilisée pour représenter des entiers négatifs est de réserver un bit qui déterminera le signe. 
@@ -66,13 +87,40 @@ Prenons un exemple avec l'entier $`5`$ sur 4 bits :
 
 Cependant cette méthode possède un inconvénient majeur :
 
-Les opérations "classiques" avec 2 nombres binaires ne fonctionnent plus ! C'est pour ces raisons que nous allons utiliser une nouvelle méthode : **le complément à deux**.
+Les opérations "classiques" avec 2 nombres binaires ne fonctionnent plus ! 
 
-Par ailleurs, on peut observer qu'il existe dorénavant deux manières de notation du nombre zéro (0) :
+Ensuite, on peut observer qu'il existe dorénavant deux manières de notation du nombre zéro (0) :
 
 - $`0000\ 0000 = +0`$
 - $`1000\ 0000 = -0`$
 
+Cela pose problème, car en maths **0 est unique**.
+
+Enfin, cela peut des **incohérences dans les calculs** : 
+$$
+(+1) + (−1)  ≠ 0
+$$
+
+
+Regardons cela : 
+$$
+  0001
++ 1001
+= 
+ 1010
+$$
+
+
+
+
+Or 1010₂ correspond à −2 dans cette représentation, alors qu’en mathématiques, on devrait trouver **0**.
+
+Résultat : les opérations arithmétiques classiques ne fonctionnent pas avec cette méthode, ce qui oblige à traiter des cas particuliers.
+
+C’est une des raisons pour lesquelles on a inventé le **complément à 2**, qui supprime le double zéro et rend les additions correctes.
+
+
+
 ## 2. Le complément à 2
 
 Le **complément à 2** est la méthode de représentation d'un entier négatif.
@@ -100,16 +148,60 @@ Dans l'opération ci-dessus, nous avons un 1 pour le 9ième bit, mais comme notr
 - Quel est le plus petit entier négatif que l'on peut représenter sur huit (8) bits ?
 - Et quel est le le plus grand ?
 
-# ✎ Remarque ✎ :
+
+
+----------------
+
+#### Mémo 
+
+| **Binaire** | **Valeur non signée** | **Valeur signée (complément à 2)** |
+| ----------- | --------------------- | ---------------------------------- |
+| 0000        | 0                     | 0                                  |
+| 0001        | 1                     | 1                                  |
+| 0010        | 2                     | 2                                  |
+| 0011        | 3                     | 3                                  |
+| 0100        | 4                     | 4                                  |
+| 0101        | 5                     | 5                                  |
+| 0110        | 6                     | 6                                  |
+| 0111        | 7                     | 7                                  |
+| 1000        | 8                     | -8                                 |
+| 1001        | 9                     | -7                                 |
+| 1010        | 10                    | -6                                 |
+| 1011        | 11                    | -5                                 |
+| 1100        | 12                    | -4                                 |
+| 1101        | 13                    | -3                                 |
+| 1110        | 14                    | -2                                 |
+| 1111        | 15                    | -1                                 |
+
+### Remarque  :
 
 Plus généralement, nous pouvons dire que pour une représentation sur $`n`$ bits, il sera possible de coder des valeurs comprises entre $`-2^{n-1}`$ et $`+2^{n-1} - 1`$ .
 
 Sachant que dans le langage C, les entiers signés sont codés sur 32 bits, dont un (1) pour le signe, quelles sont les valeurs minimale et maximale des entiers que l'on peut représenter ?
 
-En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeurs minimale et maximale des entiers ne dépend que de la quantité de mémoire disponible sur votre machine.
+- Ce qui est intéressant, c’est que quand on **dépasse la borne**, on “reboucle” :
+
+  
+
+  - 2147483647 + 1 = - 2147483648.
+  - Ce phénomène s’appelle un **overflow (dépassement de capacité)**.
+  - Et ça, c’est possible uniquement parce qu’on utilise le **complément à 2**, qui permet d’avoir des additions binaires cohérentes même quand on “déborde”.
+
+En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeurs minimale et maximale des entiers ne dépendent que de la quantité de mémoire disponible sur votre machine.
 
 Néanmoins, on dispose de la bibliothèque _numpy_ qui permet de forcer une représentation sur 8 bits, par exemple, à l'aide de la fonction *int8*
 
+```python
+import numpy as np
+
+a = np.int8(120)
+b = np.int8(10)
+
+print(a + b)  # Résultat ?
+```
+
+
+
 --------
 
 Auteurs  : Florian Mathieu - Philippe Boddaert