bit-flipping
This commit is contained in:
294
main.typ
294
main.typ
@ -152,31 +152,42 @@
|
||||
#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;
|
||||
augment: #1,
|
||||
delim: "[",
|
||||
)
|
||||
#dessiner_matrice($G =$, ((texte: $I_k$, largeur: 2.2, fond: gray.lighten(75%)), (texte: $P$, largeur: 2.2, fond: gray.lighten(75%))))
|
||||
// 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: "[",))$
|
||||
// - 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é\
|
||||
- Pour $u in FF_2^k, space #dessiner_matrice($u dot.o G =$, (
|
||||
(texte: $u$, largeur: 1.1, fond: gray.lighten(75%)),
|
||||
(texte: $u dot.o P$, largeur: 3.0, fond: gray.lighten(75%)),
|
||||
))$
|
||||
|
||||
- $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: "[",
|
||||
// )
|
||||
$
|
||||
H = mat(
|
||||
P^top, I_(n-k);
|
||||
augment: #1,
|
||||
delim: "[",
|
||||
)
|
||||
#dessiner_matrice($H =$, (
|
||||
(texte: $P^top$, largeur: 2.2, fond: gray.lighten(75%)),
|
||||
(texte: $I_(n-k)$, largeur: 2.2, fond: gray.lighten(75%)),
|
||||
))
|
||||
$
|
||||
|
||||
]
|
||||
#[
|
||||
#set text(size: 1.2em)
|
||||
@ -291,6 +302,7 @@
|
||||
|
||||
// A REMPLACER AVEC DE VRAI DONNE SUR DE VRAI CODE LDPC ET HAMMING PAR EXEMPLE
|
||||
#myslide("Approcher la Limite de Shannon")[
|
||||
// Faire un graphique waterfall comme sur les papiers de recherche...
|
||||
#limite_shannon_graphique()
|
||||
]
|
||||
|
||||
@ -777,20 +789,177 @@
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Encodage")[
|
||||
|
||||
#myslide("Encodage LDPC : Calcul de G")[
|
||||
#set text(size: 18pt)
|
||||
|
||||
#definition(titre: "Encodage", accent: blue)[
|
||||
Mot de code $bold(c)$ généré à partir d'un message $bold(u)$ :
|
||||
$bold(c) = bold(u) bold(G)$\
|
||||
// $bold(H) bold(G)^top = bold(0)$
|
||||
]
|
||||
|
||||
#v(2em)
|
||||
|
||||
#align(center)[#scale(135%)[#paradoxe_densite_reel()]]
|
||||
|
||||
#v(2em)
|
||||
|
||||
#set text(size: 1em)
|
||||
- Forme Systématique : Par élimination de Gauss sur $bold(H)$, on obtient
|
||||
|
||||
#v(1em)
|
||||
#align(center)[
|
||||
#schema_systematique()
|
||||
]
|
||||
|
||||
#v(1em)
|
||||
#set text(size: 1em)
|
||||
- La matrice $bold(G)$ devient dense $=>$ encodage en $cal(O)(n^2)$
|
||||
|
||||
// #v(1em)
|
||||
// #block(fill: rgb("#fef2f2"), stroke: 1pt + red, inset: 10pt, radius: 5pt)[
|
||||
// *Défi Matériel :* Pour $n=64\,800$ (DVB-S2), $n^2$ est prohibitif. Solution : les codes *quasi-cycliques* (5G).
|
||||
// ]
|
||||
]
|
||||
|
||||
#myslide("Décodage")[
|
||||
Canal d'étude (AWGN) analogique, tension etc, ce qui se passe en radio dans les cables etc
|
||||
#myslide("Décodage : Bit-Flipping")[
|
||||
#set text(size: 16pt)
|
||||
|
||||
#definition(titre: "Décision Stricte (Hard Decision)", accent: black)[
|
||||
Algorithme *itératif* : les nœuds *échangent des bits* pour localiser les erreurs.
|
||||
]
|
||||
|
||||
#v(0.2em)
|
||||
|
||||
#set text(size: 1em)
|
||||
|
||||
#set text(size: 16pt)
|
||||
#definition(titre: "Message Passing", accent: blue)[
|
||||
// L'information *circule le long des arêtes* du graphe de Tanner à chaque itération.
|
||||
- #icon_var envoie son bit courant à ses voisins #icon_chk
|
||||
- #icon_chk renvoie son *verdict de parité* ($0$ ou $1$)
|
||||
]
|
||||
|
||||
#v(0.6em)
|
||||
|
||||
#set text(1em)
|
||||
- Si $v_j$ participe à *trop d'équations non satisfaites* $=>$ on l'inverse.
|
||||
|
||||
#uncover(2)[
|
||||
#grid(
|
||||
columns: (1fr, 1fr, 1fr),
|
||||
column-gutter: 10pt,
|
||||
// On aligne tout par le bas (bottom) pour que les CN soient sur la même ligne
|
||||
align: center + bottom,
|
||||
[
|
||||
#bf_step1_sending()
|
||||
#v(-0.5em)
|
||||
#text(style: "italic", fill: gray.darken(40%), size: 0.8em)[VN $arrow$ CN]
|
||||
],
|
||||
[
|
||||
#bf_step2_verdict()
|
||||
#v(-0.5em)
|
||||
#text(style: "italic", fill: gray.darken(40%), size: 0.8em)[CN $arrow$ VN]
|
||||
],
|
||||
[
|
||||
#bf_step3_flip()
|
||||
#v(-0.5em)
|
||||
#text(style: "italic", fill: gray.darken(40%), size: 0.8em)[Correction]
|
||||
],
|
||||
)
|
||||
]
|
||||
// #align(center + horizon)[
|
||||
// #scale(100%)[#bp_hard_diagram()]
|
||||
// #v(0.4em)
|
||||
// #text(
|
||||
// size: 0.72em,
|
||||
// style: "italic",
|
||||
// fill: gray.darken(20%),
|
||||
// )[Échanges itératifs entre $V$ (cercles) et $C$ (carrés)]
|
||||
// ]
|
||||
]
|
||||
|
||||
#myslide("Hard decoding")[
|
||||
Nul (0 ou 1)
|
||||
transition perte d'information
|
||||
#myslide("Bit-Flipping : Graphe de flot de contrôle")[
|
||||
#set text(size: 17pt)
|
||||
|
||||
// #grid(
|
||||
// columns: (1.25fr, 0.75fr),
|
||||
// gutter: 0.8cm,
|
||||
// align: top,
|
||||
// [
|
||||
// #step_box(1, orange)[
|
||||
// *CN Update — Évaluation* \
|
||||
// #set text(size: 0.88em)
|
||||
// Chaque nœud de contrôle $c_i$ calcule sa parité :
|
||||
// $
|
||||
// f_i = xor.big_(j in cal(N)(c_i)) v_j in {0, 1}
|
||||
// $
|
||||
// Si $f_i = 1$ : *l'équation n'est pas satisfaite* $=>$ $c_i$ envoie le message "Erreur" à tous ses voisins.
|
||||
// ]
|
||||
//
|
||||
// #v(0.45em)
|
||||
//
|
||||
// #step_box(2, blue)[
|
||||
// *VN Update — Vote* \
|
||||
// #set text(size: 0.88em)
|
||||
// Chaque bit $v_j$ compte ses alarmes reçues $k_j$.
|
||||
// Si $k_j$ dépasse le seuil (ex. *majorité*) :
|
||||
// $
|
||||
// v_j arrow.l 1 - v_j quad ("FLIP")
|
||||
// $
|
||||
// ]
|
||||
//
|
||||
// #v(0.45em)
|
||||
//
|
||||
// #step_box(3, green.darken(10%))[
|
||||
// *Vérification — Syndrome* \
|
||||
// #set text(size: 0.88em)
|
||||
// On recalcule $bold(s) = bold(H) bold(r)^top$.
|
||||
// - Si $bold(s) = bold(0)$ : *Succès*, on s'arrête.
|
||||
// - Sinon : on recommence l'étape ① (jusqu'à `max_iter`).
|
||||
// ]
|
||||
// ],
|
||||
// [
|
||||
// #align(center)[
|
||||
// #v(0.3em)
|
||||
// #scale(96%)[#schema_boucle_bf()]
|
||||
// ]
|
||||
// ],
|
||||
// )
|
||||
#align(center + horizon)[
|
||||
#move(dx: 2.5cm, dy: -0.5cm)[#scale(95%)[#schema_boucle_bf()]]
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Implementation")[
|
||||
#myslide("Exemple implementation Bit-Flipping rust")[
|
||||
ex + canal d'etude bruit AWGN avec ce qu'il se passe dans les radio / cable etc + tension
|
||||
]
|
||||
|
||||
#myslide("Bit-Flipping : Analyse")[
|
||||
#set text(size: 17pt)
|
||||
|
||||
#definition(titre: "Avantages", accent: green.darken(10%))[
|
||||
#set text(size: 0.88em)
|
||||
- *Complexité* : simples XOR et compteurs — $cal(O)(n)$ par itération
|
||||
// - *Matériel* : idéal FPGA/ASIC, massivement parallélisable
|
||||
// - *Simplicité* : inventé par Gallager (1962)
|
||||
]
|
||||
#definition(titre: "Limite", accent: red)[
|
||||
#set text(size: 0.88em)
|
||||
- Ignore la *confiance* du récepteur physique dans le signal
|
||||
- Un bit reçu à $0.51$ V est traité comme $0$
|
||||
// - $=>$ Sous-optimal par rapport à la limite de Shannon
|
||||
|
||||
// #v(0.3em)
|
||||
// #align(center)[
|
||||
// #box(fill: rgb("#fff7ed"), stroke: (left: 3pt + orange), inset: (x: 8pt, y: 5pt))[
|
||||
// #text(
|
||||
// size: 0.82em,
|
||||
// )[$arrow$ Nécessite le *Soft-Decision* (Belief Propagation) pour exploiter les niveaux de gris du signal]
|
||||
// ]
|
||||
// ]
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Soft decoding")[
|
||||
@ -831,90 +1000,3 @@
|
||||
]
|
||||
|
||||
|
||||
// HARD DECISION
|
||||
// #myslide("Graphe de Tanner : Utilité")[
|
||||
// #grid(
|
||||
// columns: (1.55fr, 1fr),
|
||||
// column-gutter: 0.5cm,
|
||||
// align: top,
|
||||
// [
|
||||
// #definition(titre: "Support du Passage de Messages")[
|
||||
// Le graphe de Tanner est le *cadre naturel* des algorithmes de décodage itératifs — il rend la structure du code *explicite et locale*
|
||||
// ]
|
||||
//
|
||||
// #v(0.45em)
|
||||
//
|
||||
// #[
|
||||
// #set text(size: 1.05em)
|
||||
// - *Localité* : chaque nœud n'opère qu'avec ses *voisins directs*
|
||||
//
|
||||
// - *Itérations — à chaque tour :*
|
||||
// #pad(left: 0.9em)[
|
||||
// #text(fill: blue, weight: "bold")[V → C :] $v_j$ envoie son estimation (LLR) aux $c_i$ voisins \
|
||||
// #text(fill: orange, weight: "bold")[C → V :] $c_i$ renvoie une correction aux $v_j$ voisins
|
||||
// ]
|
||||
//
|
||||
// - *Convergence* vers le mot de code le plus vraisemblable
|
||||
//
|
||||
// - *Complexité* : $cal(O)(n dot w_c)$ par itération \ vs $cal(O)(2^k)$ pour le MDL — gain *exponentiel*
|
||||
// ]
|
||||
// ],
|
||||
// [
|
||||
// #v(0.6em)
|
||||
// #align(center)[
|
||||
// #bp_diagram()
|
||||
// #v(0.5em)
|
||||
// #set text(size: 0.79em)
|
||||
// #stack(
|
||||
// dir: ttb,
|
||||
// spacing: 0.25em,
|
||||
// [#box(width: 1.3em, height: 2pt, fill: blue)
|
||||
// #h(0.3em) #text(fill: blue, weight: "bold")[$mu_(j arrow i)$ : V → C] (LLR)],
|
||||
// [#box(width: 1.3em, height: 2pt, fill: orange)
|
||||
// #h(0.3em) #text(fill: orange, weight: "bold")[$nu_(i arrow j)$ : C → V] (correction)],
|
||||
// )
|
||||
// ]
|
||||
// ],
|
||||
// )
|
||||
// ]
|
||||
|
||||
|
||||
|
||||
#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.
|
||||
// ],
|
||||
// )
|
||||
// ]
|
||||
|
||||
Reference in New Issue
Block a user