annexes

main.typ

@@ -1,4 +1,6 @@
 #import "composants.typ": *
+#import "@preview/touying:0.5.2": *
+#import "code_slides.typ": generer_slides_code
 
 #set page(
   paper: "presentation-4-3",
@@ -1460,12 +1462,15 @@
 #[]<fin>
 
 #myslide("Annexe")[
+  #v(6.5cm)
   #align(center + horizon)[
-    Annexe
-  ]
-  #align(center + horizon)[
-    #image("src/construction.jpg", width: 80%)
+    #text(size: 100pt)[
+      Annexe
+    ]
   ]
+  // #align(center + horizon)[
+  //   #image("src/construction.jpg", width: 80%)
+  // ]
 ]
 
 // #myslide("Définition : Matrice Génératrice")[
@@ -1545,20 +1550,371 @@
   Poser les notations algebriques etc...
 ]
 
-#myslide("Définition du BER et SFR")[
+#myslide("Métriques : BER et FER")[
+  #set text(size: 18pt)
 
+  #definition(titre: "Bit Error Rate (BER)", accent: blue)[
+    $
+      "BER" = frac("Nombre de bits incorrects reçus", "Nombre total de bits transmis")
+    $
+  ]
+
+  #v(0.6em)
+
+  #definition(titre: "Frame Error Rate (FER)", accent: orange)[
+    $
+      "FER" = frac("Nombre de trames avec au moins 1 bit incorrect", "Nombre total de trames")
+    $
+  ]
+
+  #v(0.6em)
+
+  #grid(
+    columns: (1fr, 1fr),
+    gutter: 0.8em,
+    block(fill: blue.lighten(90%), stroke: 0.5pt + blue.lighten(30%), inset: 10pt, radius: 4pt)[
+      *Courbe Waterfall* : BER en fonction de $E_b \/ N_0$ (dB) — représente les performances
+    ],
+    block(fill: orange.lighten(90%), stroke: 0.5pt + orange.lighten(30%), inset: 10pt, radius: 4pt)[
+      FER $>=$ BER \
+      Une seule erreur de bit invalide toute la trame
+    ],
+  )
+
+  #v(0.5em)
+
+  // - *Monte-Carlo* : simuler un grand nombre de transmissions, collecter ~1000 erreurs par point
+  - $E_b\/N_0$ en dB $= 10 log_10 (E_b\/N_0)$
 ]
 
-#myslide("Decodage par maximum de vraisemblance")[
-  Expliquer, quelle distance ? etc
+#myslide("Décodage par Maximum de Vraisemblance (ML)")[
+  #set text(size: 17pt)
+
+  #definition(titre: "Décodeur ML — Canal AWGN + BPSK")[
+    $
+      hat(bold(c)) = arg max_(bold(c) in cal(C)) P(bold(r) | bold(c)) = arg min_(bold(c) in cal(C)) d_H (bold(r), bold(c))
+    $
+    Minimiser la distance de Hamming au mot de code le plus proche.
+  ]
+
+  #v(0.5em)
+
+  #definition(titre: "Décodage par Syndrome (Cosets)")[
+    - Calculer $bold(s) = bold(H) bold(r)^top$
+    - Chercher $bold(e)$ de poids minimal tel que $bold(H) bold(e)^top = bold(s)$
+    - Table préalculée de $2^(n-k)$ entrées $-->$ faisable seulement si $n - k$ petit
+  ]
+
+  #v(0.5em)
+
+  #definition(titre: "Complexité — NP-Difficile (Berlekamp, 1978)", accent: red)[
+    Pour $bold(H)$ quelconque : $cal(O)(2^k)$ candidats à tester.
+
+    - $k = 648$ : $2^(648) approx 10^(195)$ — hors de portée
+    - Solution : exploiter la *structure creuse* de $bold(H)$ $-->$ BP itératif
+  ]
 ]
 
-#myslide("Code LDPC non régulier")[
+#myslide("Codes LDPC Irréguliers")[
+  #set text(size: 17pt)
 
