avancée+

<

@@ -0,0 +1,363 @@
+#import "composants.typ": *
+
+#set page(
+  paper: "presentation-4-3",
+  margin: 0cm,
+)
+
+// Font
+#set text(
+  font: "New Computer Modern",
+  size: 20pt,
+  fill: black,
+)
+#set math.mat(delim: "[")
+
+// Page de garde
+#slide[
+  #place(center + horizon)[
+    #graphe_tanner_fond(1cm, 1.5)
+  ]
+  #v(1fr)
+  #align(center + horizon)[
+    #pad(x: 2cm)[
+      #text(size: 3em, weight: "bold", fill: black)[#titre]
+
+      #text(size: 1.2em, weight: "bold", fill: black)[#auteur]
+
+      #h(0.5em)
+
+      #text(size: 1.2em, fill: black)[n°#numero]
+
+      #text(size: 0.95em, fill: black)[#annee]
+    ]
+  ]
+  #v(1fr)
+]
+
+#myslide("Plan")[
+  #design_plan((
+    [Introduction],
+    [Codes linéaires],
+    [LDPC],
+    [Codage],
+    [Décodage],
+    [Analyse],
+  ))
+]
+
+#myslide("Introduction : Communication Numérique")[
+  #place(center + horizon)[
+    #canal_shannon_intro()
+  ]
+]
+
+#myslide("Introduction : Utilisation")[
+  #align(center + horizon)[
+    #grid(
+      columns: (1.5fr, 1.5fr),
+      gutter: 1.5cm,
+      align: center + horizon,
+      [
+        #box(width: 80%)[
+          #stack(
+            dir: ttb,
+            spacing: -0.5em,
+            image("src/athena_fidus_no_text.jpg", width: 100%),
+            align(left)[
+              #box(
+                inset: (x: 5pt, y: 0pt),
+                text(size: 0.45em, fill: white)[* https://gallery.ariane.group *],
+              )
+            ],
+          )
+        ]
+        #v(0.5em)
+        Athena-Fidus
+      ],
+      [
+        #box(width: 80%)[
+          #stack(
+            dir: ttb,
+            spacing: -0.5em,
+            image("src/runcamfpv2.png", width: 100%),
+            align(left)[
+              #box(
+                inset: (x: 5pt, y: 0pt),
+                text(size: 0.45em, fill: white)[* https://www.runcam.com/ *],
+              )
+            ],
+          )
+        ]
+        #v(0.5em)
+        Module OpenIPC
+      ],
+    )
+  ]
+]
+
+#myslide("Problématique")[
+  #place(center + horizon, dy: 8.1cm)[#graphe_tanner_fond(0.9cm, 1.75)]
+  #place(center + horizon, dy: 7.7cm)[
+    #block(width: 100%)[
+      #text(size: 1.2em, weight: "bold", fill: black)[
+        Comment utiliser les codes LDPC pour garantir la fiabilité d'une transmission en présence de bruit ?
+      ]
+    ]
+  ]
+]
+
+#myslide("Définition : Codes Linéaires en Bloc")[
+  #definition(titre: [Code $display((n,k) in NN^2)$])[
+    $cal(C)$ sous-espace vectoriel de dimension $k$ de $FF_2^n$
+  ]
+
+  #[
+    #set text(size: 1.1em)
+    - $k$ : longueur du message original
+    - $n$ : longueur du mot de code
+    - $m = n - k$ : nombre de bits de parités
+  ]
+
+  #definition(titre: "Encodage")[
+    $Phi : FF_2^k & -> FF_2^n in cal(L)(FF_2^k, FF_2^n)$
+  ]
+
+  #v(-1.3em)
+
+  #uncover(2)[
+    #align(center + horizon)[
+      #plongement_schema()
+    ]
+  ]
+]
+
+#myslide("Définition : Matrice Génératrice")[
+  #definition(titre: "Matrice Génératrice")[
+    $G in cal(M)_(k,n)(FF_2)$ dont les lignes sont une base de $cal(C)$
+  ]
+
+  #definition(titre: "Encodage")[
+    Pour un message $u in FF_2^k$ le mot de code $c in cal(C)$ est :
+    $
+      c = Phi(u) = u dot.o G
+    $
+  ]
+
+  #definition(titre: "Forme systématique")[
+    $
+      G = mat(
+        I_k, P;
+        augment: #1,
+        delim: "[",
+      )
+    $
+  ]
+
+  #[
+    #set text(size: 1.2em)
+    - Pour $u in FF_2^k, space display(u dot.o G = mat(u, u dot.o P; augment: #1, delim: "[",))$
+
+    - $P in cal(M)_(k ,(n-k))(FF_2)$ matrice de parité\
+  ]
+]
+
+#myslide("Définition : Matrice de Contrôle")[
+  #definition(titre: "Matrice de Contrôle")[
+    $
+      H = mat(
+        P^top, I_(n-k);
+        augment: #1,
+        delim: "[",
+      )
+    $
+  ]
+  #[
+    #set text(size: 1.2em)
+    - $cal(C) = ker(H) = {v in FF_2^n | H dot.o v^top = 0}$
+
+    - $display(G dot.o H^top = 0)$
+  ]
+
+  #definition(titre: "Syndrome")[
+    Pour un vecteur reçu $r = c + e, space s in FF_2^(n - k)$
+    $
+      s = H r^top = H c^top + H e^top = 0 + H e^top
+    $
+  ]
+  #[
+    #set text(size: 1.2em)
+    - Si $s = 0, space r$ est un mot de code valide
+    - Sinon s donne la signature de l'erreur $e$
+  ]
+  // Possible décodage par syndrome
+]
+
+#myslide("Exemple d'un code linéaire")[
+  #[
+    #set text(size: 1.1em)
+    #let col-u = blue
+    #let col-p = orange
+
+
+    #underline(offset: 3pt)[Exemple d'un code $(5,2)$]
+
+
+    - On choisit la matrice de parité $P$ :
+    $
+      P = #math.mat(
+        (text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
+        (text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
+      )
+    $
+
+    - Alors la matrice génératrice $G$ est :
+    $
+      G = #math.mat(
+        (text(fill: col-u)[1], text(fill: col-u)[0], text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
+        (text(fill: col-u)[0], text(fill: col-u)[1], text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
+        augment: 2,
+      )
+    $
+
+    - Message $display(u = #math.mat((text(fill: col-u)[1], text(fill: col-u)[1])))$
+
+    - Mot de code $c = u G$ :
+    $
+      c = #math.mat((text(fill: col-u)[1], text(fill: col-u)[1]))
+      #math.mat(
+        (text(fill: col-u)[1], text(fill: col-u)[0], text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
+        (text(fill: col-u)[0], text(fill: col-u)[1], text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
+        augment: 2,
+      )
+      =
+      #math.mat((
+        text(fill: col-u)[1],
+        text(fill: col-u)[1],
+        text(fill: col-p)[1],
+        text(fill: col-p)[0],
+        text(fill: col-p)[1],
+      ))
+    $
+  ]
+]
+
+#myslide("Exemple d'une code linéaire")[
+  #[
+    #set math.mat(delim: "[")
+    #let colu = blue
+    #let colp = orange
+
+    #v(0.5em)
+
+    #set text(size: 1.1em)
+    Enfin
+
+    $
+      H = #math.mat(
+        (text(fill: colp)[1], text(fill: colp)[0], 1, 0, 0),
+        (text(fill: colp)[1], text(fill: colp)[1], 0, 1, 0),
+        (text(fill: colp)[0], text(fill: colp)[1], 0, 0, 1),
+        augment: 2,
+      )
+    $
+
+    #v(0.8em)
+
+    Vérification du mot de code $display(c = mat(#text(fill: colu)[1], #text(fill: colu)[1], #text(fill: colp)[1], #text(fill: colp)[0], #text(fill: colp)[1]))$
+
+    #v(0.8em)
+
+    $
+      H c^top = mat(
+        1, 0, 1, 0, 0;
+        1, 1, 0, 1, 0;
+        0, 1, 0, 0, 1
+      ) mat(#text(fill: colu)[1], #text(fill: colu)[1], #text(fill: colp)[1], #text(fill: colp)[0], #text(fill: colp)[1])^top
+      = mat(
+        1 plus.o 0 plus.o 1 plus.o 0 plus.o 0;
+        1 plus.o 1 plus.o 0 plus.o 0 plus.o 0;
+        0 plus.o 1 plus.o 0 plus.o 0 plus.o 1
+      )
+      = mat(0; 0; 0)
+    $
+  ]
+]
+
+// A REMPLACER AVEC DE VRAI DONNE SUR DE VRAI CODE LDPC ET HAMMING PAR EXEMPLE
+#myslide("Approcher la Limite de Shannon")[
+  #limite_shannon_graphique()
+
+]
+
+// #myslide("Redondance et limite théorique")[
+//   Graphique waterfall avec n = 100 et n = 64800 avec limite de Shannon, $display(R = k /n) < 1$, $m = n - k$
+//
+//   Bande passante...
+//
+//   Il existe $C$ pour un canal tel que pour $R < C$ on peut atteindre une probabilité d'erreur nulle.
+//   $=>$ gros bloc (moyenne du bruit aléatoire)
+// ]
+
+#myslide("Décodage par Maximum de Vraisemblance")[
+  Trouver le message envoyer le + probable sachant le message recu : NP-COMPLET (Max)
+  Decodage par syndrome d'une code lin'aire général est NP-Complet
+  Complexité $O(2^k)$
+]
+
+#myslide("LDPC")[
+  Matrice $H$ clairsemée(low density) donc complexité mointre, pas de produit de matrice mais algorithme itératif efficace quasi linéaire
+  Graphique d'un H très grand clairesemée avec plein de 0, généré en rust par exemple où les 1 sont des points noir et le reste du blanc
+  Défniition avec (w_r,w_c)
+]
+
+#myslide("Graphe de Tanner")[
+  Il existe un isomorphisme entre H et le Graphe de Tanner
+  Graphe de tanner (cetz)
+  Contrainte de somme nulle
+]
+
+#myslide("Encodage")[
+]
+
+#myslide("Décodage")[
+  Canal d'étude (AWGN) analogique, tension etc, ce qui se passe en radio dans les cables etc
+]
+
+#myslide("Hard decoding")[
+  Nul (0 ou 1)
+  transition perte d'information
+]
+
+#myslide("Implementation")[
+
+]
+
+#myslide("Soft decoding")[
+  belief propagation, log ou virgule fixe, explication resultat meilleur
+]
+
+#myslide("Implementation")[
+
+]
+
+#myslide("Test")[
+  Irl hackrf, test de diff de debit avec des paquets
+]
+
+#myslide("Image")[
+  Test de transmission d'image avec différent ldpc non opti et opti (le H)
+]
+
+#myslide("Annexe")[
+  #align(center + horizon)[
+    Annexe
+  ]
+  #align(center + horizon)[
+    #image("src/construction.jpg", width: 80%)
+  ]
+]
+
+#myslide("Théorie deriere la définition des codes linaires")[
+  Poser les notations algebriques etc...
+]

