C'est une fonction décroissante sur ]0,1] qui s'annule en 1. En effet, l'information associée à quelque chose de certain ($p_i=1$) est nulle, alors que celle associée à quelque chose de peu probable ($p_i\rightarrow0$) est très grande $(\rightarrow\infty)$.
Avec un modèle de Markov, si on essaie de "créer" des mots lettre par lettre, plus on monte dans les ordres, plus la structure de la langue commence à apparaître. À partir de l'ordre 3, il apparaît des mots qui seraient potentiellement de la langue considérée. Ce modèle peut être adapté, comme par exemple pour le correcteur orthographique des téléphones.\\
L'idée générale de la compression d'une source de Markov est d'effectuer des prédictions pour avoir accès aux informations, de sorte qu'il ne reste à transmettre que ce que l'on ne peut pas prédire.\\
Un \emph{code} est un ensemble binaire de $\{0,1\}^*$ (union de tous les ensembles $\{0,1\}^2=\{00,11,01,10\}$ , $\{0,1\}^3= ...$ ...). Un code est donc un sous-ensemble de $\{0,1\}^*$.\\
Attention, ce sont des théorèmes d'existence : ils ne peuvent pas servir à vérifier qu'un code est préfixe ou décodable de manière unique.
\begin{exemple}
Le code $\{1,00,10\}$ n'est pas préfixe, pourtant on a $\sum2^{-l_i}=2^{-1}+2^{-2}+2^{-2}=1$. On sait seulement qu'il existe un code préfixe dont les mots de code ont ces longueurs.
\end{exemple}
\end{rem}
\begin{rem}
On sait que "préfixe" implique "décodable de manière unique". En revanche, si un code est décodable de manière unique, on peut seulement dire qu'il existe un code préfixe équivalent, sans qu'il soit le même.
Le meilleur code préfixe a une longueur moyenne au minimum égale à l'entropie de la source.\\
\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.
\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 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)}$.
$\X^{(1)}$ comporte $J-1$ éléments.
\item On répète 1 et 2 jusqu'à ce qu'il n'y ait plus que deux symboles.
\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$.\\
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\]
L'inconvénient est la taille de la table de Huffmann à gérer.
Ainsi, $\mu(x_{1:N})- c(x_{1:N})\leq2^{-\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).
\newpage
\item L'efficacité du codage est montrée en calculant la longueur moyenne du code obtenu :
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é.\\
\paragraph{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$).
On réalise des homothéties de centre 0, de rapport $2^p$ ou $2^{p-1}$ avec ou sans émission de bits.
On estime les probabilités d'apparition des bits en parallèle du codage au codeur et au décodeur, et on modifie la façon de découper les intervalles en fonction de ces probabilités d'apparition estimées.
On obtient alors un CABAC : Context Adaptative Binary Arithmetic Coder.
\begin{rem}
Si on a plusieurs symboles à coder (A,B,C), on pourrait faire un codeur arithmétique ternaire, mais on préfaire binariser les données (A=00,B=01,C=10) et utiliser un codeur arithmétique binaire, qui est plus pratique pour les remises à l'échelle.
\end{rem}
\newpage
\subsection{Code de Lempel-Ziv-Welch}
\paragraph{Idée}
Avant l'algorithme arithmétique adaptatif, il fallait avoir les probabilités d'apparition des symboles (Huffmann, codage arithmétique,...). Le code LZW permet de faire une compression sans passer par la phase d'estimation des probabilités des symboles. Par exemple pour un texte, l'alphabet est gros, et le codeur arithmétique ne fonctionne pas très bien pour les gros alphabets, car il utilise d'abord une phase de binarisation.\\
\subsubsection{Codage}
Le codage de LZW est une variante des codes LZ77 et LZ78 qui utilise un dictionnaire et n'a pas besoin des probabilités de la source. C'est un cde universel.\\
On considère une source $X$ à valeurs dans $\X=\{a,b,c\}$.
\begin{enumerate}
\item On initialise le dictionnaire de codage à l'aide des symboles de l'alphabet $\X$.
\item On cherche la plus longue suite de symboles restant à coder et appartenant au dictionnaire et on la code.
\item On rajoute cette suite suivi du premier symbole non codé $\omega$ au dictionnaire.
\item Aller en 2 tant qu'il existe des symboles à coder.
\end{enumerate}
\begin{exemple}
On a à coder la séquence $aabababca$.
\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|}
\hline
$a$&$b$&$c$&$aa$&$ab$&$ba$&$aba$&$abac$\\
\hline
0 & 1 & 2 & 3 & 4 & 5 & 6 & 7\\
\hline
\end{tabular}
\end{center}
On code $a$, on émet 0 et on ajoute $aa$ au dictionnaire.
On code $a$, on émet 0 et on ajoute $ab$ au dictionnaire.
On code $b$, on émet 1 et on ajoute $ba$ au dictionnaire.
On code $ab$, on émet 4 et on ajoute $aba$ au dictionnaire.
On code $aba$, on émet 6 et on ajoute $abac$ au dictionnaire.
On code $c$, on émet 2.
\end{exemple}
\subsubsection{Décodage}
Le décodage se fait
\begin{enumerate}
\item à partir du dictionnaire initial
\item à chaque décodage d'un mot, on rajoute ce mot suivi de $\omega$ au dictionnaire
\item$\omega$ n'est déterminé que si on a décodé le mot suivant
\end{enumerate}
\begin{exemple}
On a à décoder 001462.\\
On décode $a$, on ajoute $a\omega$ (3) au dictionnaire.
On décode $a$, donc le (3) est $aa$ et on ajoute $a\omega$ (4) au dictionnaire.
On décode $b$, donc le (4) était $ab$ et on ajoute $b\omega$ (5) au dictionnaire.
On décode $ab$, donc le (5) était $ba$ et on ajoute $ab\omega$ (6) au dictionnaire.
On décode $ab\omega$, qui était en fait un $aba$ et on ajoute $aba\omega$ (7) au dictionnaire.
On décode $c$ donc le (7) était $abac$.
\end{exemple}
En pratique :
\begin{itemize}
\item les codes générés sont à nouveau codés à l'aide d'un code de Huffmann
\item la taille du dictionnaire est limitée, les mots les moins utilisés sont effacés.
