\documentclass{article}
\input{../../preambule/preambule}

\newcommand{\nom}{TD1 : Codage de Sources}
\renewcommand{\nomentete}{UE455 - \nom}



\begin{document}

\titre{\nom}

\begin{center}
TD et TP : remi.azouit@ens-cachan.fr
\end{center}

\section*{Point de cours sur le codage de Huffman}

Il s'agit d'un codage préfixe construit de façon récursive. Avec un codage préfixe, on n'a pas besoin de recevoir tout pour décoder. On peut décoder au fur et à mesure de la réception. Dans un code préfixe, chaque code ne peut pas être le début d'un autre code.

\begin{exemple}

On considère une source $X$ à valeurs dans $\X=\{A,B,...G\}$. 

On a $p_A=3/8,\quad p_B=3/16, \quad p_C=3/16, \quad p_D=1/8,\quad p_E=1/16,\quad p_F=1/32,\quad p_G=1/32$.\\

Pour construire le codage, on range les symboles par probabilité d'apparition décroissante et on construit un arbre en associant à chaque fois les deux probabilités les plus faibles. Ainsi, les symboles les plus probables ont les codes les plus courts. Si on a deux probabilités qui sont égales, on peut choisir de façon équivalente l'une des deux : le codage sera différent mais tout aussi efficace.

\begin{figure}[h!]
\centering
\includegraphics[scale=0.5]{arbre1.png}
\end{figure}

\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|}
\hline 
$X$ & A & B & C & D & E & F & G \\ 
\hline 
Code & 1 & 011 & 010 & 001 & 0001 & 00001 & 00000 \\ 
\hline 
\end{tabular} 
\end{center}

\begin{rmq}
Pour coder un texte, on peut soit utiliser des probabilités et donc des codes "généraux", ou alors les recalculer à chaque fois.
\end{rmq}
\end{exemple}

\newpage
\section*{Exercice 1 : Codage de Huffman}

\begin{enumerate}
\item Construction de l'arbre puis codage

\begin{figure}[h!]
\centering
\includegraphics[scale=0.5]{arbre2.png}
\end{figure}

\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
\hline 
X & D & B & A & F & E & C & G & H \\ 
\hline 
Code & 00 & 10 & 010 & 110 & 111 & 0110 & 01110 & 01111 \\ 
\hline 
\end{tabular} 
\end{center}

\item $R = \sum_{x\in\X}p_x \times l_x$ où $l_x$ est la longueur du code associé à $x$

Ainsi, $R=2.83$ bits/symbole.

\item L'entropie est le nombre minimal de bits par symbole nécessaire pour représenter la source: 

$H=-\sum_{x\in\X} p_x \log_2 p_x$

Ainsi $H=2.7978$ bits/symbole.\\

On a bien $H \leq R$. Notre codage n'est pas le codage optimal.

\begin{rmq}
On obtiendrait $R=H$ dans le cas où toutes les probabilités étaient des puissances de 2.
\end{rmq}

\item Le code correspondant à $ABAADE$ est :
$010|10|010|010|00|111$
\end{enumerate}