composants.typ

@@ -174,44 +174,117 @@
 }
 
 // Schema Shannon
+// #let canal_shannon_intro() = {
+//   cetz.canvas({
+//     import cetz.draw: *
+//
+//     // Styles
+//     let s = (stroke: 2pt + black)
+//     let s_fleche = (stroke: 2pt + black)
+//     let pointe_pleine = (end: "stealth", fill: black)
+//
+//     let espacement = 5.5
+//
+//     // Blocs
+//     content((0, 0), [Source], name: "src", frame: "rect", ..s, padding: .3)
+//     content((espacement, 0), [Emetteur], name: "em", frame: "rect", ..s, padding: .3)
+//     content((espacement * 2, 0), [Canal], name: "chan", frame: "rect", ..s, padding: .3)
+//     content((espacement * 3, 0), [Récepteur], name: "rec", frame: "rect", ..s, padding: .3)
+//     content((espacement * 4, 0), [Destinataire], name: "dest", frame: "rect", ..s, padding: .3)
+//
+//     // Bruit
+//     content((rel: (0, 1.8), to: "chan"), [Bruit], name: "bruit", frame: "rect", ..s, padding: .3)
+//
+//     // Codage / Décodage
+//     content((rel: (0, 1), to: "em"), [*Codage*])
+//     content((rel: (0, 1), to: "rec"), [*Décodage*])
+//
+//     // Flèches (On utilise s_fleche et pointe_pleine)
+//     line("src.east", "em.west", mark: pointe_pleine, ..s_fleche)
+//     line("em.east", "chan.west", mark: pointe_pleine, ..s_fleche)
+//     line("chan.east", "rec.west", mark: pointe_pleine, ..s_fleche)
+//     line("rec.east", "dest.west", mark: pointe_pleine, ..s_fleche)
+//     line("bruit.south", "chan.north", mark: pointe_pleine, ..s_fleche)
+//
+//     // Annotation
+//     let note-style = (size: 0.75em, style: "italic")
+//     content((espacement * 0.5, -0.5), text(..note-style)[Message])
+//     content((espacement * 1.5, -0.5), text(..note-style)[Signal])
+//     content((espacement * 2.5, -0.5), text(..note-style)[Signal])
+//     content((espacement * 3.5, -0.5), text(..note-style)[Message])
+//   })
+// }
+
 #let canal_shannon_intro() = {