+  #definition(titre: "Distribution de Degrés (polynômes sur les arêtes)")[
+    $
+      lambda(x) = sum_i lambda_i x^(i-1), quad rho(x) = sum_j rho_j x^(j-1)
+    $
+    $lambda_i$ = fraction d'*arêtes* reliées à des VN de degré $i$, idem pour $rho_j$ et les CN.
+  ]
+
+  #v(0.5em)
+
+  #grid(
+    columns: (1fr, 1fr),
+    gutter: 0.8em,
+    definition(titre: "Avantages", accent: green.darken(10%))[
+      - Approchent la limite de Shannon de plus près
+      - VN de degré 2 : accélèrent la convergence initiale du BP
+    ],
+    definition(titre: "Optimisation", accent: orange)[
+      *Density Evolution* : calcule analytiquement le seuil de décodage en fonction de $(lambda, rho)$ $->$ optimiser numériquement
+    ],
+  )
+
+  #v(0.5em)
+
+  - Contrainte : $n sum_i lambda_i \/ i = |E| = m sum_j rho_j \/ j$
+  - DVB-S2 ($n = 64800$) : degrés variables entre 2 et 13 selon le rendement cible
 ]
 
-#myslide("Richardson-Urbanke")[
+#myslide("Encodage Efficace : Richardson-Urbanke")[
+  #set text(size: 17pt)
 