\newpage
\section*{Exercice 2 : Codage d'une source de Markov}

\begin{enumerate}
\item Le nombre minimal de bits par symbole est déterminé par l'entropie. Le code le plus efficace aurait donc un nombre moyen de bits par symbole égal à l'entropie $H=\sum p_i \log(\frac{1}{p_i}) = 1.19$ bits/symbole.

\item Construction de l'arbre puis du codage

\begin{figure}[h!]
\centering
\includegraphics[scale=0.5]{arbre3.png}
\end{figure}

\begin{center}
\begin{tabular}{|c|c|c|c|c|}
\hline 
X & ADD & STO & SUB & MPY \\ 
\hline 
\hline
CODE & 0 & 10 & 110 & 111 \\ 
\hline 
\end{tabular} 
\bigbreak
\end{center}
On calcule alors le débit moyen R = $\sum_{x \in \X} pr(x).Nbbit(X)$ = 1.375 bit/symbole\\

On a une valeur supérieure à l'entropie mais inférieure à la valeur initiale. Cool! Notre codage n'est pas optimal mais est meilleur que le premier proposé.\\


On considère maintenant le modèle de Markov d'ordre 1 pour modéliser la succession d'instructions constituany un programme. La matrice de transmission de ce modèle est donnée par:
\[P_{j|i} = \begin{pmatrix}
\frac{13}{16}&\frac{1}{16}&\frac{1}{16}&\frac{1}{16}\\
0&0&0&1\\
\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\\
1&0&0&0
\end{pmatrix}\]
\begin{enumerate}
\item Montrer que $p = \left(\frac{3}{4}\frac{1}{16},\frac{1}{16}, \frac{1}{8} \right)$ représente bien la distribution de probabilité stationnaire de la source de Markov d'ordre 1.\\
Il s'agit de vérifier que $p\times P_{j|i} = p$.\\

\underline{Remarque}:  On peut aussi voir ce résultat sous la forme plus courante $p^T = P_{j|i}^T p^T$. Ceci permet notamment de calculer $p$ s'il n'est pas donné, en cherchant un vecteur propre de $P_{j|i}^T$.\\

\item Calculer les probabilités moyennes d'avoir une succession des deux instructions suivantes :\\

\underline{Remarque}: ne pas confondre les lignes et les colonnes dans $P_{j|i}$:
\[P_{j|i} = \begin{pmatrix}
p_{ADD|ADD} & p_{SUB|ADD} & p_{MPY|ADD} & p_{STO|ADD}\\
p_{ADD|SUB} & p_{SUB|SUB} & p_{MPY|SUB} & \vdots \\
\vdots & \dots & \dots & \vdots\\
p_{ADD|STO} & \dots & \dots & p_{STO|STO}
\end{pmatrix}\]
On a donc avec la règle de Bayes :
\begin{align*}
p(STO - ADD) &= p(ADD_j | STO_{j-1}).p(STO_{j-1})\\
&= 1 \times \frac{1}{8}\\
&= \frac{1}{8}\\
p(ADD - ADD) &= \frac{13}{16}\times \frac{3}{4}\\
&= \frac{39}{64}\\
p(SUB-MPY) &= 0 \times \frac{1}{16}\\
&= 0
\end{align*}
On peut calculer les autres probabilités cumulées de la même façon à partir des probabilités conditionnelles en les piochant dans le tableau.(Elles seront toutes données à la question 4.)\\

\item En utilisant le modèle de Markov d'ordre 1, dans quelles proportions est-il possible de réduire le nombre moyen de bits utilisés pour coder une instruction?\\

On calcule donc l'entropie $H=0.87$bit/symbole. On a une entropie inférieur à l'entropie initiale. Ceci vient du fait que l'on a un couplage des symboles, donc plus d'informations pour un même nombre de bits transmis.\\
\end{enumerate}

\item 
On commence par rappeler toutes les probabilités cumulées ordonnées:\\
\begin{center}
\begin{tabular}{|c|c|c|c|c|c|}
\hline 
X & ADD-ADD & STO-ADD & SUB-STO & ADD-SUB & ADD-MPY \\ 
\hline 
Pr(X) & $\frac{39}{64}$ & $\frac{8}{64}$ & $\frac{4}{64}$ & $\frac{3}{64}$ & $\frac{3}{64}$ \\ 
\hline 
\hline
X & ADD-STO & MPY-ADD & MPY-SUB & MPY-MPY & MPY-STO \\ 
\hline 
Pr(X) & $\frac{3}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ \\ 
\hline 
\end{tabular} 
\end{center}
\bigbreak
On a alors $R = \frac{1.98}{2}$ bit/instruction. (On divise par 2 car on a 2 instructions codées à chaque fois)
\end{enumerate}

\newpage
\section*{Exercice 14 : Codage de source distribué}

\begin{enumerate}

\item On a 8 possibilités et toutes équiprobables donc :
\begin{align*}
H(X) &= -\sum p_i log_2 p_i\\
&= -8 (\frac{1}{8} log_2 \frac{1}{8})\\
H(X) &= 3 bit/symbole =  H(Y)
\end{align*}

\item On a $d_H(x_k,y_k) \leq 1$ ce qui impose certaines combinaisons. Pour un x donné, il y a 4 possibilités de y. On a donc $8\times 4 =32$ possibilités toutes équiprobables.\\
Ainsi, $H(x_k,y_k) = 5$ bit/symbole.\\

\item On a par propriété : $H(X,Y) = H(X|Y) + H(Y)$, or si X et Y sont indépendants alors $H(X|Y) = H(X)$ donc on a $H(X|Y) = H(X) + H(Y)$.\\
Comme on n'a pas cette égalité, c'est que X et Y sont corrélés.\\

\item Il faut 3 bits pour coder $x_k$\\
%Trou du cul!!!
\item $H(X,Y) = H(X|Y) + H(Y)$ donc on a clairement $H(X|Y)=2$.\\

Comme $d_H(x_k,y_k) \leq 1$, on a qu'un seul bite de différent. Il suffit donc de coder la position du bite différent, 00 si identique, 01 pour le premier etc.\\

\item Pour coder le couple, il ne faut plus que 5 bits.\\

\item Dans ce cas, s'ils ne communiquent pas, on va devoir coder avec 6 bits.\\

\item 4 ensembles, donc on n'a besoin que de deux bits.\\

\item On a donc besoin que de 5 bits.\\

\item On connaît x et l'index de y, et x a un bit de différent avec l'une des deux possibilités de l'ensemble correspondant à l'index donné par y. Ces 2 possibilités sont distantes de 3, donc x ne peut être distant de 1 qu'avec l'un des deux. On peut donc retrouver (seulement car $d_H(x,y)\leq 1$) y à partir de x.\\

\item  On alors R=H !!! \huge youuuupiiiiiiiiii \small
\end{enumerate}

\newpage
\section*{Exercice 13 : Codage par plages de zéros}
\begin{enumerate}
\item On calcule l'entropie de cette source: $H(X) = -(p log(p) + (1-p)log(1-p))$\\

\item Huffman serait inefficace (inutile) car il y a seulement 2 symboles à coder.\\

\item On a $y \in [0;+\infty [$.\\

\item On a $P_0 = p$, $P_1 = p(1-p)$, $P_2 = p(1-p)^2$ et $P_k = p(1-p)^k$.\\

\item On a $H(Y) = -\sum_{k=0}^{\infty} P_k logP_k$.\\

\item \begin{align*}
H(Y) &= - \sum_{k=0}^{\infty}p(1-p)^klog(p(1-p)^k)\\
&= - \sum_{k=0}^{\infty}p(1-p)^k(log(p)+klog(1-p))\\
&= -log(p) - \frac{1-p}{p} log(1-p)
\end{align*}

\item On part de $-log(p_k) \leq \lceil-log(p_k) \rceil \leq -log(p_k) + 1$ en multipliant par $p_k$ et n sommant sur l'infini, on identifie l'entropie et on obtient: 
\[H(Y) \leq l(Y) \leq H(Y) +1 \]

\item k pour Y représente k+1 bits pour X.
\end{enumerate}


\end{document}