-  cetz.canvas({
+  // Couleurs
+  let col-u = blue        // Signal propre
+  let col-p = orange      // Signal bruité
+  let C_MAIN = black      
+  let C_BG = rgb("#f8f9fa") // Le gris très clair demandé
+  let C_LABEL = black     
+
+  cetz.canvas(length: 1cm, {
     import cetz.draw: *
 
-    // Styles
+    let x_left = 4.0 ; let x_right = 16.0 ; let x_noise = 22.5
-    let s = (stroke: 2pt + black)
+    let y_top = 14.5 ; let y_mid = 9.0 ; let y_bot = 3.5
-    let s_fleche = (stroke: 2pt + black)
-    let pointe_pleine = (end: "stealth", fill: black)
 
-    let espacement = 5.5
+    // Style des lignes avec flèches
+    let s_ligne = (stroke: 1.5pt + C_MAIN, mark: (end: "stealth", fill: C_MAIN, size: 0.25))
+    let s_bruit_fleche = (stroke: (paint: black, thickness: 1.5pt, dash: "dashed"), mark: (end: "stealth", fill: black, size: 0.25))
 
-    // Blocs
+    // Fonction de bloc avec le nouveau fond
-    content((0, 0), [Source], name: "src", frame: "rect", ..s, padding: .3)
+    let bloc(pos, txt, stxt, n) = {
-    content((espacement, 0), [Emetteur], name: "em", frame: "rect", ..s, padding: .3)
+      content(pos, [#set align(center); #text(C_MAIN, weight: "bold", size: 1.2em)[#txt] \ #text(C_MAIN, size: 0.85em, style: "italic")[#stxt]], 
-    content((espacement * 2, 0), [Canal], name: "chan", frame: "rect", ..s, padding: .3)
+      frame: "rect", fill: C_BG, stroke: C_MAIN + 1.5pt, padding: 0.7, radius: 0.3, name: n)
-    content((espacement * 3, 0), [Récepteur], name: "rec", frame: "rect", ..s, padding: .3)
+    }
-    content((espacement * 4, 0), [Destinataire], name: "dest", frame: "rect", ..s, padding: .3)
 
-    // Bruit
+    // --- ONDES (Bruit dosé : "tremblement" au lieu de "chaos") ---
-    content((rel: (0, 1.8), to: "chan"), [Bruit], name: "bruit", frame: "rect", ..s, padding: .3)
+    let wave_vert(x, y_start, y_end, is_noisy) = {
+      let n_points = 200 
+      let color = if is_noisy { col-p } else { col-u }
+      
+      line(..range(n_points + 1).map(i => {
+        let t = i / n_points
+        let y = y_start + t * (y_end - y_start)
+        
+        // Enveloppe pour raccord propre
+        let env = if t < 0.05 { t/0.05 } else if t > 0.95 { (1-t)/0.05 } else { 1.0 }
+        
+        let signal = 0.35 * calc.sin(t * 6 * calc.pi)
+        
+        // Bruit dosé : on a baissé les fréquences et l'amplitude
+        let bruit = if is_noisy { 
+          (0.08 * calc.sin(t * 45 * calc.pi) + 0.05 * calc.cos(t * 97 * calc.pi))
+        } else { 0 }
+        
+        (x + (signal + bruit) * env, y)
+      }), stroke: color + 1.6pt)
+    }
 
-    // Codage / Décodage
+    wave_vert(x_right, y_top - 1.5, y_mid + 1, false) // Bleu 
-    content((rel: (0, 1), to: "em"), [*Codage*])
+    wave_vert(x_right, y_mid - 1, y_bot + 1.5, true)  // Orange
-    content((rel: (0, 1), to: "rec"), [*Décodage*])
 
-    // Flèches (On utilise s_fleche et pointe_pleine)
+    // --- BLOCS ---
-    line("src.east", "em.west", mark: pointe_pleine, ..s_fleche)
+    bloc((x_left, y_top), "Source", "Information", "src")
-    line("em.east", "chan.west", mark: pointe_pleine, ..s_fleche)
+    bloc((x_right, y_top), "Émetteur", "Codage", "em")
-    line("chan.east", "rec.west", mark: pointe_pleine, ..s_fleche)
+    bloc((x_right, y_mid), "Canal", "", "canal") 
-    line("rec.east", "dest.west", mark: pointe_pleine, ..s_fleche)
+    bloc((x_noise, y_mid), "Bruit", "", "bruit")
-    line("bruit.south", "chan.north", mark: pointe_pleine, ..s_fleche)
+    bloc((x_right, y_bot), "Récepteur", "Décodage", "rec")
+    bloc((x_left, y_bot), "Destinataire", "Information", "dest")
 
-    // Annotation
+    // --- CONNEXIONS ---
-    let note-style = (size: 0.75em, style: "italic")
+    line("src.east", "em.west", ..s_ligne)
-    content((espacement * 0.5, -0.5), text(..note-style)[Message])
+    line("bruit.west", "canal.east", ..s_bruit_fleche) 
-    content((espacement * 1.5, -0.5), text(..note-style)[Signal])
+    line("rec.west", "dest.east", ..s_ligne)
-    content((espacement * 2.5, -0.5), text(..note-style)[Signal])
+
-    content((espacement * 3.5, -0.5), text(..note-style)[Message])
+    // --- ANNOTATIONS ---
+    let lab(pos, body, color: C_LABEL, anchor: "center") = content(pos, text(size: 0.95em, fill: color, style: "italic", weight: "medium")[#body], anchor: anchor)
+
+    lab(((x_left + x_right)/2 - 0.3, y_top + 0.7), "Message")
+    lab((x_right + 1.2, (y_top + y_mid)/2), "Signal", color: col-u, anchor: "west")
+    lab((x_right + 1.2, (y_mid + y_bot)/2), "Signal + Bruit", color: col-p, anchor: "west")
+    lab(((x_left + x_right)/2 + 0.3, y_bot - 0.7), "Message reçu")
   })
 }
 
@@ -500,3 +573,199 @@
   ]
 }
 
+#let decor_matrice_etoilee() = {
+  // Ajuste length (ex: 0.6mm ou 0.7mm) selon ta diapo
+  cetz.canvas(length: 0.7mm, {
+    import cetz.draw: *
+
+    // --- 1. Paramètres de la Matrice ---
+    let nx = 430         
+    let ny = 265         
+    
+    // --- 2. Paramètres de la Loupe ---
+    let loupe_x = nx * 0.70  
+    let loupe_y = -ny / 2.0  
+    let R = 50.0         
+    let zoom = 3.0       
+
+    // --- 3. Paramètre d'Estompage (Gauche uniquement) ---
+    let fade_left = 220.0   
+
+    // Palette de couleurs
+    let col_focus = rgb("#0284c7")
+    let col_fade = rgb("#64748b")
+    let col_grid = rgb("#e2e8f0")
+
+    // --- Fonction pseudo-aléatoire ---
+    let pseudo_rand(x, y) = {
+      let v = x * 7919 + y * 104729 + (x * x) * 313 + (y * y) * 991 + (x * y) * 101
+      calc.rem(calc.abs(v), 100)
+    }
+
+    // --- ÉTAPE A : Dessin de la matrice (Fade à gauche uniquement) ---
+    for x in range(nx) {
+      for y in range(ny) {
+        let hash = pseudo_rand(x, y)
+        let is_active = hash < 12 
+
+        if is_active {
+          // L'intensité ne dépend plus que de la position X
+          let intensity = calc.min(1.0, x / fade_left)
+
+          if intensity > 0.05 { 
+            let radius = 0.20 + 0.15 * intensity 
+            let c = col_fade.lighten((1.0 - intensity) * 80%)
+            circle((x, -y), radius: radius, fill: c, stroke: none)
+          }
+        }
+      }
+    }
+
+    // --- ÉTAPE B : Dessin de la Loupe ---
+    circle((loupe_x, loupe_y), radius: R, fill: white, stroke: none)
+
+    // Grille zoomée
+    let limit = 20 
+    for k in range(-limit, limit + 1) {
+      let offset = k * zoom
+      if calc.abs(offset) < R {
+        let half_chord = calc.sqrt(R * R - offset * offset)
+        line((loupe_x + offset, loupe_y + half_chord), (loupe_x + offset, loupe_y - half_chord), stroke: 0.5pt + col_grid)
+        line((loupe_x - half_chord, loupe_y + offset), (loupe_x + half_chord, loupe_y + offset), stroke: 0.5pt + col_grid)
+      }
+    }
+
+    // Points zoomés 
+    let search_r = int(R / zoom) + 2 
+    let lx_int = int(loupe_x)
+    let ly_idx = int(-loupe_y) 
+
+    for x in range(lx_int - search_r, lx_int + search_r + 1) {
+      for y in range(ly_idx - search_r, ly_idx + search_r + 1) {
+        let hash = pseudo_rand(x, y)
+        if hash < 12 { 
+          let dx = x - loupe_x
+          let dy = -y - loupe_y 
+          let d_orig = calc.sqrt(dx * dx + dy * dy)
+          let d_zoom = d_orig * zoom
+
+          if d_zoom <= R - 1.2 {
+            circle((loupe_x + dx * zoom, loupe_y + dy * zoom), radius: 1.1, fill: col_focus, stroke: none)
+          }
+        }
+      }
+    }
+
+    // Bordures de la Loupe
+    circle((loupe_x, loupe_y), radius: R, stroke: 1.8pt + col_focus.lighten(20%))
+    circle((loupe_x, loupe_y), radius: R + 1.5, stroke: 1.0pt + col_focus.lighten(50%))
+    circle((loupe_x, loupe_y), radius: R + 3.5, stroke: 0.5pt + col_focus.lighten(80%))
+  })
+}
+
+#let hldpc() = {
+  import cetz.draw: *
+  
+  let points = (
+    (7,0), (10,0), (15,0), (22,0), (24,0), (29,0), (3,1), (6,1), (18,1), (19,1), (25,1), (27,1),
+    (5,2), (9,2), (13,2), (14,2), (17,2), (28,2), (0,3), (8,3), (11,3), (16,3), (20,3), (26,3),
+    (1,4), (2,4), (4,4), (12,4), (21,4), (23,4), (5,5), (6,5), (8,5), (10,5), (21,5), (29,5),
+    (14,6), (15,6), (16,6), (18,6), (22,6), (28,6), (0,7), (1,7), (4,7), (9,7), (20,7), (26,7),
+    (2,8), (3,8), (11,8), (12,8), (17,8), (19,8), (7,9), (13,9), (23,9), (24,9), (25,9), (27,9),
+    (0,10), (6,10), (15,10), (18,10), (21,10), (26,10), (2,11), (7,11), (10,11), (17,11), (22,11), (27,11),
+    (8,12), (11,12), (14,12), (20,12), (23,12), (29,12), (4,13), (5,13), (9,13), (13,13), (16,13), (19,13),
+    (1,14), (3,14), (12,14), (24,14), (25,14), (28,14)
+  )
+
+  cetz.canvas(length: 0.45cm, {
+    let nx = 30
+    let ny = 15
+    let cell_size = 1.0
+    let h_width = nx * cell_size
+    let h_height = ny * cell_size
+    
+    // Palette unifiée
+    let color_blue = blue
+    let color_orange = orange
+    let col_dot_base = gray.darken(30%)
+    
+    // Définition des couleurs de fond (lighten)
+    let col_row_bg = color_blue.lighten(90%)
+    let col_col_bg = color_orange.lighten(90%)
+    // Calcul du mélange pour l'intersection
+    let col_mix_bg = col_row_bg.mix(col_col_bg)
+    
+    // Label "H ="
+    content((-3.4, -h_height / 2), text(size: 1.6em, weight: "bold")[$bold(H) = $])
+
+    // Sélection visuelle (Focus)
+    let sel_row = 7
+    let sel_col = 10 
+
+    // Rectangles de fond
+    rect((0, -sel_row), (h_width, -sel_row - 1), fill: col_row_bg, stroke: none)
+    rect((sel_col, 0), (sel_col + 1, -h_height), fill: col_col_bg, stroke: none)
+    rect((sel_col, -sel_row), (sel_col + 1, -sel_row - 1), fill: col_mix_bg, stroke: none)
+
+    // Grands crochets matriciels
+    let b_w = 0.6
+    set-style(stroke: (thickness: 1.5pt, cap: "round"))
+    line((b_w, 0.3), (0, 0.3), (0, -h_height - 0.3), (b_w, -h_height - 0.3))
+    line((h_width - b_w, 0.3), (h_width, 0.3), (h_width, -h_height - 0.3), (h_width - b_w, -h_height - 0.3))
+
+    // Dessin des points
+    for (x, y) in points {
+      let px = x + 0.5
+      let py = -y - 0.5
+      
+      let is_row = (y == sel_row)
+      let is_col = (x == sel_col)
+      
+      let d_col = col_dot_base
+      let r = 0.16
+      
+      if is_row {
+        d_col = color_blue
+        r = 0.24
+      } else if is_col {
+        d_col = color_orange
+        r = 0.24
+      }
+
+      circle((px, py), radius: r, fill: d_col, stroke: none)
+    }
+
+    // 5. Légendes w_r et w_c
+    content((h_width + 0.5, -sel_row - 0.5), anchor: "west", text(fill: color_blue, weight: "bold", size: 1.1em)[$w_r = 6$])
+    content((sel_col + 0.5, 0.8), anchor: "south", text(fill: color_orange, weight: "bold", size: 1.1em)[$w_c = 3$])
+  })
+}
+
+#let hldpc_dual(row1: 0, row2: 14) = {
+  import cetz.draw: *
+  let points = ((7,0), (10,0), (15,0), (22,0), (24,0), (29,0), (3,1), (6,1), (18,1), (19,1), (25,1), (27,1), (5,2), (9,2), (13,2), (14,2), (17,2), (28,2), (0,3), (8,3), (11,3), (16,3), (20,3), (26,3), (1,4), (2,4), (4,4), (12,4), (21,4), (23,4), (5,5), (6,5), (8,5), (10,5), (21,5), (29,5), (14,6), (15,6), (16,6), (18,6), (22,6), (28,6), (0,7), (1,7), (4,7), (9,7), (20,7), (26,7), (2,8), (3,8), (11,8), (12,8), (17,8), (19,8), (7,9), (13,9), (23,9), (24,9), (25,9), (27,9), (0,10), (6,10), (15,10), (18,10), (21,10), (26,10), (2,11), (7,11), (10,11), (17,11), (22,11), (27,11), (8,12), (11,12), (14,12), (20,12), (23,12), (29,12), (4,13), (5,13), (9,13), (13,13), (16,13), (19,13), (1,14), (3,14), (12,14), (24,14), (25,14), (28,14))
+
+  cetz.canvas(length: 0.35cm, {
+    let nx = 30; let ny = 15
+    let col_1 = orange; let col_2 = blue
+    
+    content((-3.4, -7.5), text(size: 1.6em )[$H = $])
+
+    // Fonds de lignes
+    rect((0, -row1), (nx, -row1 - 1), fill: col_1.lighten(90%), stroke: none)
+    if row2 != none { rect((0, -row2), (nx, -row2 - 1), fill: col_2.lighten(90%), stroke: none) }
+
+    // Crochets
+    set-style(stroke: (thickness: 1.2pt))
+    line((0.5, 0.3), (0, 0.3), (0, -ny - 0.3), (0.5, -ny - 0.3))
+    line((nx - 0.5, 0.3), (nx, 0.3), (nx, -ny - 0.3), (nx - 0.5, -ny - 0.3))
+
+    for (x, y) in points {
+      let d_col = gray.darken(30%)
+      let r = 0.15
+      if y == row1 { d_col = col_1; r = 0.22 }
+      else if y == row2 { d_col = col_2; r = 0.22 }
+      circle((x + 0.5, -y - 0.5), radius: r, fill: d_col, stroke: none)
+    }
+  })
+}

