1ere partie 451

451-Signal_Image/Cours/chap0.tex

@@ -0,0 +1,64 @@
+\documentclass[main.tex]{subfiles}
+\begin{document}
+Les signaux déterministe sont utilisé pour les test ou les commandes . Ils sont cependants insuffisant pour décrire l'ensemble des phénomènes qui peuvent être aléatoire ou stochastique. Il est donc nécessaire d'introduire des ``signaux aléatoires'' (SA).
+\begin{exemple}[Lot de resistances ``identiques'']
+  On considère un lot de résistance de même valeur indiqué par le code couleur, et de même précision. Elles ont en réalité toutes des valeurs différentes $R_i$. on note $s_i(t)$ , la tension au borne de $R_i$.
+
+  On a $s_i(t)=0$ mais avec $A\gg1$ on obtient $A.s_i(t)\neq 0$.
+
+  Alors: $\overline{s_i(t)} = 0$ mais il existe une fluctuation de la tension due au bruit thermique.
+
+  On note alors :
+  \[
+    s_i(t) = s(t,i) = s(t,\omega)
+  \]
+  C'est une réalisation particulière du SA, appelé par la suite trajectoire.
+\end{exemple}
+
+Dans le cas général on parle de fonction aléatoire $F(\theta,\omega)$ ,où $\theta$ est un paramètre certain (comme le temps par exemple).
+
+
+\begin{rem}
+  Un signal aléatoire n'est caractérisé qu'en moyenne.
+  \begin{itemize}
+  \item moyenne à $\omega$ donné : $s(t,\omega_0) =s_0(t)$ : \textbf{moyenne temporelle}
+  \item moyenne à $t$ donné : $s(t_0,\omega) = s_0(\omega)$ : \textbf{moyenne statistique}.
+  \end{itemize}
+\end{rem}
+On dit aussi que $S(t,\omega) = S_t(\omega)$ est une famille de variable aléaoire indexé par le temps, qui décrit l'aspect incertain à chaque instant.
+\begin{figure}[H]
+  \centering
+  \begin{tikzpicture}
+    \begin{axis}[
+      scale=1.5,
+    axis lines = middle,
+    set layers=standard,
+    domain=0:10,
+    samples y=1,
+%   view={-10}{-20},
+    unit vector ratio*=1 5 1,
+    xtick=\empty, ytick=\empty, ztick=\empty,
+    %xlabel=$t$,ylabel=$\omega$,
+    xmax=12,ymax=3.1,
+    ]
+    \foreach \p in {0,1,2,3}
+    {\addplot3[thick, black] (x,\p,{2*sin(deg(x)+\p*70)});}
+    \foreach \t in {3,6,9}
+    {\addplot3[dashed,domain=0:3] (\t,x,0);}
+    \foreach \t in {3,6,9}
+    \foreach \u in {0,1,2,3}
+    {\addplot3[dotted, domain=0:{2*sin(deg(\t)+\u*70)},samples=2,mark size=0.5pt,mark=*] (\t,\u,x);}
+    \foreach \v in {1,2,3}
+   \addplot3[dotted, domain=0:{2*sin(\v*70)},samples=2,mark size=0.5pt,mark=*] (0,\v,x);
+    \node[above,right] at (axis cs: 12,0,0) {$t$};
+    \node[above,left] at (axis cs: 0,3,0) {$\omega$};
+  \end{axis}
+  \end{tikzpicture}
+  \caption{Représentation des trajectoires d'un signal aléatoire}
+\end{figure}
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "main"
+%%% End:

451-Signal_Image/Cours/chap1.tex

@@ -0,0 +1,217 @@
+\documentclass[main.tex]{subfiles}
+\begin{document}
+\section{Probabilités}
+\subsection{Évènement}
+\begin{itemize}
+\item La réalisation d'une expérience aléatoire (on ne peux pas prédire avec certitude le résultat) est un \textit{évènement} $\omega$, singleton de $\Omega$ ensembles de tous les évènements.
+  \begin{exemple}[jet de dé]
+    aux évènements    ``Tirer 1, ... ,6 `` on associe $\Omega={\omega_1,...\omega_6}$
+  \end{exemple}
+\item $\mathcal{E} $est une tribu (ou $\sigma$-algèbre) de $\Omega$, tel que:
+  \begin{itemize}
+  \item $\Omega \in \mathcal{E}$
+  \item $\mathcal{E}$ est stable par union , intersection et complémentarité.
+  \end{itemize}
+\end{itemize}
+\subsection{Probabilités}
+\begin{defin}
+  On appelle probabilité :
+  \[
+    P : \begin{cases}
+      \mathcal{E} &\to [0,1]\\
+      E &\mapsto P(E)
+        \end{cases}
+   \]
+   tel que:
+
+   \begin{itemize}
+   \item $    P(\Omega) = 1 $
+   \item $ \forall E_i , i\in \mathbb{I} \text{ , desév disjoint 2 à 2}, \implies
+     P\left(\displaystyle\bigcup_{i\in\mathbb{I}}E_i\right) = \displaystyle\sum_{\mathbb{I}} P(E_i)$
+   \end{itemize}
+
+ \end{defin}
+
+\pagebreak
+ \begin{prop}
+   \begin{itemize}
+   \item  $ P(\bar{E}) = 1-P(E)$
+   \item $(P(\emptyset) = 0)$
+   \item $A \subset B  \implies P(A) \leq P(B)$
+   \item $P(A+B) = P(A)+P(B)-P(A\cap B)$
+   \end{itemize}
+ \end{prop}
+\subsection{Probabilités conditionnelles}
+
+\begin{defin}
+  Soit $A$ et $B$ deux évènements.  On appelle \emph{probabilité conditionnelle} la probabilité de $A$ sachant que  $B$ est réalisé:
+  \[
+    P(A|B) = \frac{P(A\cap B)}{P(B)}
+  \]
+\end{defin}
+\begin{prop}[Formule de Bayès]
+  \[
+    P(A|B) = \frac{P(B|A)P(A)}{P(B)}
+  \]
+\end{prop}
+
+\subsection{Indépendance}
+\begin{defin}
+  Deux évènements $A$ et $B$ sont dits \emph{indépendant} si et seulement si le fait que $A$ est réalisé n'apporte pas d'information sur la réalisaiton de $B$
+    \begin{align*}
+      & P(A|B) = P(A)\\
+      \iff & P(B|A) = P(B)\\
+      \iff & P(A\cap B) = P(A) .P(B)
+    \end{align*}
+\end{defin}
+\begin{defin}
+  Des évènements $(E_i)_{i\in\mathbb{I}}$  sont dits mutuellement indépendants (ou encore indépendants dans leur ensemble), si et seulement si:
+  \[
+  P\left(\displaystyle\bigcap_{i\in\mathbb{I}}E_i\right) = \displaystyle\prod_{\mathbb{I}} P(E_i)
+\]
+\end{defin}
+
+\begin{prop}
+  L'indépendance dans son ensemble implique l'indépendance deux à deux. \\
+  La réciproque n'est pas forcément vraie.
+\end{prop}
+\section{Variable aléatoire réelle et scalaire}
+On se place dans un espace probabilisé $\Omega$ donné.
+\subsection{Généralité et exemple}
+\begin{defin}
+  On appelle \emph{Variable aléatoire} (VA) :
+  \[
+    X :
+    \begin{cases}
+      \Omega \to \R \\
+      \omega \mapsto X(\omega)=x
+    \end{cases}
+  \]
+\end{defin}
+\begin{exemple}
+  \begin{itemize}
+  \item Dé à n faces (discret)
+  \item distance d'une flèche au centre de la cible.
+  \end{itemize}
+\end{exemple}
+\begin{prop}
+  Pour des variables aléatoires continues,
+  \[
+    P(X=x) = 0 , \forall x\in \R
+  \]
+  car $x$ est un point de mesure nulle.
+\end{prop}
+
+
+\subsection{Fonction de répartition}
+
+\begin{defin}
+  On appelle fonction de répatition:
+  \begin{align*}
+    F_X(x) &= P(X\leq x) = P(X \in ]-\infty,x])\\
+           &=P(\{\omega \in \Omega|X(\omega)\le x \})
+  \end{align*}
+\end{defin}
+\begin{prop}
+  \begin{itemize}
+  \item $0 \le\F_X(x) \le1$
+  \item $P(a\le X\le b) = F_X(b)-F_X(a)$
+  \item $F_x$ est une fonction :
+    \begin{itemize}
+    \item non décroissante
+    \item continue presque partout
+    \end{itemize}
+  \end{itemize}
+\end{prop}
+
+Une variable aléatoire est complétement caractérisée par sa f.d.r
+\begin{rem}
+  Dans le cas d'une VAD , $F_X$ est en marche d'escalier.
+\end{rem}
+\subsection{Densité de probabilité}
+\begin{defin}
+  On appelle \emph{densité de probabilité} la fonction :
+  \[
+f_X(x) \equals_{\mathcal{D}} \dervi[F_X(x)]{x}
+\]
+Avec la dérivée généralisé au sens des distributions.
+\end{defin}
+\begin{prop}
+  \begin{itemize}
+  \item Les fonction de densité de probabilité et de répartition sont équivalentes pour décrire une variable aléatoire.
+  \item $f_X(x)\ge 0$
+  \item $\displaystyle \int_{-\infty}^{+\infty}f_X(x)\d x = 1$
+  \item $\displaystyle \int_{-\infty}^{x}f_X(\alpha)\d \alpha = F_X(x)$
+  \end{itemize}
+\end{prop}
+
+\begin{rem}
+  Pour les variables aléatoires discrètes, la ddp est une suite d'impulsion de Dirac :
+  \[
+    f_X(x) = \sum_{i\in\mathbb{I}}p_i\delta(x-x_i)
+  \]
+\end{rem}
+
+\begin{exemple}
+  \begin{itemize}
+  \item VAC uniforme sur $[a,b]$:
+    \[
+      f_X(x) = \frac{1}{b-a} \mathbb{1}_{[a,b]}
+    \]
+  \item VAC gaussienne :
+    \[
+      f_X(x) = \frac{1}{\sqrt{2\pi}\sigma} exp\left(\frac{-1}{2}\frac{(x-m_x)^2}{\sigma_X^2}\right)
+    \]
+  \end{itemize}
+\end{exemple}
+
+\subsection{Changement de VA}
+\begin{prop}
+  Soit $g :
+  \begin{cases}
+    \R \to \R \\
+    X \mapsto g(X) = Y
+  \end{cases}$ une fonction homéomorphique\footnotemark \\
+  Alors :
+  \[
+    f_Y(y) = f_X(x) \left|\deriv[x]{y}\right| = f_X(x) \frac{1}{ \left|\deriv[y]{x}\right|}
+  \]
+  Dans le cas ou $g$ n'est pas bijective :
+  \[
+    f_Y(y) = \sum_{x_i|g(x_i)=y}^{}f_X(x) \left|\deriv[x]{y}\right|_{x=x_i}
+  \]
+\end{prop}
+\footnotetext{continue, bijective continue}
+
+\subsection{Expérance, moment et fonction caractéristique}
+
+
+
+
+\subsection{Fonction caractéristique}
+\section{Couple de variable aléatoire réelles}
+\subsection{Généralité}
+\subsection{Fonction de répartition}
+\subsection{Densité de probabilité}
+\subsubsection{Espérance de la VA}
+\subsection{Indépendance}
+\subsection{Changement de VA}
+\subsection{Espérance et moments-fonction caractéristique}
+\section{Variable aléatoire vectorielle et réelles}
+\subsection{Définition}
+\subsection{Fonction de répartition}
+\subsection{Densité de Probabilité}
+\subsection{Indépendance}
+\subsection{Changement de variable aléatoire}
+\subsection{Espérance, moments et fonction caractéristique}
+\subsection{Va Gaussienne et réelle}
+\section{Extension aux VA complexes}
+
+
+
+\end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "main"
+%%% End:

