diff --git a/Code/todo.md b/Code/todo.md
new file mode 100644
index 0000000..7f32133
--- /dev/null
+++ b/Code/todo.md
@@ -0,0 +1,2 @@
+- Implémenter correction d'erreur classique par répétition avec taux d'erreur varible.
+- Implémenter le code de Hamming
diff --git a/Notes/notes.pdf b/Notes/notes.pdf
index 84ee2c2..49d6b16 100644
Binary files a/Notes/notes.pdf and b/Notes/notes.pdf differ
diff --git a/Notes/notes.typ b/Notes/notes.typ
index 4e54de3..c25649c 100644
--- a/Notes/notes.typ
+++ b/Notes/notes.typ
@@ -10,6 +10,250 @@
 ]
 
 
+= Introduction à la théorie de l'information
+#v(5pt)
+
+Problème principal : il y a du bruit dans les transmissions mais on veut pas d'erreurs.\
+Au lieu de trouver des modifications physiques on va creer des solutions pour corriger les erreurs.\
+Il faut un *encodeur* qui ajoute de la redondance et un *décodeur*.\
+
+#v(5pt)
+
+#import "@preview/cetz:0.4.2"
+#align(center)[
+  #cetz.canvas(length: 1cm, {
+    import cetz.draw: *
+
+    content((0, 0), name: "src")[*Source*]
+
+    rect((2, -0.75), (5, 0.75), name: "enc")
+    content("enc")[Encodeur]
+
+    rect((7, -0.75), (10, 0.75), name: "chan")
+    content("chan")[Canal _(Bruité)_]
+
+    rect((12, -0.75), (15, 0.75), name: "dec")
+    content("dec")[Décodeur]
+
+    content((17, 0), name: "dest")[*Dest*]
+
+    line("src", "enc", mark: (end: ">"))
+    line("enc", "chan", mark: (end: ">"))
+    line("chan", "dec", mark: (end: ">"))
+    line("dec", "dest", mark: (end: ">"))
+
+    content((1, 0), anchor: "south", padding: 5pt)[$ s $]
+    content((6, 0), anchor: "south", padding: 5pt)[$ t $]
+    content((11, 0), anchor: "south", padding: 5pt)[$ r $]
+    content((16, 0), anchor: "south", padding: 5pt)[$ hat(s) $]
+  })
+  Code correcteur d'erreurs pour un cannal binaire symetrice @mackay
+]
+
+#v(5pt)
+
+Le but est de transformer un cannal bruité en cannal fiable avec un coups de calculs en plus (encodeur / décodeur).\
+On vas chercher la meilleur performance de correction d'erreurs. Ce sont les limites théoriques que cherchent à trouver la _Théorie de l'information_.
+Pas de retransmissions.
+
+#v(5pt)
+
+= Codes de répétition
+#pad(left: 1cm)[
+
+  == Définitions
+
+  Il s'agit ici de répter tous les bits. Un message source *$s$*, un message transmit *$t$*, un vecteur de bruit *$n$* et un message recu *$r$*. $space$ *$r = t + n$*.
+  #pad(left: 1cm)[
+    $s = space space 0 space space space space space 1$\
+    $t = overbrace(000) space overbrace(111)$ \
+    $n = 001 space space space 010$ \
+    $r = 001 space space space 101$\
+  ]
+  On décode en choisissant le bit le plus présent dans un bloc. \
+  C'est ce que représente le _Likelihood ratios_ : $P(r | s = 1) / P(r | s = 0)$ \
+  Ici $001 -> 0$ et $101 -> 1$ donc $hat(s) = 0 space 1$.\
+  Preuve de l'optimalité (dans le sens la plus faible probabilité d'erreurs) @mackay p6. \
+  *Problème* : trois fois plus de bande passante...
+]
+
+#v(5pt)
+
+= _Single parity check code_ et définitions algébriques
+#pad(left: 1cm)[
+  Ajout d'uniquement 1 bit d'information à la fin sur la parité du nombre de 1. \
+  Un message *$s$* est de la forme
+  $
+    s = [s_1 space s_2 space s_3 space s_4 space s_5 space s_6]
+  $
+  où $c_i in {0,1}$ et le _codeword_ vérifie la contraine si
+
+  #math.equation(
+    numbering: _ => "E",
+    block: true,
+  )[$s_1 plus.o s_2 plus.o s_3 plus.o s_4 plus.o s_5 plus.o s_6 = 0$]
+
+  _parity-check equation_.\
+  Inversion d'un nombre bit paire $=>$ E = 0 donc aucune erreur détécté.\
+  C'est donc pas assez puissant pour savoir quel bit à changé.\
+
+  On écrit sous forme matricielle.
+
+  $ H s^T = mat(1, 1, 0, 1, 0, 0; 0, 1, 1, 0, 1, 0; 1, 1, 1, 0, 0, 1;) mat(s_1; s_2; s_3; s_4; s_5; s_6) = mat(0; 0; 0) $ avec $H$ la matrice _parity-check_ où chaque ligne de $H$ correspond à l'équation de parité et chaque colonne de $H$ correspond à un bit du _codeword_.\
+
+  Les contraines sont alors les suivantes
+  $
+    s_4 & = s_1 plus.o s_2
+          s_5 & = s_2 plus.o s_3
+                s_6 & = s_1 plus.o s_2 plus.o s_3
+  $
+
+  De plus $s_4, s_5, s_6$ sont les bits de parités et :
+  $ s = [s_1 s_2 s_3 s_4 s_5 s_6] = [s_1, s_2, s_3]
+  underbrace(
+    mat(
+      1, 0, 0, 1, 0, 1;
+      0, 1, 0, 1, 1, 1;
+      0, 0, 1, 0, 1, 1
+    ), G
+  ) $ où *$G$* est la matrice génératrice du code.\
+
+  On note $u = [u_1, ..., u_k]$ où $u$ contient les $k$ bits du message, ici $u = [u_1, u_2, u_2]$
+  $ s = u G $ Pour un message de longueur $k$ et $n$ _codewords_, $G in M_(k times n) (ZZ \/ 2ZZ)$. \
+
+  De plus $k / n$ est le _rate_ du code.\
+
+  Un code de taille $k$ contient $2^k$ _codewords_. Ces _codewords_ sont des sous-ensembles avec $2^n$ vecteurs de taille $n$ possibles. \
+
+  On peut obtenir $H$ sout la forme
+
+  $ H = [A, I_(n-k)] $ avec $A in M_((n-k) times k) (ZZ \/ 2 ZZ)$ et donc
+  $ G = [I_k, A^T] $ De plus si $G$ est la matrice génératrice pour un code avec matrice de parité $H$ alors
+
+  $ G H^T = 0 $ $G$ est orthogonal à $H$.\
+
+  Un code peut avoir autant de contraites _parity-check_ qu'il veut mais seulement $n - k$ d'entre elle seront linéairement independantes. C'est à dire :
+
+  $
+    n - k = op("rg")(H)
+  $
+
+  Voir @johnson
+
+  == Comment détécter et corriger les erreurs
+
+  Supposon qu'on envoie $s = [1 space 0 space 1 space 1 space 1 space 0]$ et qu'on recois $r = [1 space 0 space 1 space 0 space 1 space 0]$ alors
+
+  $
+    H r^T = mat(1, 1, 0, 1, 0, 0; 0, 1, 1, 0, 1, 0; 1, 1, 1, 0, 0, 1;) mat(1; 0; 1; 0; 1; 0) = mat(1; 0; 0)
+  $
+
+  Le vecteur $s = H r^T$ est le *syndrome* de $r$, il indique quel contraine de _parity-check_ ne sont pas satisfaites par $r$.\
+
+  Ici $s = mat(1; 0; 0)$ et l'équation de parité associé est $s_4 = s_1 plus.o s_2$.\
+
+  Un _block code_ ne peut détecter des erreurs que si ces dernières ne transforment pas un _codeword_ valide en un autre _codeword_ valide. (voir #link(<hamming>)[Code de _Hamming_])
+  \
+
+  - Distance de Hamming : Nombre de positions où les bits diffèrent entre deux _codewords_.\
+    Exemple : $[1 space 0 space 1 space 0 space 0 space 1 space 1 space 0]$ et $[1 space 0 space 0 space 0 space 0 space 1 space 1 space 1]$ diffèrent aux positions 3 et 8 \
+    $=>$ Distance de Hamming = $2$.
+
+  - Distance minimale ($d_min$) : La plus petite distance de Hamming mesurée entre n'importe quelle paire de _codewords_ appartenant au code.
+
+  Un code avec une distance minimale $d_min$ peut garantir la détection de $t$ erreurs si et seulement si :
+  $
+    t < d_min
+  $
+
+  Exemple :\
+  Pour _Hamming_ (7,4) vu #link(<hamming>)[après], on a $d_min = 3$. \
+  $=>$ Il garantit la détection de 1 ou 2 erreurs ($t < 3$).\
+  $=>$ Si 3 bits (ou plus) s'inversent, le message peut correspondre à un autre _codeword_ valide. (Exemple 1.8 @mackay).
+
+  Pour corriger l'erreur, le décodeur cherche le _codeword_ le plus probable.\
+
+  Principe (_maximum-likelihood_ (ML) Decoder) : Il choisit le _codeword_ $s$ valide qui a la plus petite distance de Hamming avec le message reçu $r$. (Si égalité alors le choix est aléatoire).
+
+  $
+    hat(s) = min_(c in C) d_H (r, s)
+  $
+  Avec $C$ l'ensemble des _codewords_ valides.
+]
+
+#v(5pt)
+
+= Code de _Hamming_ <hamming>
+#pad(left: 1cm)[
+  But : Ajouter de la redondance à des bloques de données.\
+  _Block code_ : règle de conversion d'un sequence de bits *$s$* de longueur $K$ dans une séquencce *$t$* de $N$ bits. (Redondance $=>$ $N > K$). \
+  Dans un code linéaire les $N - K$ bits réstant sont linéaire en fonction des $K$ bits originaux, ce sont les _parity-check bits_.\
+  - _Hamming_ (7,4)
+  #pad(left: 1cm)[
+    L'encodage se visualise via 3 cercles sécants (Diagramme de Venn).
+    Les 7 bits sont placés de sorte que la parité de chaque cercle soit paire (somme = 0).
+
+    - Bits de Source ($s_1, s_2, s_3, s_4$) : Copiés directement dans le message transmis ($t_1..t_4$).
+    - Bits de Parité ($t_5, t_6, t_7$) : Calculés pour valider les cercles.
+
+    $
+      t_5 & = s_1 plus.o s_2 plus.o s_3 & "(Cercle 1)" \
+      t_6 & = s_2 plus.o s_3 plus.o s_4 & "(Cercle 2)" \
+      t_7 & = s_1 plus.o s_3 plus.o s_4 & "(Cercle 3)"
+    $
+
+    Le *Syndrome* *$z$* :
+    On vérifie la parité des cercles à l'arrivée.
+    - 1 cercle faux $->$ Erreur sur le bit de parité.
+    - 2 ou 3 cercles faux $->$ Erreur à l'intersection unique des cercles fautifs.
+  ]
+  On peut le voir sous forme de matrice.\
+  Message transmit *$t$* (_codeword_) :
+  $
+    t = G^T s
+  $
+
+  avec *$G$* la matrice génératrice du code.
+
+  // $
+  //   G^T = mat(
+  //     1, 0, 0, 0;
+  //     0, 1, 0, 0;
+  //     0, 0, 1, 0;
+  //     0, 0, 0, 1;
+  //     1, 1, 1, 0;
+  //     0, 1, 1, 1;
+  //     1, 0, 1, 1;
+  //     column-gap: #1.5em,
+  //   )
+  // $
+  Visualisation de la solution avec diagramme de Venn.\
+  Trouver $P$ tel que
+  $ G^T = mat(
+    I_n;
+    P;
+    row-gap: #0.75em
+  ) $ avec $z = H r$ et $H$ la mtrice _parity-check_ $H = mat(-P, I_(n-1)) = mat(P, I_(n-1))$ \
+  Et donc tous les _codewords_ satisfont $t = G^T s$,
+  $
+    H t = mat(
+      0;
+      0;
+      0;
+    )
+  $
+  Mais $r = G^T s + n$ on doit trouver *$n$* tel que $H n = z$. C'est le probleme _maximum-likelihood decoder_.
+
+  Voir exemple @mackay p9. | #link("https://www.youtube.com/watch?v=X8jsijhllIA")[3Blue1Brown Hamming codes]
+]
+
+
+= Low-density parity-check codes (LDPC) @johnson
+
+#pad(left: 1cm)[
+
+]
+
 
 #pagebreak()
 #bibliography("sources.yml", style: "ieee")