+  *Problème :* Forme systématique $->$ $bold(G)$ dense $->$ $cal(O)(n^2)$ opérations.
+
+  #v(0.4em)
+
+  #definition(titre: "Forme ALT : Approximate Lower Triangular")[
+    Par permutation des lignes/colonnes de $bold(H)$ :
+    $
+      bold(H) = mat(A, B, T; C, D, E)
+    $
+    où $T$ est *triangulaire inférieure* de taille $(m-g) times (m-g)$, $g$ = gap (très petit).
+  ]
+
+  #v(0.4em)
+
+  #definition(titre: [Encodage en $cal(O)(n + g^2)$])[
+    Résolution en 2 phases :
+    1. Calculer $bold(p)_1 in FF_2^g$ par élimination sur système de taille $g$
+    2. Calculer $bold(p)_2 in FF_2^(m-g)$ par back-substitution sur $T$ (triangulaire)
+  ]
+
+  #v(0.3em)
+
+  - En pratique (QC-LDPC / 5G / DVB-S2) : encodage par *registres à décalage* $->$ $cal(O)(n)$
+]
+
+#myslide("Canal AWGN")[
+  #v(-0.8em)
+  #set text(size: 18pt)
+
+  #definition(titre: "Modèle du Canal — BPSK sur AWGN")[
+    $
+      y_i = x_i + n_i, quad x_i in {+1, -1}, quad n_i ~ cal(N)(0, sigma^2)
+    $
+    Mapping BPSK : bit $0 arrow.bar +1$, bit $1 arrow.bar -1$
+  ]
+
+  #v(-0.5em)
+
+  #definition(titre: "Rapport Signal sur Bruit")[
+    $
+      frac(E_b, N_0) = frac(1, 2 R sigma^2)
+    $
+    $R = k\/n$ : rendement du code. Exprimé en dB : $10 log_10(E_b\/N_0)$.
+  ]
+
+  #v(-0.5em)
+
+  #definition(titre: "LLR Initial sur Canal AWGN")[
+    $
+      L_"canal"(y_i) = ln frac(P(v_i = 0 | y_i), P(v_i = 1 | y_i)) = frac(2 y_i, sigma^2)
+    $
+    Le LLR est *proportionnel* à la valeur reçue $y_i$ : signe = décision, valeur absolue = confiance.
+  ]
+]
+
+#myslide("Construction de Gallager (1962)")[
+  #set text(size: 17pt)
+
+  #definition(titre: "Principe")[
+    Empiler $w_c$ sous-matrices de taille $(m \/ w_c) times n$ :
+    $
+      bold(H) = mat(H_1; H_2; dots.v; H_(w_c))
+    $
+  ]
+
+  #v(0.4em)
+
+  #set text(size: 21pt)
+  *Algorithme :*
+  - $H_1$ : blocs réguliers de $w_r$ uns consécutifs (colonnes disjointes)
+  - $H_2, dots, H_(w_c)$ : copies de $H_1$ avec colonnes *permutées aléatoirement*
+
+  #v(0.5em)
+
+  #set text(size: 17pt)
+  #grid(
+    columns: (1fr, 1fr),
+    gutter: 0.8em,
+    definition(titre: "Avantage", accent: green.darken(10%))[
+      Simple à construire.\
+      Garantit $w_c$ et $w_r$ exacts.
+    ],
+    definition(titre: "Limite", accent: red)[
+      Cycles de longueur 4 fréquents.\
+      Aucun contrôle du girth.
+    ],
+  )
+]
+
+#myslide("Construction de MacKay-Neal (1996)")[
+  #v(1.6cm)
+  #set text(size: 19pt)
+
+  #definition(titre: "Principe")[
+    Construction *aléatoire* de $bold(H)$ avec évitement actif des 4-cycles.
+  ]
+
+  #v(0.4em)
+
+  #set text(size: 21pt)
+  *Algorithme* — pour chaque arête à placer $(v_j, c_i)$ :
+  1. Vérifier l'absence de 4-cycle : $exists.not (j', i')$ tel que $H_(i,j') = H_(i',j) = H_(i',j') = 1$
+  2. Si conflit : *rejeter* $c_i$ et tirer un autre nœud de contrôle
+  3. Sinon : ajouter l'arête
+
+  #v(0.5em)
+
+  #set text(size: 18pt)
+  #definition(titre: "Résultat")[
+    - Garanti *sans 4-cycles* par construction $->$ girth $>= 6$
+    // - Non garanti globalement (dépend de la densité)
+    // - Fondement théorique du BP (article MacKay & Neal, 1996)
+    - Performances nettement supérieures à Gallager
+  ]
+]
+
+#myslide("Progressive Edge-Growth (Hu et al., 2005)")[
+  #set text(size: 18pt)
+
+  #definition(titre: "Idée")[
+    Construire les arêtes *une par une* en maximisant le *girth local* à chaque étape.
+  ]
+
+  #v(0.4em)
+
+  #set text(size: 21pt)
+  *Algorithme* — pour relier $v_j$ à un nouveau CN :
+  1. BFS depuis $v_j$ dans le graphe courant
+  2. S'arrêter quand tous les CN ne sont plus accessibles à un nouveau niveau
+  3. Relier $v_j$ au CN de plus faible degré *non encore atteint* par le BFS
+
+  #v(0.5em)
+
+  #set text(size: 18pt)
+  #grid(
+    columns: (1fr, 1fr),
+    gutter: 0.8em,
+    definition(titre: "Avantage", accent: green.darken(10%))[
+      Maximise le girth global.\
+      Surpasse Gallager et MacKay.\
+      Standard de référence.
+    ],
+    definition(titre: "Complexité", accent: orange)[
+      $cal(O)(n dot w_c dot m)$\
+      Coût en construction seulement, pas en décodage.
+    ],
+  )
+]
+
+#myslide("Limite de Shannon : Canal AWGN")[
+  #set text(size: 18pt)
+
+  #definition(titre: "Capacité du Canal AWGN (Shannon, 1948)")[
+    $
+      C = 1/2 log_2(1 + "SNR") quad ["bit / utilisation"]
+    $
+    Il *existe* un code de rendement $R < C$ avec BER $-> 0$ quand $n -> infinity$.
+  ]
+
+  #v(0.6em)
+
+  - Pour $R = 1/2$ : limite à $E_b\/N_0 approx 0.19$ dB
+  - *Bit-Flipping* : ~5–6 dB de la limite
+  - *Sum-Product* : ~1–1.5 dB de la limite
+
+  #v(0.5em)
+
+  #definition(titre: "Pourquoi de grands blocs ?", accent: orange)[
+    Loi des grands nombres : pour $n$ grand, le bruit moyen par bit converge vers $sigma^2$.
+    Plus $n$ est grand, plus on s'approche de la limite — au prix de la latence.
+  ]
+
+  #v(0.3em)
+
+  #align(center)[
+    #block(fill: gray.lighten(90%), stroke: 0.5pt + gray, inset: 10pt, radius: 4pt)[
+      DVB-S2 : $n = 64800$ → à 0.5 dB de Shannon pour $R = 1/2$.
+    ]
+  ]
+]
+
+#myslide("Girth : Impact sur la Convergence du BP")[
+  #v(0.7cm)
+  #set text(size: 17pt)
+
+  #definition(titre: [BP Exact $->$ Graphe = Arbre])[
+    Sans cycle, le BP est *exact* et converge en au plus diamètre(graphe) itérations.
+  ]
+
+  #v(0.4em)
+
+  #definition(titre: "Problème des Cycles Courts", accent: red)[
+    Un cycle de longueur $2l$ : après $l$ itérations, un message revient à son point de départ.
+    $->$ *Violation de l'indépendance* des messages $->$ BP sous-optimal.
+  ]
+
+  #v(0.4em)
+
+  - *Girth = 4* : deux VN partagent deux CN $->$ corrélation immédiate, convergence vers solution incorrecte
+  - *Girth = 6* : premier retour après 3 itérations $->$ stable pour quelques itérations
+  // - PEG garantit girth $>= 6$ voire $8$ pour $n = 1296$, $w_c = 3$
+
+  #v(0.4em)
+
+  #align(center)[
+    #block(fill: gray.lighten(90%), stroke: 0.5pt + gray, inset: 10pt, radius: 4pt)[
+      girth $>= 2 I_"max"$ pour que les cycles n'affectent pas les $I_"max"$ premières itérations.
+    ]
+  ]
+]
+
+#myslide("QC-LDPC : Codes Quasi-Cycliques")[
+  #v(1cm)
+  #set text(size: 18pt)
+
+  #definition(titre: [Structure de $bold(H)$ — Blocs Circulants])[
+    $
+      bold(H) = mat(
+        bold(Pi)^(p_(0,0)), dots, bold(Pi)^(p_(0,n_b-1));
+        dots.v, dots.down, dots.v;
+        bold(Pi)^(p_(m_b-1,0)), dots, bold(Pi)^(p_(m_b-1,n_b-1))
+      )
+    $
+    $bold(Pi)^p$ = identité décalée de $p$ lignes ($p = -1$ $->$ matrice nulle)
+  ]
+
+  #v(0.5em)
+
+  #definition(titre: "Avantages")[
+    - *Stockage* : seulement la matrice des exposants $p_(i,j)$ (taille $m_b times n_b$)
+    - *Encodage* : registres à décalage $->$ $cal(O)(n)$ simple en FPGA
+    - *Décodage* : $Z$ noeuds traités en parallèle par bloc circulant
+  ]
+
+  #v(0.3em)
+
+  - DVB-S2 : $Z = 360$, $m_b times n_b = 45 times 90$ $->$ $n = 64800$
+]
+
+#myslide("Convergence du BP : Comportement et Critères")[
+  #set text(size: 17pt)
+
+  #definition(titre: "Hypothèse du BP")[
+    Messages entrants en un nœud supposés *indépendants*.
+    $->$ Exact sur arbre, *approché* sur graphe à grand girth.
+  ]
+
+  #v(0.4em)
+
+  #definition(titre: "Critères d'Arrêt")[
+    - *Syndrome nul* : $bold(H) hat(bold(c))^top = bold(0)$ $->$ succès, on s'arrête
+    - *$I_"max"$ itérations* atteint $->$ échec $->$ paquet perdu (compte dans le FER)
+  ]
+
+  #v(0.4em)
+
+  - En pratique : $I_"max" = 50$–$200$ selon le code et le SNR
+  - Oscillations possibles autour d'un *pseudo-mot de code* (trapping set)
+  - Plus le SNR est élevé, moins d'itérations nécessaires
+
+  #v(0.4em)
+
+  #align(center)[
+    #block(fill: gray.lighten(90%), stroke: 0.5pt + gray, inset: 10pt, radius: 4pt)[
+      Analyse théorique : *Density Evolution* — calcule le seuil exact de convergence en fonction de $E_b\/N_0$.
+    ]
+  ]
 ]
 
 #myslide("CN Update : Formalisme probabiliste")[
