girth

main.typ

@@ -150,6 +150,7 @@
   ]
 
   #definition(titre: "Forme systématique")[
+    // TODO : changer [I_k | P] en un graphique jolie avec I et P dans un carré coloré
     $
       G = mat(
         I_k, P;
@@ -496,7 +497,7 @@
 
   #align(center)[
     #scale(180%)[
-      #tanner_canvas(colored: false)
+      #tanner_canvas(colored: true)
     ]
   ]
 
@@ -617,8 +618,163 @@
   ]
 ]
 
-#myslide("Graphe de Tanner")[
-  AJOUTER UNE SLIDE SUR LA CONTRAINE DE SOMME NUL POUR UNE MOT DE CODE VALIDE !
+#let mot_valide = (
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+)
+
+#myslide("La Contrainte de Somme Nulle")[
+  #set text(size: 18pt)
+
+  #definition(titre: "Vision Graphe", accent: green)[
+    Si $s = 0$ alors que chaque nœud de contrôle est localement satisfait
+  ]
+
+  #v(1cm)
+
+  #align(center)[
+    #scale(150%)[
+      #tanner_status(
+        scale: 0.55cm,
+        v_values: mot_valide,
+        hl_v: (),
+      )
+    ]
+  ]
+
+  #v(1.2cm)
+
+  #set text(size: 20pt)
+  #align(center + horizon)[
+    Chaque #icon_chk calcule le xor de ses voisins #icon_var : $space display(f_i = xor.big_(j in cal(N)(c_i)) v_j)$
+  ]
+
+  #v(1em)
+  #align(center)[
+    #move(dy: -10pt)[
+      #scale(150%)[
+        #zoom_contrainte(is_ok: true)
+      ]
+    ]
+  ]
+
+  // #v(1em)
+  // #block(inset: 10pt, fill: rgb("#f0fdf4"), stroke: 1pt + rgb("#22c55e"), radius: 5pt)[
+  //   Toutes les équations de parité sont vérifiées simultanément.
+  // ]
+]
+
+#myslide("?")[
+  #set text(size: 18pt)
+
+  #definition(titre: "Détection d'Erreur", accent: red)[
+    Si un bit est inversé, toutes les contraintes associées sont à $1$
+  ]
+
+  #v(1cm)
+
+  #align(center)[
+    #let idx_erreur = 10
+    #let mot_erronne = mot_valide.enumerate().map(p => if p.first() == idx_erreur { 1 } else { p.last() })
+    #scale(150%)[
+      #tanner_status(
+        scale: 0.55cm,
+        v_values: mot_erronne,
+        hl_v: (idx_erreur,),
+        highlight_edges: true,
+      )
+    ]
+  ]
+
+  #v(1.3cm)
+
+  #align(center)[
+    $0 plus.o bold(1) plus.o 0 = bold(1) arrow$ *Erreur détectée*
+  ]
+
+  #v(1em)
+  #align(center)[
+    #move(dy: 11.5pt)[
+      #scale(150%)[
+        #zoom_contrainte(is_ok: false)
+      ]
+    ]
+  ]
+
+  // #block(inset: 10pt, fill: rgb("#fef2f2"), stroke: 1pt + red, radius: 5pt)[
+  //   *Principe du décodage :*
+  //   Le bit $v_{10}$ est relié à *plusieurs alarmes* (arêtes rouges au premier plan). Il est le suspect idéal pour une correction par "bit-flipping".
+  // ]
+]
+
+#myslide("La Topologie de H : Le Girth")[
+  #set text(size: 18pt)
+
+  #definition(titre: "Définition : Le Girth (La Maille)", accent: blue)[
+    Longueur du plus court cycle dans le graphe de Tanner
+  ]
+
+  #v(0.5em)
+
+  - Le girth est *pair*
+  - La valeur minimale est $g = 4$.
+
+  #v(1em)
+
+  #align(center)[
+    #block(fill: rgb("#f8fafc"), stroke: 1pt + blue.lighten(50%), inset: 10pt, radius: 5pt)[
+      Girth élevé $=>$ Meilleure diffusion de l'information.
+    ]
+  ]
+
+  #v(2.5em)
+
+  #align(center)[
+    #scale(140%)[
+      #grid(
+        columns: (1fr, 1fr),
+        gutter: -7cm,
+        [
+          #schema_girth_4(highlight: false)
+          #v(0.5em)
+          #text(size: 0.8em, style: "italic")[Graphe de Tanner]
+        ],
+        [
+          #schema_girth_4(highlight: true)
+          #v(0.5em)
+          #text(size: 0.8em, fill: red, weight: "bold")[4-Cycle]
+        ],
+      )
+    ]
+  ]
 ]
 
 #myslide("Encodage")[
@@ -721,3 +877,44 @@
 //     ],
 //   )
 // ]
+
+
+
+#myslide("tt")[
+  f
+]
+
+// --- SLIDE 2 : DANGER ET SOLUTIONS (À placer plus tard) ---
+//
+// #myslide("Cycles courts : Danger et Solutions")[
+//   #set text(size: 18pt)
+//
+//   #grid(
+//     columns: (1fr, 1fr),
+//     gutter: 1.5cm,
+//     [
+//       #text(weight: "bold", fill: red, size: 1.1em)[1. Le Danger : L'Effet d'Écho]
+//       #v(1em)
+//
+//       #align(center)[#echo_chamber()]
+//
+//       #v(1em)
+//       *Conséquences sur le décodage :*
+//       - Une information erronée se renforce elle-même en tournant dans le cycle.
+//       - Empêche la convergence de l'algorithme.
+//       - Crée un *Error Floor* (plancher d'erreur) impossible à dépasser.
+//     ],
+//     [
+//       #text(weight: "bold", fill: green, size: 1.1em)[2. La Solution : Algorithme PEG]
+//       #v(1em)
+//
+//       #align(center)[#peg_concept()]
+//
+//       #v(1em)
+//       *Progressive Edge-Growth :*
+//       - Algorithme de construction de $bold(H)$ "bord à bord".
+//       - On connecte chaque nouveau nœud au point le plus *distant* du graphe existant.
+//       - *Résultat :* On "casse" les cycles courts et on maximise le Girth.
+//     ],
+//   )
+// ]