On continue le compte rendu …

Petit fix du Makefile

CompteRendu/CompteRendu.tex

@@ -20,9 +20,9 @@
 
 \theorembodyfont{\upshape}
 
-% Assure que les nouvelles parties commencent toujours sur une nouvelle page.
+% Ajoute le joli séparateur entre les parties
 \let\oldpart\part
-\renewcommand\part{\clearpage\oldpart}
+\renewcommand\part{\hsep\oldpart}
 
 % Un peu plus d'interligne, c'est plus lisible
 \onehalfspacing
@@ -31,8 +31,9 @@
 \newcommand{\hsep}{\centerline{\rule{0.8\linewidth}{.05pt}}}
 
 % Racourcis
-\newcommand{\FD}{\mathbb{F}_2\hspace{-.2em}}
+\newcommand{\FD}{\mathbb{F}_2}
 \newcommand\fsign[3]{\item \textbf{#1} : \textit{#2} \qquad Complexité en $\mathcal{O}(#3)$\\}
+\newcommand\fsignz[2]{\item \textbf{#1} : \textit{#2}\\}
 \newcommand\into{\textrightarrow\:}
 
 \newtheoremstyle{break}
@@ -46,22 +47,40 @@
 \theoremstyle{remark}
 \newtheorem*{remarque}{Remarque}
 
-% Compter les mots
 
-\author{Samy AVRILLON, Victor BELLOT, Dylan THEVENET}
+%% Choose your 5/2
-\title{Études des codes cycliques}
+% 1: Dylan
+% 2: Samy
+% 3: Victor
+\newcounter{cqd}
+\setcounter{cqd}{2}
+
+\newcommand\lequel[3]{
+
+\ifnum\value{cqd}=1 
+#1
+\else\ifnum\value{cqd}=2 
+#2
+\else
+#3
+\fi\fi
+}
+
+\author{\lequel{Dylan THEVENET}{Samy AVRILLON}{Victor BELLOT}}
+\title{Étude des codes correcteur d'erreurs}
 \begin{document}
 
 	\maketitle
 	
 	\hsep
 	
-	\tableofcontents
+	\section*{Introduction}
 	
-	\pagebreak
+	Ce document est le compte rendu de mon TIPE fait pour l'année 2021. L'objectif premier est de créer un ensemble de modules OCaml permettant de manipuler et d'utiliser les codes correcteurs d'erreurs. Une première partie va donc s'intéresser aux différents concepts mathématiques derrière la théorie des codes correcteurs, ainsi qu'aux théorèmes qui permettront d'obtenir des algorithmes efficaces. La seconde partie va décrire les algorithmes et structures de données crées et décrire succinctement leur fonctionnement.
 	
+	\ifnum\value{cqd}=1\else % Dylan n'a pas besoin de première partie
 	\part{Contexte mathématique}
-		
+	\fi
 	\section{Codes}
 	
 	\begin{definition}[Code, Codage]
@@ -86,7 +105,7 @@
 	\begin{theoreme}\label{thCapacité}
 		On peut alors exprimer $e_d$ et $e_c$ en fonction de $d_C$ :
 		
-		$$ e_c = d_C - 1 \qquad e_d = \left\lfloor\frac{d_C - 1}{2}\right\rfloor$$
+		$$ e_d = d_C - 1 \qquad e_c = \left\lfloor\frac{d_C - 1}{2}\right\rfloor$$
 	\end{theoreme}
 	
 	\begin{definition}[Code Parfait]
@@ -111,7 +130,7 @@
 		\end{definition}
 		
 		\begin{definition}[Matrice de contrôle]
-			On appelle \textbf{matrice de contrôle} n'importe quelle matrice de $\mathcal{M}_{n-k,k}(\FD)$ ayant $C$ pour noyau.
+			On appelle \textbf{matrice de contrôle} n'importe quelle matrice de $\mathcal{M}_{n-k,n}(\FD)$ ayant $C$ pour noyau.
 			
 			Tout code a au moins une matrice de contrôle.
 		\end{definition}
@@ -135,15 +154,15 @@
 			On appelle alors \textbf{mot erreur} le mot $E = Z - Y$.
 			On appelle \text{syndrome} le mot $S = H \cdot Z$.
 			
-			On remarque que $E$ et $Z$ on le même syndrome. On peut plus généralement définir une relation d'équivalence «avoir le même syndrome». Les classes d'équivale nce de cette relation sont appelées \textbf{classes latérales}.
+			On remarque que $E$ et $Z$ on le même syndrome. On peut plus généralement définir une relation d'équivalence «avoir le même syndrome». Les classes d'équivalence de cette relation sont appelées \textbf{classes latérales}.
 		\end{definition}
 		
 	\section{Codes cycliques}
 		
 		\begin{definition}[Code cyclique]
-			Un code linéaire est dit cyclique si il est stable par décalage binaire cyclique. C'est à dire que si $w_1w_2w_2\ldots w_n$ est dans $C$ alors $w_2w_3w_4\ldots w_{n-1}w_nw_1$ appartient aussi à $C$.
+			Un code linéaire est dit cyclique s'il est stable par décalage binaire cyclique. C'est à dire que si $w_1w_2w_3\ldots w_n$ est dans $C$ alors $w_2w_3w_4\ldots w_{n-1}w_nw_1$ appartient aussi à $C$.
 			
-			On peut aussi définir le \textbf{code cyclique engendrée} par un mot $w$, qui est le plus petit espace vectoriel stable par décalage cyclique qui contienne $w$.
+			On peut aussi définir le \textbf{code cyclique engendré} par un mot $w$, qui est le plus petit espace vectoriel stable par décalage cyclique qui contienne $w$.
 		\end{definition}
 		
 		\begin{definition}
@@ -160,6 +179,65 @@
 			Un codage naturel pour un code cyclique apparaît avec le polynôme générateur. Le codage appliqué à un mot $w$ est le mot associé au produit du polynôme générateur et du polynôme associé à $w$. 
 		\end{remarque}
 		
+		\ifnum\value{cqd}=1
+		\section{Codes BCH}
+		
+		\begin{definition}[Racine primitive n-ième de l'unité]
+			On appelle \textbf{racine primitive n-ième de l’unité} un nouveau nombre $\alpha$, tel que $\alpha^n = 1$ et $\forall k \in \llbracket1,n-1\rrbracket\,\alpha^k \neq 1$.
+			
+			Ce n’est pas un élément de $\FD$.
+			
+			On peut donc factoriser $X^n+1 = \displaystyle\prod_{k=0}^{n-1}{\left(X-\alpha^k\right)}$, mais les termes ne sont malheureusement pas dans $\FD[X]$.
+		\end{definition}
+		
+		\begin{definition}
+			On définit $\FD(\alpha)$ comme le plus petit corps contenant à la fois $\FD$ et le nouvel élément $\alpha$.
+			
+			Alors, $\FD(\alpha) = \left\{P(\alpha) | P\in\FD[X]\right\}$
+		\end{definition}
+		
+		\begin{definition}
+			$I = \left\{P \in \FD [X] | P(\alpha) = 0\right\}$ est un idéal de $\FD[X]$ engendré par un unique polynôme unitaire $M_\alpha$
+			
+		\end{definition}
+		
+		\begin{theoreme}
+
+			$\FD(\alpha)$ contient $2^q$ éléments, où $q = deg(M_\alpha)$
+			On peut de la même manière construire des corps de taille $p^m$, où $p$ est un nombre premier et $m$ est un entier naturel non nul.
+		\end{theoreme}
+		
+		\begin{theoreme}
+			Soit $P$ un polynôme à coefficients dans $\FD (\alpha)$. On a l’équivalence :
+			$$P\text{ est un polynôme à coefficients dans } \FD \iff P(X)^2 = P(X^2)$$
+			
+		\end{theoreme}
+		
+		\begin{theoreme}
+			Soit $P(X)= \displaystyle\prod_{i\in\Sigma} (X - \alpha^i)$
+			
+			Alors $P(X) \in \FD [X]$ $\iff$ $\Sigma$ est stable par multiplication par 2 modulo n.
+			
+		\end{theoreme}
+		
+		D’où la définition suivante :
+		
+		\begin{definition}[Classes cyclotomiques]
+			On appelle \textbf{classe cyclotomique engendrée par $j$} l’ensemble $\left\{j, 2j,\cdots, 2^{s-1}j\right\}$ (où les entiers sont réduits modulo n) avec $2^s j \equiv j\mod\,n$
+			C’est une partie de ${0,..., n - 1}$ stable par multiplication par 2 et minimale pour l’inclusion.
+			
+		\end{definition}
+		
+		Les classes cyclotomiques permettent donc de factoriser complètement $X^n + 1 dans \FD [X]$
+		
+		\begin{theoreme}[Théorème BCH]
+			On note $C$ le code cyclique associé à la partie stable $\Sigma = \left\{i_1 ,\cdots, i_{n-k} \right\}$ (donc de polynôme générateur	$\displaystyle\prod_{i\in\Sigma}{(X-\alpha^i)}$)
+			
+			S’il existe des entiers $a$ et $s$ tels que $\Sigma$ contienne $a, a + 1, \cdots, a + s$ alors la distance minimale de $C$ est supérieure ou égale à $s+1$.
+			
+		\end{theoreme}
+		
+	\else
 	\part{Algorithmes}
 	\section{Des structures de données}
 	
@@ -216,15 +294,16 @@
 			\fsign{appartenir}{code\_lineaire -> vecteur -> bool}{n}
 				Renvoie \textit{vrai} si et seulement si le vecteur appartient au code, c'est à dire, si et seulement si $HX=0$ avec $H$ la matrice de contrôle et $X$ le vecteur de $\FD^n$ en question.
 			\fsign{distance\_minimale}{code\_lineaire -> int}{non}
-				Renvoie la distance minimale du code, utilisée pour calculer les capacités de détéction et de correction du code (voir \ref{thCapacité}). Le calcul s'effectue en recherchant le plus petit mot (au sens du poids) qui soit dans le code.
+				Renvoie la distance minimale du code, utilisée pour calculer les capacités de détection et de correction du code (voir \ref{thCapacité}). Le calcul s'effectue en recherchant le plus petit mot (au sens du poids) qui soit dans le code.
-			\fsign{decoder}{code\_lineaire \into vecteur \into Math.vecteur}{euhhhhhhhh}
+			\fsignz{decoder}{code\_lineaire \into vecteur \into Math.vecteur}
-				Décode le mot de $\FD^n$ donné. L'algorithme recherche le mot le plus proche du mot recu qui soit dans le code et à une distance inferieure à la distance de correction. Si il est impossible de décoder, renvoie une exception du type \verb|IndecodableException|.
+				Décode le mot de $\FD^n$ donné. L'algorithme recherche le mot le plus proche du mot reçu qui soit dans le code et à une distance inférieure à la distance de correction. Si il est impossible de décoder, renvoie une exception du type \verb|IndecodableException|.
 				
-			\fsign{genererClasses}{code\_cyclique \into classes\_latérales}{well ...}Génère les classes latérales associées au code spécifié. Parcours les vecteurs par poids croissant (d'abord ceux de poids 1, puis 2, etc…) et référence leur syndrome dans \verb|classes.rpz : vecteur -> vecteur| qui à un syndrome associe le représentant de la classe latérale de poids le plus faible.
+			\fsign{genererClasses}{code\_lineaire \into classes\_latérales}{well ...}Génère les classes latérales associées au code spécifié. Parcours les vecteurs par poids croissant (d'abord ceux de poids 1, puis 2, etc…) et référence leur syndrome dans \verb|classes.rpz : vecteur -> vecteur| qui à un syndrome associe le représentant de la classe latérale de poids le plus faible.
 			
 			\fsign{decoder2}{classes\_latérales \into vecteur \into vecteur}{n\cdot \ln(n)} Décode le mot $Z$ de $\FD^n$ donné. L'algorithme calcule le syndrome du mot, obtient le représentant de la classe latérale associée à ce vecteur $E$. Dans l'hypothèse où le mot reçu est effectivement décodable, alors, son «erreur» $E = Z-Y$, avec $Y$ le mot du code initialement envoyé, a la même classe latérale que $Z$. Donc $Y = Z+E$, on obtient un mot du code que l'on peut décoder.
 		\end{itemize}
 	
+	\pagebreak
 	\part*{Annexes}
 		\begin{figure}[h]
 			\begin{center}
@@ -233,5 +312,6 @@
 				\caption{Exemple d'affichage de vecteur,matrice et polynômes}
 			\end{center}
 		\end{figure}
+	\fi
 	
 \end{document}

Makefile

@@ -8,6 +8,10 @@ ascii: $(shell find textes/ -type f -iname "*.txt" ! -iname "*.ascii.txt" | sed
 %.cmx: %.ml
 	ocamlopt -c $<
 
+images.cmo: images.ml images.mli
+	ocamlc -c images.mli
+	ocamlc -c images.ml
+
 Code.cmo: Code.ml Code.mli Math.cmo
 	ocamlc -c "Code.mli"
 	ocamlc -c "Code.ml"
@@ -21,7 +25,7 @@ tipe: tipe.cmx
 %.txt.test: %.ascii.txt tipe
 	./tipe $<
 
-ocshell:
+ocshell: images.cmo Math.cmo Code.cmo
 	rlwrap ocaml graphics.cma images.cmo Math.cmo Code.cmo
 
 runall: $(shell find textes/ -type f -iname "*.txt" ! -iname "*.ascii.txt" | sed "s/\.txt/\.txt\.test/")

TestImage.ml

@@ -3,7 +3,7 @@ open Images ;;
 open Math;;
 open Code;;
 
-let img = lire_image "Documents/gauss_low.png";;
+let img = lire_image "Documents/gauss.png";;
 
 
 let alpha = 0.95;;
@@ -15,6 +15,7 @@ let nbreErr () =
 	else if (0.9<=v && v<0.99) then 1
 	else if (0.99<v && v<0.999) then 2
 	else 3;;
+
 let rec bruiteur n a = 
 	let v = nbreErr () in
 	let x = ref a in
@@ -80,8 +81,6 @@ do
 done;;
 
 for i=0 to larg-1 do
-print_string "\r";
-print_int i;
 for j=0 to long-1 do
 img.(i).(j) <- transmettre code classes img.(i).(j)
 done
@@ -91,7 +90,7 @@ done;;
 for j=0 to long-1 do
 img.(i).(j) <- transmetGros codeG classesG img.(i).(j)
 done
-done;;*)
+done;;
+*)
 
-
+sauver_image img "gaussV2.png";;
-sauver_image img "gaussV2-low.png";;