@@ -1708,19 +2064,106 @@
   ]
 ]
 
-#myslide("AWGN")[
+#myslide("Bit-Flipping : Choix du Seuil")[
+  #set text(size: 18pt)
 
+  - Chaque $v_j$ reçoit de ses $w_c$ voisins $c_i$ un verdict $f_i in {0, 1}$.
+  - Il retourne son bit si *trop d'équations échouent*.
+
+  #v(0.3em)
+
+  #definition(titre: "Stratégies de Seuil")[
+    #table(
+      columns: (1.2fr, 1.4fr, 1.4fr),
+      inset: 8pt,
+      stroke: 0.5pt + gray,
+      align: center + horizon,
+      [*Seuil*], [*Règle*], [*Remarque*],
+      [Majorité stricte], [$k_j > w_c \/ 2$], [Standard Gallager-A],
+      [Seuil fixe $b$], [$k_j >= b$ (ex. $b = w_c$)], [Gallager-B : plus conservateur],
+      [Tous insatisfaits], [$k_j = w_c$], [Très conservateur, peu de faux retournements],
+    )
+  ]
+
+  #v(0.5em)
+
+  - *Gallager-A* : retourner si *toutes* les contraintes sont violées ($k_j = w_c$) — évite les oscillations
+  - *Gallager-B* : retourner si *au moins* $b < w_c$ contraintes violées — plus agressif
 ]
 