main.typ

@@ -35,19 +35,20 @@
   #v(1fr)
 ]
 
-#myslide("Plan")[
+#myslide("Plan")[                                                     
-  #design_plan((
+  #grid(                                                              
-    [Introduction],
+    columns: (auto, 1fr),                                             
-    [Codes linéaires],
+    align: horizon,                                                   
-    [LDPC],
+    place(center + horizon, dx: 11.8cm, dy: 0.7cm)[#decor_matrice_etoilee()],                       
-    [Codage],
+    design_plan((                                                     
-    [Décodage],
+      [Introduction], [Codes linéaires], [LDPC],                     
-    [Analyse],
+      [Codage], [Décodage], [Analyse],                               
-  ))
+    ))                                                               
-]
+  )                                                                   
+] 
 
-#myslide("Introduction : Transmission Numérique")[
+#myslide("Introduction : Communication Numérique")[
-  #align(center + horizon)[
+  #place(center + horizon, dy: 8cm)[
     #canal_shannon_intro()
   ]
 ]
@@ -132,7 +133,7 @@
   ]
 ]
 
-#myslide("Définition: Matrice Génératrice")[
+#myslide("Définition : Matrice Génératrice")[
   #definition(titre: "Matrice Génératrice")[
     $G in cal(M)_(k,n)(FF_2)$ dont les lignes sont une base de $cal(C)$
   ]