451-Signal_Image/Cours/main.tex

@@ -12,8 +12,12 @@
 
 \maketitle
 \tableofcontents
-\chapter{Chapitre 1}
+\chapter*{Introduction}
-\chapter{Chapitre 2}
+\subfile{chap0.tex}
+\chapter{Rappel d'élement de probabilité et de VA}
+\subfile{chap1.tex}
+\chapter{Signaux Aléatoire}
+
 \chapter{Filtrage des Signaux Aléatoires}
 \subfile{chap3.tex}
 
@@ -24,3 +28,8 @@
 
 
 \end{document}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: t
+%%% End:

455-Codage_Sources/Cours/chap1.tex

@@ -277,16 +277,15 @@ Pour qu'un code binaire soit préfixe (ou décodable de manière uniquer), \emph
 
 \section{Code de longueur minimale}
 On considère une source $X$ sans mémoire d'alphabet $\X = \{a_1,...,a_J\}$ et de probabilités $p_j = Pr(X=a_j)$.
-On souhaite construire un code préfixe de longueur moyenne minimale associé à $X$.\\
+On souhaite construire un code préfixe de longueur moyenne minimale associé à $X$.
-
 Si on note $l_1,...,l_J$ les longueurs des mots de codes associés à $a_1,...a_J$ la longueur moyenne sera:
 \[\overline{l}=\sum_{j=1}^Jp_jl_j\]
 
 On cherche à minimiser $\overline{l}$ en s'assurant que le code reste préfixe, c'est à dire que:
  \[\sum_{j=1}^J2^{-l_j} \leq 1 \text{ ou } \sum_{j=1}^J2^{-l_j} - 1 \leq 0\]
 
-C'est un problème d'optimisation sans contrainte que l'on résout en introduisant le Lagrangien:
+Il s'agit d'un problème d'optimisation sous contrainte que l'on résout en introduisant le Lagrangien, avec $\mu$ le multiplicateur de Lagrange:
- \[L(l_1,...l_J,\mu) = \sum_{j=1}^Jp_jl_j + \mu\times (\sum_{j=1}^J2^{-l_j} - 1) \text{  avec $\mu$ le multiplicateur de Lagrange}\]
+ \[L(l_1,...l_J,\mu) = \sum_{j=1}^Jp_jl_j + \mu\times (\sum_{j=1}^J2^{-l_j} - 1) \]
 
 Une condition nécessaire d'optimisation est que:
  \[\left\{ \begin{matrix}
@@ -314,75 +313,97 @@ Une condition nécessaire d'optimisation est que:
     Le meilleur code préfixe a une longueur moyenne au minimum égale à l'entropie de la source.
  \[ \boxed{ \overline{l} = \sum_{j=1}^J p_j(-log_2p_j) = H(x)}\]
 \end{prop}
- \begin{rem}
- L'entropie (avec une source sans mémoire) donne une borne supérieure de la quantité d'information réelle contenue dans un message. Dans le cas d'un texte, l'entropie au sens d'une source de Makorv diminue quand on augmente l'ordre, jusqu'à se stabiliser au bout d'un certain ordre.
- \end{rem}
 
- \begin{prop}[Code préfixe à longueur minimale]
+\begin{rem}
+ L'entropie (avec une source sans mémoire) donne une borne supérieure de la quantité d'information réelle contenue dans un message. Dans le cas d'un texte, l'entropie au sens d'une source de Makorv diminue quand on augmente l'ordre, jusqu'à se stabiliser au bout d'un certain ordre.
+\end{rem}~
+
+\begin{prop}[Code préfixe à longueur minimale]
    \begin{itemize}
     \item Si $p_i\ge p_j$, $l_i\le l_j$
     \item Les noms de codes associé aux deux symboles les moins probables sont de même longueur
     \item Les noms de codes associé aux deux symboles les moins probables ne diffère que d'un seul bit à la fin.
    \end{itemize}
  \end{prop}
-
 \subsection{Codage de Huffmann}
-
+On considère une source $X$ à valeurs dans $\X$, de probabilités associées $p_i=Pr(X=a_i)$, pour $i\in\X$.
-On considère une source $X$ à valeurs dans $\X$, de probabilités associées $p_i=Pr(X=a_i)$, pour $a_i\in\X$.
-
-\paragraph{Code préfixe à longueur minimale}
-Pour qu'un code à longueur variable préfixe $C$ de longueurs de mots de code $l_1,...,l_j$ soit un code de Huffmann, il faut que :
-\begin{itemize}
-\item $p_i \leq p_j \Rightarrow l_i \geq l_j, \forall i,j$
-\item les deux mots de codes associés aux symboles les moins probables aient la même longueur
-\item parmi tous les mots de code de longueur maximale, deux d'entre eux ne diffèrent que par le dernier bit.
-\end{itemize}
-
 \paragraph{Principe d'un code de Huffmann}
 À partir de ces propriétés, on peut fabriquer un code de Huffmann.
 
 Initialement, on considère une source $X^{(0)}$ à $J$ symboles $\X=\{a_1,\dots a_J\}$
 
 \begin{enumerate}
-\item On identifie les deux symboles $a_i^{(0)}$ et $a_j^{(0)}$ les moins probables, avec les probabilités associées $p_i^{(0)}$ et $p_j^{(0)}$
+\item \textbf{Entrée} $\chi =\{1 ... N\} , \vec{p} = (p_1...p_n)^TT$
-\item On fabrique une source fictive $X^{(1)}$ émettant tous les symboles de $\X$ sauf $a_i^{(0)}$ et $a_j^{(0)}$, remplacé par le symbole fictif $a_{ij}^{(0)}$ de probabilité $p_i^{(0)}+p_j^{(0)}$.
+\item Si $N=2$
-
+  \begin{itemize}
-$\X^{(1)}$ comporte $J-1$ éléments.
+  \item $\mathcal{C}=\{0,1\}$
-
+  \item renvoyer $\mathcal{C}$
-\item On répète 1 et 2 jusqu'à ce qu'il n'y ait plus que deux symboles.
+  \end{itemize}
+\item Sinon :
+  \begin{itemize}
+  \item Trouve les indices $i$ et $j$ des deux symboles les moins probables.
+  \item Construire $
+    \begin{array}{l}
+      \chi'= \{1,...,i-1,...,i',i+1,...,j-1,j',j+1,...,N\}\\
+      \vec{p}' = (p_1, ...,p_{i-1},p_i+p_j,p_{i+1},...,p_{j-1},p_{j+1},...,p_N)
+    \end{array}$
+    \item $\mathcal{C}' = (\chi',\vec{p}')$.
+    \item On fabrique $\mathcal{C}$ à partir de $\mathcal{C}'$ en rajoutant $0$ ou $1$ à $c_i'$ Soit :
+      \[
+        \mathcal{C}=\{ c_1,...,c_{i-1},(c_i';0),c_{i+1},...,c_{j-1},(c_i',1)\}
+      \]
+  \end{itemize}
 \end{enumerate}
 
-Au bout de $J-2$ itérations, il reste deux symboles $\X^{(J-2)} = \{a_1^{(J-2)},a_2^{(J-1)}\}$. Le premier est identifié avec un 0, le second avec un 1.\\
-
-Si $a_1^{(J-2)}$ est un symbole fictif résultant du regroupement de deux symboles $a_1^{(J-3)}$ et $a_2^{(J-3)}$ alors le code associé à ces deux symboles est obtenu en rajoutant 0 ou 1 au code associé à $a_1^{(J-2)}$.\\
-
-Plus généralement, si $\underline{C}$ est le code associé au symbole fictif $a_i^{k)}$ résultant du regroupement de $a_i^{(k-1)}$ et $a_j^{(k-1)}$, alors le code de $a_i^{(k-1)}$ sera $\underline{C} 0$ et le code de $a_j^{(k-1)}$ sera $\underline{C} 1$.\\
-
 \begin{prop}
-
+  On montre que la longueur moyenne $\overline{l}$ d'un code de Huffmann associé à une source satisfait
-On montre que la longueur moyenne $\overline{l}$ d'un code de Huffmann associé à une source satisfait \[ H(x) \leq \overline{l} \leq H(X) +1 \]
+  \[ H(x) \leq \overline{l} \leq H(X) +1 \]
-
+  On peut obtenir des codes plus performants en codant des paires de symboles, des triplets... des N-uplets de symboles. Avec ce type de technique, la longueur moyenne $\overline{l}$ par symbole de la source initiale satisfait :
-On peut obtenir des codes plus performants en codant des paires de symboles, des triplets... des N-uplets de symboles. Avec ce type de technique, la longueur moyenne $\overline{l}$ par symbole de la source initiale satisfait : \[H(X) \leq \overline{l} \leq H(X)+1 \]
+  \[H(X) \leq \overline{l} \leq H(X)+1 \]
-
+  L'inconvénient est la taille de la table de Huffmann à gérer.
-L'inconvénient est la taille de la table de Huffmann à gérer.
 \end{prop}
-\newpage
+
+\begin{rem}
+  \begin{itemize}
+  \item Ce type de code est efficace lorsque $H(x) \gg 1$.
+
+  \item Dans le cas ou $H(x)< 1$ il est possible de construire un code de Huffman pour des groupes de $M$ symboles. Dans ce cas on a :
+    \[
+      MH(x) \le \overline{l_M} < MH(x)+1
+    \]
+\end{itemize}
+\end{rem}
+Il reste cependant plusieurs problèmes :
+\begin{itemize}
+\item Grande taille du code de Huffmann
+\item Il faut donner les infos nécessaires aux décodeur pour le décodage:
+  \begin{itemize}
+  \item On transmet le code(couteux)
+  \item On transmet le vecteur de probabilité $\vec{p}$ (plus complexe)
+  \item On utilise un code standardisé (ex: JPEG)
+  \end{itemize}
+\end{itemize}
+\paragraph{Exercice:} Coder l'algorithme de Huffman dans le langage de votre choix.
+
 \subsection{Codage arithmétique}
 
 On considère une source binaire $X$ avec $p_0=Pr(X=0)$ et $p_i=Pr(X=i)$.
-
 Cette source génère un message $x_{1:N}$ de longueur $N$.
-
-
 On va associer un code $\underline{c}(x_{1:N})$ à $x_{1:N}$ qui sera un nombre dans l'intervalle $[0,1[$.
 
+
+\paragraph{Exercice:} Construire une fonction \texttt{a = binaire(x,m)} qui donne les $m$ premier bits de la représentation binaire de $x\in [0,1]$.
+
 On essaie de représenter $\c(x_{1:N})$ avec peu de bits si $x_{1:N}$ est très probable et avec plus de bits si $x_{1:N}$ est moins probable.
 
-\subsubsection{Algorithme de codage arithmétique (codage d'Elias)}
+\subsubsection{Algorithme de codage arithmétique en précision inifinie}
 
-\paragraph{Initialisation} $l_0=0, \quad h_1 = 1,\quad n=1$
+On considère une source binaire sans mémoire décritre par $p=(p_0,p_1)^T$ et ayant généré $x = (x_1 ... x_n)$ à coder.
 
-\paragraph{Étapes}
+\begin{enumerate}
+\item \textbf{Initialisation} $l_0=0, \quad h_0 = 1,\quad i=1$
+
+\item \textbf{Étapes : pour n allant de 1 à N}
 \begin{enumerate}
 \item Si $x_n=0$ alors $l_n=l_{n-1}$ et $h_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$
 \item Si $x_n=1$ alors $l_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$ et $h_n=h_{n-1}$
@@ -391,46 +412,70 @@ On essaie de représenter $\c(x_{1:N})$ avec peu de bits si $x_{1:N}$ est très
 \item On a $h_N-l_N=p(x_{1:N})$
 \end{enumerate}
 
-On pose $\mu(x_{1:N}) = \frac{l_N+h_N}{2} \text{ et } \lambda(x_{1:N}) = \lceil - \log_2(p(x_{1:N})) \rceil + 1$
+\item On pose \[
-
+    \lambda(\vec{x}) = \frac{l_N+h_N}{2} \text{ et } \mu(\vec{x}) = \lceil-\log_2(h_n-l_n))\rceil\]
-\[ \overline{c}(x_{1:N}) = \lfloor \mu(x_{1:N}) \rfloor _{\lambda(x_{1:N})} \]
+\item On a alors le code arithmétique associé:
-
+\[ \overline{c}(\vec{x}) = \lfloor \lambda(\vec{x}) \rfloor _{\mu(\vec{x)+1}} \]
+\end{enumerate}
 où $\lfloor a \rfloor _{\lambda}$ est la représentation binaire de $a$ tronquée à $\lambda$ bits. (Exemple : $\lfloor 0,1011 \rfloor _2 = 0,10$)\\
+\subsubsection{Algorithme de décodage arithmétique en précision infinie}
+Le décodeur arithmétique va chercher à déterminer les selections des sous intervalles faites par le codeur.\\
 
-Il faut montrer que $c(x_{1:N}) \in [l_N,h_N[$ (et qu'alors on pourra décoder), et que cette procédure de codage est efficace. \\
+\textbf{Entrée}: $\vec{c},\vec{p},N$
+\begin{enumerate}
+\item Initialisation : $[l_0,h_0[ = [0,1[$
+  On note $\tilde{\lambda}$ le nombre dont la représentation est $\vec{c}$
 
+\item \textbf{Pour i allant de 1 à n}:
+  \begin{itemize}
+  \item Si $\tilde{\lambda}\in[l_{i-1},l_{i-1}+p_0(h_{i-1}-l_{i-1})]$ alors : $x_i=0$ et $[l_i,h_i[ = [l_{i-1},l_{i-1}+p_0(h_{i-1}-l_{i-1})]$
+    \item sinon $x_i=1$ et $[l_i,h_i[ = [l_{i-1}+p_0(h_{i-1}-l_{i-1}),h_{i-1}]$
+  \end{itemize}
+\end{enumerate}
+
+\subsubsection{Performance}
+
+Il faut montrer que $c(x_{1:N}) \in [l_N,h_N[$ (et qu'alors on pourra décoder), et que cette procédure de codage est efficace, ie $E(\mu(X_1...X_N ))\simeq NH(x)$
 
 
 \begin{itemize}
-\item On sait que $c(x_{1:N}) \leq \mu(x_{1:N})$ et on veut montrer que $\mu(x_{1:N})-c(x_{1:N}) \leq \frac{h_N-l_N}{2}$.\\
+\item On sait que $c(\vec{x}) \leq \mu(\vec{x})$ et on veut montrer que :
-
-Avec par exemple
-$\mu(x_{1:N}) = 0,101xxx$ et $c(x_{1:N})=0,101$, alors
-\[ \mu(x_{1:N}) - c(x_{1:N}) = 0,000xxx \leq \sum_{i=4}^6 2^{-i} \]
-
-
-Ainsi dans le cas général,
-\[ \mu(x_{1:N}) - c(x_{1:N}) \leq \sum_{i=\lambda(x_{1:N})+1}^{+\infty} 2 ^{-i} = 2^{-\lambda(x_{1:N})} \]
-
-Or, on a $\lambda(x_{1:N}) = -\lceil \log_2(p(x_{1:N})) \rceil + 1$
 \[
-\begin{array}{ccccc}
+\lambda(x)-\lambda(\vec{x}) \leq \frac{h_N-l_N}{2}
-- \log_2(p(x_{1:N})) + 1 & \leq & \lambda(x_{1:N}) & < & -\log_2(p(x_{1:N})) + 2 \\
-\log_2(p(x_{1:N})) - 1 & \geq & -\lambda(x_{1:N}) & > & \log_2(p(x_{1:N})) - 2 \\
-2^{\log_2(p(x_{1:N})) - 1} & \geq & 2^{-\lambda(x_{1:N})} & > & 2^{\log_2(p(x_{1:N})) - 2} \\
-\end{array}
 \]
-\[ \frac{p(x_{1:N})}{2} \geq 2^{-l(x_{1:N})} \]
+On considère la représentation binaire de $\lambda(\vec{x})$:
+\[
+  \tilde{\lambda} = \sum_{i=1}^{n}a_i2^{-i}
+\]
+Pour $\tilde{\lambda}(\vec{x})$ on a :
+\[
+  \tilde{\lambda} = \sum_{i=1}^{\mu(\vec{x})+1}a_i2^{-i}
+\]
+D'où:
 
-Ainsi, $\mu(x_{1:N}) - c(x_{1:N}) \leq 2^{-\lambda(x_{1:N})} \leq \frac{p(x_{1:N})}{2} = \frac{h_N-l_N}{2}$ donc  $c(x_{1:N}) \in [l_N,h_N[$ (donc on pourra décoder).
+  \begin{align*}
+  \lambda(\vec{x})-\tilde{\lambda}(\vec{x}) &= \sum_{i=\mu(\vec{x})+2}^{\infty}a_i2^{-i} \\
+                               &\leq \sum_{}^{} 2^{-i}\\
+                               &\leq 2^{-\mu(\vec{x}+1)}
+  \end{align*}
+
+  Or
+  \[
+  \begin{array}{ccccc}
+
+2^{-\mu(\vec{x})+1} &=& 2^{-\left(\lceil -\log_2(h_n-l_n)\rceil+1\right)}&&\\
+1 -\log(h_n-l_n) &\le& \lceil -\log_2 (h_n-l_n)\rceil+1 &\leq& -\log_2(h_n-l_n)+1+1\\
+-2 + \log(h_n-l_n ) & <& \lceil - \log_2( .)\rceil +1 &\le& -1 + \log_2(.)\\
+\frac{h_n-l_n}{4}&\le& 2- &\le& \frac{h_n-l_n}{2}
+  \end{array}
+\]
 
-\newpage
 \item L'efficacité du codage est montrée en calculant la longueur moyenne du code obtenu :
-\[ \overline{l} = \sum_{x_{1:N}\in\X^N} p(x_{1:N}) \lambda(x_{1:N}) \]
+\[ \overline{l} = \sum_{\vec{x}\in\X^N} p(\vec{x}) \lambda(\vec{x}) \]
 
-En utilisant le premier encadrement de $\lambda(x_{1:N})$, alors
+En utilisant le premier encadrement de $\lambda(\vec{x})$, alors
 \[ \begin{array}{ccccc}
-- \sum_{x_{1:N}} p(x_{1:N})( \log_2(p(x_{1:N}))-1) & \leq & \overline{l} & < & -\sum_{x_{1:N}} p(x_{1:N})(\log_2(p(x_{1:N}))-2) \\
+- \sum_{\vec{x}} p(\vec{x})( \log_2(p(\vec{x}))-1) & \leq & \overline{l} & < & -\sum_{\vec{x}} p(\vec{x})(\log_2(p(\vec{x}))-2) \\
 NH(X) + 1 & \leq & \overline{l} & < & NH(X) + 2
 \end{array}
 \]
@@ -438,8 +483,6 @@ NH(X) + 1 & \leq & \overline{l} & < & NH(X) + 2
 Cette procédure est efficace pour $N\to +\infty$, avec l'$\infty$ petit. Par exemple, pour $N=100$, alors la longueur moyenne sera proche à $1\%$ de l'entropie.
 \end{itemize}
 
-\paragraph{Décodage}
-On part de $c(x_{1:N})$, on réalise le découpage de $[0,1[$ suivant les probabilités d'apparition de 0 et de 1. À chaque étape, l'intervalle auquel appartient $c(x_{1:N})$ permet de déterminer le bit codé.\\
 
 \subsubsection{Réalisation pratique}
 En pratique, le codage utilise l'intervalle $[0,2^p[$ où $p$ désigne la précision du codeur arithmétique. (pour le codage H264/AVC, on a $p=9$).