-#myslide("Gallager")[
+#myslide("Que Se Passe-t-il en Cas d'Échec ?")[
+  #set text(size: 16pt)
 
+  #definition(titre: "Échec du Décodeur")[
+    Après $I_"max"$ itérations : syndrome $bold(s) != bold(0)$ $->$ *décodage échoué*. \
+    Deux scénarios :
+    - La trame est *perdue* (FPV, diffusion) $->$ acceptable
+    - La trame doit *arriver* (fichier, protocole) $->$ retransmission nécessaire
+  ]
+
+  #v(0.5em)
+
+  #definition(titre: "ARQ — Automatic Repeat reQuest")[
+    Le récepteur envoie un *NACK* (Not Acknowledged) : l'émetteur retransmet.
+    - *Stop-and-Wait* : simple mais inefficace
+    - *Hybrid ARQ (HARQ)* : combine ARQ + codage — standard LTE/5G
+  ]
+
+  #v(0.4em)
+
+  #definition(titre: "HARQ Type II — Chase Combining", accent: blue)[
+    Le récepteur *combine* les LLR des deux transmissions avant de redécoder :
+    $
+      L_"total"(y_i) = L_"canal"^1(y_i) + L_"canal"^2(y_i)
+    $
+    // $->$ gain de $3$ dB sans retransmission supplémentaire effective.
+  ]
 ]
 
-#myslide("Mackay-Neal")[
+#myslide("Limites du Modèle AWGN")[
+  #v(-0.7cm)
+  #set text(size: 17pt)
 
+  #definition(titre: "Ce que AWGN suppose")[
+    - Bruit *blanc* : indépendant d'un symbole à l'autre
+    - Distribution *gaussienne* stationnaire
+    - Canal *sans mémoire* : chaque bit perturbé indépendamment
+  ]
+
+  #v(-0.2cm)
+
+  #definition(titre: "Canaux Réels — Ce qu'AWGN ne capture pas", accent: red)[
+    #table(
+      columns: (1.2fr, 1.8fr),
+      inset: 8pt,
+      stroke: 0.5pt + gray,
+      [*Phénomène*], [*Impact*],
+      [Évanouissements (fading)], [SNR varie dans le temps],
+      [Burst d'erreurs], [Bits consécutifs corrompus $->$ entrelacement nécessaire],
+      [Bruit impulsionnel], [Pics de bruit ponctuels (moteurs, orages)],
+      [Erreurs de phase], [Synchronisation imparfaite en BPSK],
+    )
+  ]
+
+  #v(-0.2cm)
+
+  #definition(titre: "Solution : Entrelacement", accent: blue)[
+    Permuter les bits *avant* l'envoi : les erreurs en rafale deviennent des erreurs isolées pour le décodeur LDPC.
+  ]
 ]
 
+#set raw(theme: "ldpc-theme.tmTheme")
 
-#myslide("Progressive Edge-growth")[
-
-]
+#generer_slides_code(
+  (
+    "src/rs/code.rs",
+    "src/rs/encoder.rs",
+    "src/rs/decoder.rs",
+    "src/rs/generator.rs",
+    "src/rs/channel.rs",
+    "src/rs/matrix.rs",
+    "src/rs/lib.rs",
+  ),
+  myslide,
+  graphe_tanner_fond,
+)