@@ -162,7 +163,7 @@
   ]
 ]
 
-#myslide("Défniition: Matrice de Contrôle")[
+#myslide("Définition : Matrice de Contrôle")[
   #definition(titre: "Matrice de Contrôle")[
     $
       H = mat(
@@ -199,7 +200,6 @@
     #let col-u = blue
     #let col-p = orange
 
-
     #underline(offset: 3pt)[Exemple d'un code $(5,2)$]
 
 
@@ -248,8 +248,7 @@
     #let colu = blue
     #let colp = orange
 
-    #v(0.5em)
+    #place(dx: 0cm, dy: 2.0cm)[
-
     #set text(size: 1.1em)
     Enfin
 
@@ -283,11 +282,11 @@
     $
   ]
 ]
+]
 
 // A REMPLACER AVEC DE VRAI DONNE SUR DE VRAI CODE LDPC ET HAMMING PAR EXEMPLE
 #myslide("Approcher la Limite de Shannon")[
   #limite_shannon_graphique()
-
 ]
 
 // #myslide("Redondance et limite théorique")[
@@ -299,16 +298,136 @@
 //   $=>$ gros bloc (moyenne du bruit aléatoire)
 // ]
 
-#myslide("Décodage par Maximum de Vraisemblance")[
+#myslide("Le Mur de la Complexité")[
-  Trouver le message envoyer le + probable sachant le message recu : NP-COMPLET (Max)
+  #set text(size: 19pt)
-  Decodage par syndrome d'une code lin'aire général est NP-Complet
+      #definition(titre: [Décodage par Maximum de Vraisemblance (MDL)], accent: black)[
-  Complexité $O(2^k)$
+        Chercher le mot de code $bold(c) in cal(C)$ le plus probable sachant $bold(r)$ reçu :
+        $ hat(bold(c)) = arg min_(bold(c) in cal(C)) d_H (bold(r), bold(c)) $
+      ]
+
+      - Équivalent à chercher l'erreur $bold(e)$ de poids minimal tel que $bold(H) bold(e)^top = bold(s)$.
+      
+      #v(0.5em)
+
+      #definition(titre: "Le Problème du décodage par Syndrome")[
+        NP-Difficile et pour $H$ quelconque : $cal(O)(2^k)$
+      ]
+
+      - Pour $k=100$ bits, $2^100 approx 10^30$ opérations nécessaires.
 ]
 
-#myslide("LDPC")[
+#myslide("Définition des Codes LDPC")[
-  Matrice $H$ clairsemée(low density) donc complexité mointre, pas de produit de matrice mais algorithme itératif efficace quasi linéaire
+      #definition(titre: [Formalisation des Codes LDPC Réguliers])[
-  Graphique d'un H très grand clairesemée avec plein de 0, généré en rust par exemple où les 1 sont des points noir et le reste du blanc
+        Code linéaire en bloc avec une matrice de contrôle $bold(H)$ est *clairsemée*.
-  Défniition avec (w_r,w_c)
+      ]
+
+      - *Poids de Colonne $w_c$*
+      
+      - *Poids de Ligne $w_r$* 
+
+      #v(0.5em)
+
+      #definition(titre: "Conditions de Faible Densité", accent: black)[
+        #set align(center)
+        $w_c << n - k $ #h(2cm) $w_r << n$
+      ]
+
+      #definition(titre : "Rendement")[
+        $ display(R = (n - op("rg")(H)) / n >= 1 - m / n) $
+      ]
+  ]
+
+  #myslide([Matrice de contrôle])[
+  #definition(titre : [Code LDPC $(6, 3)$])[
+    $m w_r = n w_c$ donc $H in cal(M)_(15, 30)(FF_2)$ et $display(R = 1 - m / n = 1/2)$
+  ]
+
+  #v(2cm)
+
+  #place(center + horizon, dx: 0cm, dy: 7.3cm)[
+  #scale(140%)[#hldpc()] 
+  ]
+]
+
+#myslide("De la Matrice aux Équations de Parité")[
+  #set text(size: 17pt) 
+
+  #let v_space = 2.83cm
+
+  #align(center)[
+    #scale(115%)[
+      #grid(
+        columns: (auto, auto),
+        gutter: -15pt,
+        align: horizon,
+        [#hldpc_dual(row1: 0, row2: none)],
+        [
+          // #set math.mat(gap: 24.5pt)
+          #move(dy: 13.8pt)[
+          $ underbrace(
+            mat(r_0; r_1;#v(v_space);dots.v; r_29; delim: "["), 
+            #text()[Mot reçu] r space in space FF_2^30
+          ) $
+        ]
+        ]
+      )
+    ]
+  ]
+
+  #v(0.5cm)
+
+  #set text(size: 1.1em)
+
+  - Chaque ligne $j$ de $H$ définit une équation de parité $f_j$.
+  - Pour $r$, on vérifie le syndrome : $H r^top = 0$.
+
+  #v(0.2cm)
+
+  #definition(titre: [Équations de Parité], accent: orange)[
+    #set text(size: 1em)
+    #text(fill: orange)[$ f_0 : r_7 plus.o r_10 plus.o r_15 plus.o r_22 plus.o r_24 plus.o r_29 = 0 $]
+  ]
+  
+  #v(0.3cm)
+  #text(size: 1.1em)[- Si $f_j = 1$, un nombre impair de bits a été inversé par le canal.]
+]
+
+#myslide("L'Entrelacement des Contraintes")[
+  #set text(size: 17pt)
+
+#align(center)[
+  #move(dx: -1.2cm)[
+    #scale(115%)[#hldpc_dual(row1: 0, row2: 14)]
+  ]
+]
+
+  #v(1cm)
+
+    #set text(size: 1.1em)
+    - Chaque bit $r_i$ participe à $w_c = 3$ équations distinctes
+
+  #v(1cm)
+
+  // --- Étage 2 : Système et Décision ---
+  #set align(center + horizon)
+  #scale(115%)[
+      #block(fill: gray.lighten(95%), inset: 10pt, stroke: 0.5pt + gray, radius: 4pt)[
+        $ cases(
+          #text(fill: orange)[$r_7 plus.o r_10 plus.o r_15 plus.o r_22 plus.o bold(r_24) plus.o r_29 &= 0$],
+
+          #h(4.5cm) #text(size : 20pt)[$bold(dots.v)$],
+
+          #text(fill: blue)[$r_1 plus.o r_3 plus.o r_12 plus.o bold(r_24) plus.o r_25 plus.o r_28 &= 0$]
+        ) $
+      ]
+    ]
+
+    #v(1cm)
+
+  #set align(left)
+  #set text(size: 1.1em)
+  - *$r_24$* : Surveillé par #text(fill: orange)[$f_0$] et #text(fill: blue)[$f_14$].
+  - Si #text(fill: orange)[$f_0 = 1$] et #text(fill: blue)[$f_14 = 1$], $r_24$ est suspect
 ]
 
 #myslide("Graphe de Tanner")[
@@ -361,3 +480,13 @@
 #myslide("Théorie deriere la définition des codes linaires")[
   Poser les notations algebriques etc...
 ]
+
+#myslide("Decodage par maximum de vraisemblance")[
+  Expliquer, quelle distance ? etc
+]
+
+#myslide("Code LDPC non régulier")[
+
+]
+
+