Chapter 2

SOURCES DISCRETES
Marc URO
TABLE DES MATIERES
ENTROPIE D'UNE SOURCE DISCRETE ................................................................ ...3
CODAGE DE SOURCE ................................................................ ............................... 8
GENERALITES SUR LES CODES ................................................................ ....9
CODAGE D'UNE VARIABLE ALEATOIRE DISCRETE................................14
CODAGE D'UNE SOURCE ................................................................ .............. 16
CODES A LONGUEUR VARIABLE....................................................... 16
CODES BLOC................................................................ .......................... 35

3
SOURCES DISCRÈTES
ENTROPIE D'UNE SOURCE DISCRÈTE
Exemple
On considère les 26 lettres de l'alphabet auxquelles on ajoute le caractère blanc (ou espace)
pour séparer les mots. Si on considère les 27 symboles équiprobables et indépendants, on
obtient une entropie par lettre de H0 = log2 27 = 4, 75 bits . Disposant dans une urne 27
papiers sur chacun desquels est inscrit un des 27 symboles et procédant à des tirages avec
remise, on obtiendrait une séquence du type:
XFOML RHKHJFFJUJ ZLPWCFWCKCYJFFJEYVKCQSGHYD

QPAAMKBZAACIBZLHJQD
Dans une telle séquence, seules les lettres nous sont familières (par leur agencement). Un
modèle plus fin consiste à estimer les probabilités d'apparition des lettres en effectuant des
statistiques à partir des textes écrits. Shannon a réalisé ces statistiques sur des textes anglais et
il a obtenu:
Lettre Fréquence Lettre Fréquence Lettre Fréquence

relative relative relative
- 0,182 H 0,043 P 0,016
E 0,107 D 0,031 W 0,013
T 0,086 F 0,028 B 0,012
A 0,067 L 0,024 V 0,007
O 0,065 C 0,023 K 0,003
N 0,058 M 0,021 X 0,001
R 0,056 U 0,020 J 0,001
I 0,052 G 0,016 Q 0,001
S 0,050 Y 0,016 Z 0,001
4 ____________________________________________________________ sources discrètes
Le calcul de l'entropie par lettre effectué à partir de ces fréquences relatives d'apparition des
27
lettres (assimilées à des probabilités) conduit à H1 = − ∑ pi log2 pi = 4,029 bits . En effectuant
i =1
de nouveaux tirages avec remise dans une urne contenant les lettres dans les proportions
correspondant aux fréquences relatives du tableau précédent, on obtiendrait une séquence de
la forme:
OCRO HLI RGWR NMIEL VIS EU LL NBNESEBYA TH EEI

ALHENHTTPA OOBTTVA NAH BRL
Cette 'phrase' ressemble un peu plus que la précédente à un texte anglais en ce sens que la
longueur d'un mot y est voisine de la normale et que la répartition du nombre de voyelles et
de consonnes est vraisemblable.
Toutefois cette séquence reste relativement éloignée d'un texte anglais. Ceci tient au fait que
les lettres successives d'un texte ne sont nullement indépendantes les unes des autres (en
anglais la lettre 't' est souvent suivie d'un 'h' tandis qu'elle est rarement suivie d'un 'z' ou d'un
'w').
Pour tenir compte des dépendances entre une lettre et la lettre suivante, il faut effectuer des
statistiques sur les couples de lettres qui apparaissent dans un texte sensé. On peut alors
assigner à chaque couple de lettres une probabilité d'apparition. Ces nombres permettent le
calcul de l'entropie conditionnelle H (U2 / U1) où (U1 ,U2 ) représente le couple formé par une
lettre et la lettre suivante à l'aide de la relation H (U2 / U1 ) = H (U1 ,U2 ) − H(U1 ). La valeur
numérique obtenue est H2 = 3,318 bits . Pour simuler l'expérience en prenant en considération
la dépendance d'une lettre avec la suivante, on procède comme suit:
27 urnes contiennent chacune les couples de lettres avec la même première lettre et dans des
proportions correspondant aux valeurs estimées. On extrait une série de couples de lettres de
ces urnes en notant à chaque fois la seconde lettre. À chaque extraction on tire un couple dans
l'urne dont la lettre correspond à la seconde lettre du tirage précédent. Pour le premier tirage,
on peut déterminer l'urne à partir d'un tirage au sort dans l'urne de l'expérience précédente
(qui donne la première lettre). Le résultat est alors de la forme:
ON IE ANTSOUTINYS ARE T INCORE ST BE S DEAMY ACHIN D

ILONASIVE TUCOOWE AT TEASONARE FUSO TIZIN ANDY TOBE
SEACE CTISBE
sources discrètes ___________________________________________________________ 5
On note cette fois que non seulement les proportions entre voyelles et consonnes sont
convenables, mais qu'en plus les alternances entre voyelles et consonnes se rapprochent de
celles rencontrées dans la réalité, ce qui permet de pouvoir 'prononcer' les mots.
En considérant les relations probabilistes liant les triplets de lettres, on obtiendrait une
entropie conditionnelle H3 = H(U3 / U1 ,U 2 ) = 3,1 bits . Il faudrait maintenant disposer de 27
2
urnes contenant chacune les combinaisons de trois lettres avec les deux premières fixées. En
procédant de façon analogue à l'expérience précédente, on obtiendrait:
IS NO IST LAT WHEY CRATICT FROURE BIRS GROCID

PONDENOME OF DEMONSTRURES OF THE REPTAGIN
IS REGOACTIONA OF CRE
Des mots complets anglais commencent à apparaître. Notons que la prise en compte de huit
lettres consécutives conduit, pour la langue anglaise, à une entropie conditionnelle
H8 ≈ 1,86 bit . Cela signifie qu'en moyenne, dans un texte anglais, l'information apportée par
une lettre est de l'ordre de 1,86 bit. Ce nombre est à comparer avec H0 = 4,75 bits . On dit
1,86
que l'entropie relative est de ≈ 40%. Concrètement cela se traduit par le fait que, dans le
4,75
choix des lettres pour écrire un message en anglais sensé, on est 40% aussi libre qu'on le
serait si on se contentait de choisir de façon équiprobable et indépendante les lettres les unes
après les autres. On dit aussi que la redondance est égale à 1- entropie relative = 60%. En
d'autres termes 40% des lettres sont choisies librement, les 60% restant étant imposés par les
règles de structure du langage.
Revenant à notre exemple, on peut interpréter les nombres H0 = 4,75 bits et H8 = 1,86 bit de
la façon suivante: la prise en compte des redondances du langage conduit à n'utiliser en
moyenne que 1,86 bit pour coder une lettre alors que l'approche plus grossière considérant
les lettres équiprobables et indépendantes exige 4,75 bits..
Plus généralement soit U une source discrète, c'est-à-dire un dispositif susceptible de fournir
des symboles (ou lettres) issus d'un alphabet. On notera U1 ,U2 ,...,U n ,... les variables
aléatoires correspondant aux valeurs émises par la source U aux instants 1,2,...,n,.... La
source est dite stationnaire si sa loi de probabilité ne dépend pas de l'instant considéré
(ie. ∀k les Uk ont même loi).
Comme on l'a fait pour une variable aléatoire pour laquelle on a défini la notion d'entropie, on
souhaiterait caractériser une source par son entropie.
La difficulté tient ici à ce que les variables U1,U2 ,...,U n,... ne sont pas forcément
indépendantes et qu'une définition correcte de l'entropie par lettre de la source doit prendre en
compte les liens probabilistes unissant U1,U2 ,...,U n ,... . Deux approches sont alors
envisageables:
- Première approche
On définit tout d'abord l'entropie par lettre source dans une séquence (ou un mot) de L lettres
1
par H L (U ) = H(U1 , U2 ,...,UL ), puis l'entropie par lettre de la source par Llim H L (U ) .
→ +∞
L
- Deuxième approche
On peut aussi se proposer d'évaluer l'entropie par lettre source par la mesure de l'incertitude
de la Lième occurence de la source connaissant les L-1 précédentes réalisations lorsque L est
grand. Cela revient alors à prendre en compte la quantité:
lim H (U L / U1 ,U2 ,...,U L −1 ) .

L→ +∞
En fait on va montrer que les quantités lim H L (U ) et lim H (U L / U1 ,U2 ,...,U L −1 ) sont
L→ +∞ L→ +∞
égales.
Théorème
Soit U une source discrète stationnaire telle que H1(U) < + ∞ , alors:
- H (U L / U1 ,U2 ,...,U L−1 ) est une fonction décroissante de L (1)
- H L (U ) ≥ H(UL / U1 ,U 2 ,...,U L−1 ) (2)
- H L (U ) est une fonction décroissante de L (3) .

- lim H L (U ) = lim H (U L / U1 ,U 2 ,...,U L −1 ) (4)
L → +∞ L→ +∞
- En conséquence, on définira l'entropie par lettre de la source U par:

H∞ (U ) = lim HL (U ) = lim H(U L / U1 ,U2 ,...,U L −1 )
L→ +∞ L→ +∞
On a vu que le conditionnement diminue l'entropie (ie H ( X / Y ) ≤ H( X )),
donc: H (UL / U1 ,U2 ,...,U L−1 ) ≤ H (UL / U 2 ,...,U L −1 ) et par stationnarité:
H (UL / U 2 ,...,U L −1 ) = H (U L −1 / U1 ,U 2 ,...,U L− 2 ),
H (UL / U1,U2 ,...,U L−1 ) ≤ H (U L −1 / U1 ,...,U L− 2 ), ce qui montre le (1).
Montrons maintenant le (2).

De H (X , Y ) = H(X ) + H (Y / X ) , on déduit:
H (X,Y, Z ) = H (X,Y ) + H (Z / X,Y ) et plus généralement:
H (U1 ,U 2 ,...,U L ) = H (U1 ) + H(U2 / U1 ) + H (U 3 / U1 ,U 2 )+...+ H(UL / U1 ,U 2 ,...,U L −1 ) soit:
H L (U ) = H(U1 , U2 ,...,U L ) = (H (U1 ) + H (U2 / U1 ) + H(U3 / U1, U2 )+...+ H (U L / U1 ,U2 ,..., UL −1 ))

1 1
L L
mais:
H (UL / U 1,U2 ,...,U L ) ≤ H (UL −1 / U1 ,U2 ,...,U L− 2 ) ≤...≤ H (U 2 / U1 ) ≤ H(U1 )
Donc H L (U ) ≥ (L H(U L / U1 ,U 2 ,...,UL−1 ))= H(UL / U1 ,U 2,...,U L−1 ) et (2) est montrée.
1
L
H L (U ) = H (U1 ,U2 ,...,U L ) = (H(U1 ,U2 ,...,U L−1 ) + H (U L / U1 ,U2 ,...,UL −1 ))
1 1
L L
1 1
H L (U ) = H(U1 ,U2 ,...,U L −1 ) + H(UL / U1 ,U 2,...,U L −1 ) et d'après le (2):
L L
H (UL / U 1,U2 ,..., U L−1 ) ≤ H L (U ) donc
1 1
H L (U ) ≤ H(U1 ,U 2 ,...,U L−1 ) + HL (U ) soit:
L L
 1 1
H L (U )1 −  ≤ H(U1 ,U 2 ,..., UL−1 ) d'où:
L L
H(U1 ,U2 ,...,U L−1 ) = H L−1 (U ). Par conséquent le point (3) est montré.
1
H L (U ) ≤
L −1
Les suites H L (U ) et H (UL / U 1 ,U 2 ,...,U L−1 ) (indexées par L) sont décroissantes et positives
(donc minorées). Elles sont donc convergentes.

De plus, on a H L (U ) ≥ H(UL / U1 ,U 2 ,...,U L−1 ). Soit alors H∞ (U ) = lim HL (U ) . On a:
L→ +∞
H∞ (U ) ≥ lim H(UL / U1 ,U 2 ,...,U L −1 ).

L →+ ∞
Il nous reste donc à montrer que H∞ (U ) ≤ lim H(UL / U1 ,U 2 ,...,U L −1 ).

L →+ ∞
H (U 1 ,U 2 ,...,U L+ j ) et:
1
∀ j ∈IN HL + j (U ) =
L+ j
[H(U1 ,U2 ,...,UL −1 ) + H(UL / U1 ,U2 ,...,UL −1) + H(UL +1 / U1,U2 ,...,UL )+...
1
HL + j (U ) =
L+ j
... + H (UL + j / U1 ,U 2 ,...,UL+ j −1 ) ] et
comme le conditionnement diminue l'entropie:

[H(U1 ,U2 ,...,UL −1 ) + ( j + L )H(UL / U1 ,U2 ,...,UL −1)]. En faisant tendre L
1
HL + j (U ) ≤
L+j
vers l'infini, on obtient:

H∞ (U ) ≤ lim H(UL / U1 ,U 2 ,..., U L −1 ) (cqfd)
L →+ ∞
Remarques (corollaire du théorème)
- Si U est une source sans mémoire (ie les Uk sont indépendants), alors H∞ (U ) = H(U1 )
- Si U est une chaîne de Markov homogène d'ordre 1, alors H∞ (U ) = H (U 2 / U1 ) .
CODAGE DE SOURCE
Soit U une source discrète à N valeurs possibles et d'entropie H∞ (U ) < log 2 N . L'entropie
H (U )
relative Hr (U ) = ∞ étant strictement plus petite que 1, la redondance r = 1 − Hr (U) est
log2 N
différente de zéro. L'élimination de la partie redondante de l'information délivrée par la
source peut être obtenue en codant les différentes configurations émises par la source. Deux
types de codes peuvent être utilisés:
- Codes à longueur fixe. Tous les mots ont même longueur, c'est-à-dire contiennent le même
nombre de symboles.
- Codes à longueur variable. La longueur des mots varie en fonction de leur fréquence
d'apparition. Un mot sera d'autant plus long que sa probabilité d'apparition sera petite.
L'opération de compaction des données va consister, à l'aide d'un codage adéquat, à réduire
le débit binaire d'une source tout en conservant l'information fournie par celle-ci. On dit aussi
que l'on effectue une compression sans perte d'information. Cette opération se justifie
lorsque des contraintes de stockage ou de transmission de l'information sont imposées. Ceci

nous conduit à examiner les propriétés liées aux codes.
GÉNÉRALITÉS SUR LES CODES
Soit B un alphabet de référence, c'est-à-dire un ensemble de lettres (en général B est

l'alphabet binaire B = {0,1}). En concaténant des lettres de l'alphabet B, on forme des mots
dont la longueur correspond au nombre de lettres utilisées. Un code C est un ensemble de
mots.
Exemple
B = {0,1}
C = {00,01,10,11} est un code de longueur fixe égale à 2.
On dira qu'un code est uniquement déchiffrable si toute suite de mots code ne peut être
interprétée (décodée) que d'une seule manière.
Exemples
{0,11,010} est uniquement déchiffrable.
0 1 101
  n'est pas uniquement déchiffrable car:
î (α ) (β ) (γ )
101 peut être interprété comme βαβ ou γ .
Un code préfixe est un code pour lequel aucun mot n'est le début d'un autre mot. Il est clair
qu'un code préfixe est uniquement déchiffrable.
Un moyen simple de construire un code préfixe consiste à utiliser un arbre dont chaque
branche représente une lettre de l'alphabet élémentaire (alphabet de référence). Il faut alors
choisir les mots de telle sorte que pour tout couple de mots, le chemin permettant de conduire
à l'un des mots ne soit pas inclus dans le chemin menant à l'autre mot.
Exemple
10 ___________________________________________________________ sources discrètes
0 1
0 1 0 1
00 01
0 1 0 1
100 101 110 111
{0,10,110,111} est un code préfixe.
{0,11,110,111} n'est pas un code préfixe car le chemin menant à 11 est inclus dans les
chemins menant à 110 et 111.
Théorème de Kraft
Une condition nécessaire et suffisante pour qu'un code C puisse être transformé (en permutant
certaines lettres dans les mots) en un code préfixe équivalent (par code équivalent, on entend
un code fabriqué à partir du même alphabet de référence et possédant la même distribution de
longueur des mots) est:
∑b
c ∈C
− n (c )
≤1 (1) avec:
b = nombre de lettres dans l'alphabet de référence

c = mot code
n(c) = longueur du mot c.
Remarque: La somme est effectuée sur tous les mots code.

sources discrètes __________________________________________________________ 11
Nous allons montrer que si le code est préfixe (ou possède un code équivalent préfixe), alors
la relation (1) est satisfaite.
Soient n1 ≤ n2 ≤...≤ nM les longueurs des M mots code et n"= nM la longueur maximale.
Notons K l'arbre complet dont les noeuds terminaux correspondent à tous les b-mots code de
longueur n". Alors le code associé à ces mots vérifie (1) car:
∑b
c ∈C
− n( c)
=b
−n"
b = 1 (le nombre de mots code étant b ). Ceci, bien sûr, n'étant valable que
n" n"
si les mots code ont tous la même longueur n" et sont au nombre de b n" . Si tous les mots
n"
code ont la même longueur n" , mais sont en nombre inférieurs à b , alors la relation (1)
sera satisfaite avec l'inégalité stricte.
Supposons maintenant que le code C possède au moins un mot c de longueur i strictement

inférieure à n". Dans l'arbre K, le mot c est à l'origine d'un sous-arbre complet contenant b n"−i
noeuds terminaux, donc dans la somme effectuée sur le code comportant b n" mots de
longueur n", le terme b −n"b n"−i où b n"−i représente le nombre de mots de longueur n" (du
sous arbre engendré par c) est remplacé par b −i (puisque i est la longueur de c). Donc la
somme calculée ne change pas.
Par conséquent la première implication est montrée (se reporter au dessin ci-dessous).
0 1
1
0 1 mot c de longueur i
2
0 1 0 1
3
0 1
0 1 0
0 1 1
4
sous-arbre engendré par c Longueur des mots

Nous allons maintenant montrer que si la relation (1) est satisfaite, alors il existe un code
préfixe équivalent au code C.
Soient m1, m2 ,..., mn" les nombres de mots de longueur 1, 2, ..., n". On a alors:
n"
∑b − n( c)
= ∑ mi b− i ≤ 1. D'où:
c ∈C i =1
m1 b−1 ≤ 1
m1 b− + m 2 b− ≤ 1
1 2
m1 b−1 + m 2 b−2 + m3 b−3 ≤ 1

...
...
m1 b−1 + m 2 b−2 + ... ... +m n" ≤ 1
Soit encore:
m1 ≤ b ⇔ (1' )
m 2b −2 ≤ 1 − m1 b−1
m 2 ≤ b − m1b
2
⇔ (2' )
m 3b−3 ≤ 1 − m 2 b −2 − m1b −1
m 3 ≤ b 3 − m 2 b − m1 b2 ⇔ (3' )
(1') nous permet de construire les m1 mots de longueur 1 grâce à un arbre.
Dans (2') b 2 − m1 b représente la différence entre le nombre de mots possibles de longueur 2 et
le nombre de branches de l'arbre qui ne sont plus disponibles car provenant des m1 mots de
longueur 1. De même pour (3'): b 3 représenterait le nombre de mots possibles de longueur 3

2
auquel il faudrait enlever m 2 b à cause du choix des m 2 mots de longueur 2 et m1 b car les
m1 mots choisis de longueur 1 rendent indisponibles les branches situées en aval (voir schéma
page suivante)
.
1 mot de longueur 1
1 mot de longueur 2
2 mots de longueur 3
Sur la figure les cercles représentent les mots code, les traits fins sont les "descendances" des
mots code (donc d'utilisation interdite pour fabriquer d'autres mots code). Dans cet exemple
on a choisi b = 2, m1 = 1, m2 = 1, m3 = 2.
Un second théorème important (il permettra, avec le théorème précédent, de réduire la classe
des codes uniquement déchiffrables à celle des codes préfixes) est le:
Théorème de Mac-Millan
Un code C uniquement déchiffrable vérifie: ∑b
c ∈C
− n (c )
≤1 .
Considérons le polynôme énumérateur des longueurs du code C:
P( z ) = ∑ z = z 1 + z 2 +...+z avec n1 ≤ n2 ≤...≤ nM les longueurs des M mots code et

n(c ) n n nM
c ∈C
n"= nM la longueur maximale. Le degré n" de ce polynôme est la longueur maximale des
mots. Pour énumérer les mots obtenus en concaténant de toutes les manières possibles k mots
de C, il suffit d'élever à la puissance k le polynôme énumérateur des longueurs. On obtient
kn"
ainsi: ∑ ν (i )zi . La sommation s'effectue à partir de i = k car initialement les mots les plus
i=k
courts ont pour longueur 1 et k après concaténation.

Elle s'arrête à kn car n est avant concaténation la plus grande longueur. ν(i) désigne le
nombre de séquences de longueur i après concaténation de k mots. Et puisque le code est
uniquement déchiffrable, toutes ces séquences sont différentes, donc ν(i) ≤ b i . En prenant
z = b dans P(z) , on obtient:
−1 k
k
 
kn" kn"
P(b ) =  ∑ b − n(c ) = ∑ ν (i) b −i ≤ ∑ b i b −i ≤ kn" donc:
−1 k
 c ∈C  i =k i =k
1 1
( Logk + Logn")
∑ b − n( c) ≤ (kn")k = e k
1 Logkn"
= ek . Si on fait tendre k vers l'infini, on a:
c ∈C
1
( Logk + Logn")
lim e k = 1 d'où le résultat.
k→+∞
Remarque:
Ces deux théorèmes nous permettent donc d'affirmer qu'à tout code uniquement déchiffrable
on peut associer un code préfixe équivalent. Ainsi, à chaque fois que l'on aura à étudier un
code uniquement déchiffrable, on pourra raisonner sans perte de généralité sur un code
préfixe.
CODAGE D'UNE VARIABLE ALÉATOIRE DISCRÈTE
Avant d'étudier le codage de source qui va concerner les réalisations successives de U

(U1 ,U2 ,...,Un ,...) , on va s'intéresser au cas plus simple d'une variable aléatoire. Notre objectif
sera principalement de minimiser la longueur moyenne des mots code définie par
M
n = ∑ pin(i)
i =1
avec M = nombre de mots code

pi = fréquence relative d' apparition du mot code numéro i
n(i) = longueur du mot code numéro i
On va montrer que le codage d'une variable aléatoire X a des performances (en termes de
longueur moyenne des mots code) liées à l'entropie de la variable.
Proposition 1
Pour tout codage d'une variable aléatoire X par un code uniquement déchiffrable (sur un
alphabet de référence à b lettres), la longueur moyenne des mots code n vérifie:
H (X ) ≤ n logb où la base du logarithme coïncide avec celle utilisée pour la mesure de
H (X ) (entropie de X).
Puisque le code C est uniquement déchiffrable, on a ∑b

c ∈C
− n (c )
≤ 1. Supposons que le code
M
b −n(i )
possède M mots différents et posons Q = ∑ b − . Alors (q1 , q2 ,..., qM ) tel que qi =
n(i )
i =1 Q
définit une loi de probabilité. Si de plus (p1 , p2 ,..., pM ) désigne la loi de X, on sait d'après le
M M M
lemme fondamental que ∑ pi log i ≤ 0 soit ∑ pi logqi − ∑ pi log pi ≤ 0
q
i =1 pi i =1 i =1
∑ p (logb
i =1
i
−n( i )
− logQ )+ H ( X ) ≤ 0
M M
∑ −n(i)pi log b − ∑ pi logQ + H( X ) ≤ 0

i =1 i =1
d'où − n logb − logQ + H (X ) ≤ 0 soit
nlog b ≥ H (X ) − logQ ≥ H(X ) car Q ≤ 1 (cqfd).
Proposition 2
Pour toute variable aléatoire X, il existe un code préfixe tel que:
nlog b < H (X ) + logb
Construisons un code tel que le iième mot correspondant à la iième valeur de X (prise avec la
probabilité pi ) ait une longueur n(i ) vérifiant − logb pi ≤ n(i) < − logb pi + 1 où logb désigne le
logarithme à base b.
M M
Alors − n(i) ≤ logb pi soit b − ≤ pi d'où on déduit: ∑ b − n(i ) ≤ ∑ pi = 1. Cette inégalité nous
n(i )
i =1 i =1
assure l'existence d'un code préfixe. De plus:
n(i ) < − logb pi + 1 ⇒ n(i )pi < − pi logb + pi d'où:
M M
n = ∑ pin(i) < − ∑ pi log b pi + 1
i =1 i=1
Si a est la base du logarithme pour le calcul de H(X):
M
Ln b
n < − ∑ pi
Ln pi Ln a
+ 1 soit en multipliant par log b = :
i =1 Ln a Ln b Ln a
nlog b < H( X) + log b (cqfd).
Finalement, en regroupant les propositions 1 et 2, on déduit que tout codage d'une variable
aléatoire X par un code uniquement déchiffrable vérifie:
H( X ) H(X )
n≥ , c'est-à-dire que apparaît comme une limite inférieure pour n en dessous
logb log b
de laquelle il n'est pas possible de descendre.
De plus, pour toute variable aléatoire X, il existe un code préfixe pour lequel n vérifie:
H(X)
n< +1
logb
H( X ) H (X )
Par conséquent ce code préfixe vérifiera la double inégalité: ≤n < +1
log b logb
CODAGE D'UNE SOURCE
CODES À LONGUEUR VARIABLE
On va appliquer les résultats précédents à une source stationnaire.

Théorème du codage de source
Soient U une source stationnaire et H L (U ) l'entropie par lettre source pour un mot de
longueur L. On note b la taille de l'alphabet utilisé pour construire le code.
Alors il est possible de trouver un code préfixe pour encoder les mots de L lettres source avec
un nombre moyen n de lettres code par lettre source de telle sorte que:
H L (U ) H (U ) 1
≤n< L + où la base du logarithme est celle utilisée pour exprimer H L (U ) .
logb log b L
De plus, si on fait tendre L vers l'infini, alors pour tout nombre δ réel et positif, on pourra
H∞ (U ) H (U )
trouver un code préfixe tel que: ≤n< ∞ +δ
log b log b
ième
Considérons la L extension de la source U, c'est-à-dire la nouvelle source dont les
réalisations correspondent à toutes les concaténations de L lettres émises par la source U. L
est appelé l'ordre d'extension de la source.
Cette extension définit un vecteur aléatoire U = (U1 ,U2 ,...,UL ) où Ui représente la i
ième
occurence de la source U. Et on peut appliquer les résultats des propositions 1 et 2

précédentes à la source U :
HU( )≤ n <
( )+ 1
HU
(α) où nL désigne le nombre moyen de symboles nécessaires
L
log b logb
pour coder les mots de L lettres source. Compte tenu de la relation
L H L (U ) L H L (U )
()
H U = H(U1 ,U2 ,...,U L ) = L HL (U ) , on déduit:
log b
≤ nL <
log b
+ 1 ⇔ (α )
H L (U ) nL H L (U ) 1 nL
soit ≤ < + ⇔ (α ) où représente le nombre moyen de symboles
logb L log b L L
nécessaires pour coder une lettre source (en considérant des mots de L lettres source). Donc la
première assertion du théorème est montrée.
1 1
Ensuite, lim = 0 entraîne ∀ δ > 0 ∃ L0 / ∀L > L0 <δ.
L→ +∞ L L
nL
On a donc ∀ L > L0 et en notant n = :
L
HL (U) H (U )
≤n< L + δ soit en faisant tendre L vers l'infini:
logb log b
H∞ (U ) H (U )
≤n< ∞ + δ ce qui montre la deuxième assertion du théorème.
log b log b
EXEMPLES DE CODES À LONGUEUR VARIABLE UTILISÉS POUR COMPACTER

UNE SOURCE
- Code Morse
Il s'agit d'un code ternaire. Le principe consiste à associer à chaque lettre une succession
d'émissions de courants brefs (points) et longs (traits) séparés par des pauses courtes. Entre
chaque lettre est insérée une pause plus longue. Les mots sont séparés par une pause deux fois
plus longue que celle disposée entre les lettres. Les trois lettres code sont le point, le trait et la
pause. Aux lettres les plus fréquentes sont affectées les mots code les plus courts.
Lettre Fréquence Code Durée Lettre Fréquence Code Durée

d'apparition Morse d'apparition Morse
A 0,0642 ._ 9 N 0,0574 _. 9
B 0,0127 _... 13 O 0,0632 ___ 15
C 0,0218 _._. 15 P 0,0152 .__. 15
D 0,0317 _.. 11 Q 0,0008 __._ 17
E 0,1031 . 5 R 0,0484 ._. 11
F 0,0208 .._. 13 S 0,0514 ... 9
G 0,0152 __. 13 T 0,0796 _ 7
H 0,0467 .... 11 U 0,0228 .._ 11
I 0,0575 .. 7 V 0,0083 ..._ 13
J 0,0008 .___ 17 W 0,0175 .__ 13
K 0,0049 _._ 13 X 0,0013 _.._ 15
L 0,0321 ._.. 13 Y 0,0164 _.__ 17
M 0,0198 __ 11 Z 0,0005 __.. 15
ESPACE 0,1859 6
- Code de Shannon-Fano
Il s'agit du premier code utilisé pour exploiter la redondance d'une source.
La première étape consiste, après avoir classé les différents symboles à coder suivant l'ordre
décroissant de leur probabilité les uns en dessous des autres, à diviser ces symboles en deux
sous-groupes de telle sorte que les probabilités cumulées de ces deux sous-groupes soient
aussi proches que possible l'une de l'autre.
Dans la deuxième étape, on affecte le chiffre binaire "0" au sous-groupe placé au dessus et
"1" au sous groupe placé en dessous du premier. Les mots code du premier sous-groupe
commenceront tous par "0" tandis que ceux du second commenceront par "1".
On redivise les sous-groupes comme indiqué dans la première étape et on procède comme
décrit à la seconde étape.
L'algorithme prend fin lorsque les sous-groupes ne contiennent qu'un élément: Tous les
symboles source ont alors un mot code.
Exemple:
Soit une source dont les cinq symboles A, B, C, D, E apparaîssent avec les probabilités
15 7 6 6 5
, , , , .
39 39 39 39 39
En appliquant la procédure décrite précédemment, on obtient le tableau:
Symbole Fréquence Première Deuxième Troisième Quatrième

d'apparition division division division division
A 15/39 0 0
B 7/39 0 1
C 6/39 1 0
D 6/39 1 1 0
E 5/39 1 1 1
On obtient pour chaque lettre les mots code binaires:

A 00
B 01
C 10
D 110
E 111
La longueur moyenne d'un mot code est:
15 7 6 6 5
2. + 2. + 2. + 3. + 3. = 2,282 bits . Ce nombre est à comparer avec l'entropie de
39 39 39 39 39
la source:
−  log2 + log 2  = 2,1858 Sh.
15 15 7 7 6 6 5 5
+ log 2 + 2. log 2
î 39 39 39 39 39 39 39 39 
Le code de Shannon-Fano était utilisé dans les télétypes des années cinquante. Il a depuis
laissé sa place à un code plus performant, le code de Huffman.
- Code de Huffman
La construction de l'arbre permettant d'affecter aux n lettres source un mot code s'effectue de
façon ascendante (contrairement au code de Shannon-Fano).
Première étape
On classe les lettres source suivant l'ordre croissant de leur probabilité.
Deuxième étape
On crée un noeud parent à partir des deux lettres source de probabilités les plus faibles.
Troisième étape
On affecte au noeud parent une probabilité égale à la somme des probabilités des deux lettres
source à l'origine du noeud parent.
Quatrième étape
On élimine de la liste les deux précédentes lettres source et on les remplace par le "super
symbole" constitué par le noeud parent.
Considérant les n-1 lettres source restantes, on revient à la deuxième étape jusqu'à ce qu'il ne
reste plus de lettre source.
Exemple
On reprend l'exemple précédent constitué des cinq lettres A, B, C, D, E affectées des

15 7 6 6 5
fréquences relatives d'apparition: , , , , .
39 39 39 39 39
(IV)
(24/39) (III)
(11/39) (I) (13/39) (II)
E D C B A
(5/39) (6/39) (6/39) (7/39) (15/39)
Les lettres souce étant disposées dans l'ordre croissant de leur probabilité, on rassemble E et
5 6 11
D en un noeud parent (I) de probabilité + = .
39 39 39
13
On crée le super symbole (II) à partir de C et de B de probabilité .
39
24
On relie (I) et (II) en un troisième super symbole (III) de probabilité .
39
L'étape finale consiste à relier (III) et A.
Le code binaire obtenu est:
E 000
D 001
C 010
B 011
A 1
 15
La longueur moyenne d'un mot s'écrit: 3. 1 −  + 1. = 2,23 bits .
15
 39  39
Les différentes étapes décrites pour construire l'algorithme de Huffman sont justifiées par les
résultats théoriques suivants.
Soit une source à K symboles {a1 ,a2 ,...,aK } tels que P(a1 ) ≥ P(a2 ) ≥...≥ P (aK ). On désigne
par x1 , x2 ,..., x K les mots code binaires correspondant à la source de longueur n1 , n2 ,..., nK .
Lemme 1
Pour n'importe quelle source avec K ≥ 2, un code optimum existe dans lequel les deux mots
les moins probables x K et x K −1 ont la même longueur et ne diffèrent que par le dernier digit:
"1" pour x K et "0" pour x K−1 .
Tout d'abord on peut observer que pour au moins un code optimum, on doit
vérifier:nK (longueur du mot le moins probable) ≥ ni ∀ i ∈{1,2,..., K}. En effet, si tel n'était
pas le cas, cela signifierait qu'il existerait un code C1 pour lequel on aurait un indice i avec
nK < ni . En permutant les mots code xi et x K on obtiendrait un nouveau code C2 dont la
longueur moyenne des mots diffèreraient du premier d'une quantité égale à
∆n = P(ai )nK + P(aK )ni − P(aK )nK − P (ai )ni = [P(ai ) − P(aK )](nK − ni ) < 0 . Ainsi le code C1
ne serait pas optimum.
Ensuite, on peut remarquer que dans n'importe quel code optimum dans lequel x K a la plus
grande longueur, il doit y avoir un autre mot code qui diffère de x K par le dernier digit, sinon
le dernier digit pourrait être omis sans violer la condition de préfixe, par là même on
diminuerait n et le code ne serait pas optimum.
Finalement si xi est le mot code qui diffère de x K seulement en un rang donné, on doit avoir
ni ≥ nK −1 car nK ≥ n j ∀j . On permute alors les mots xi et x K −1 (sinon ∆n < 0 ).
Par conséquent x K et x K −1 ne diffèrent que d'un digit qui est le dernier digit et le lemme 1 est
montré.
Le problème se résume maintenant à trouver un code pour a1 ,a2,...,aK − 2 et de déterminer les

nK − 1 premiers digits de x K puisqu'on a fixé le dernier à "1".
Définissons la nouvelle source U' = {a' 1 ,a' 2 ,..., a' K −1 } avec:
a' k = ak ∀ k ≤ K − 2 et P(a' k ) = P(ak )

P(a' K −1) = P(aK −1 ) + P(aK )
Lemme 2
Si un code préfixe est optimum pour U' , alors le code préfixe associé pour U est optimum
pour U.
Par le code préfixe associé pour U, on entend le code obtenu en ajoutant à x' K −1 un "0" (resp
un "1") terminal pour créer x K−1 (resp x K ).
En effet les longueurs n' k des mots code pour U' sont liées aux longueurs nk des mots code
pour U par la relation:
 n' k si k ≤ K − 2
nk = 
î n' K −1 +1 si k ∈ {K − 1,K }
On a alors:
K −2
n = ∑ P(ak )nk = ∑ P(ak )n' k +[P(aK −1) + P(aK )](n' K −1 +1)
K
k =1 k =1
soit:
K
n = ∑ P(a' k )n' k + P(a' K −1 )(n' K −1 +1) = n' + P(a' K −1 )
k =1
On en conclut que n et n' ne différent que par une quantité (P(a' K −1 )) qui est indépendante
du code pour U' . Par conséquent on ne peut minimiser n qu'en minimisant n' .
En raisonnant ainsi de proche en proche, on obtient l'algorithme de Huffman.
ÉTUDE DU CAS OU L'ALPHABET DE RÉFÉRENCE N'EST PAS BINAIRE
Si l'alphabet de référence utilisé pour construire les mots code n'est pas binaire, alors le
lemme 1 s'applique toujours mais le lemme doit être modifié car il peut exister des mots
autres que x K−1 qui diffèrent de x K dans le dernier digit. Notons D la taille de l'alphabet, avec
D ≠ 2.
Lemme 3
Pour un arbre complet, il existe un entier m tel que le nombre de noeuds terminaux soit:
D + m.(D − 1) .
Un arbre complet est un arbre pour lequel chaque noeud intermédiaire comporte exactement
D feuilles.
En effet l'arbre le plus petit possède D noeuds terminaux. Cela correspond à m = 0. Et si un

de ces noeuds terminaux est transformé en un noeud intermédiaire, on a alors D nouveaux
noeuds à la place d'un, soit un gain de D − 1. Ainsi à chaque conversion possible on ajoute
D − 1 noeuds, ce qui montre le lemme.
Chaque code peut être décrit par un arbre complet avec peut-être B noeuds terminaux non
utilisés. Et pour un code optimum, deux remarques peuvent être formulées:
- Tous les noeuds non utilisés (pour fabriquer un mort code) doivent avoir la "même
longueur" que le mot code le plus long, sinon le code ne serait pas optimum.
- Il y a au plus D − 2 noeuds terminaux non utilisés. En effet, il ne peut y en avoir un

multiple de D − 1 , sinon on les rassemblerait par paquets de D − 1 sous un même arbre
comportant un mot code et ce mot code pourrait être écrit avec une lettre de moins.
Donc la valeur maximum pour B est D − 2. Par ailleurs, on a vu que le nombre de noeuds
terminaux est D + m.(D − 1) . Donc si K est le nombre de symboles à coder, alors
K + B = D + m.(D − 1). Soit K = m.(D − 1) + D − B d'où:
K − 2 = m. (D − 1) + D − B − 2.
Or 0 ≤ B ≤ D − 2 ⇒ 0 ≥ − B ≥ 2 − D ⇒ D − 2 ≥ D − 2 − B ≥ 0
Donc D − B − 2 apparaît comme le reste de la division euclidienne de K − 2 par D − 1.
B doit vérifier la relation: B = D − 2 − Reste (K − 2, D − 1) .
Ainsi pour la première étape de l'algorithme de Huffman, on va regrouper les D − B

symboles les moins probables. Ensuite on rassemblera les symboles par groupes de D pour
créer les super-symboles.
Remarques
- Un code de Huffman est toujours au moins aussi performant qu'un code de Shannon-Fano.
- Le codage de Huffman (comme celui de Shannon-Fano) nécessite la connaissance des

probabilités a priori des lettres source. En fait, si on ne connaît pas ces nombres, on peut
toujours les estimer en mesurant les fréquences d'apparition des différents symboles dans le
message à transmettre. Mais il faudra alors transmettre la table des probabilités ainsi estimées
pour que le décodage soit possible.
- Comme nous l'indique le théorème du codage de source, le code sera d'autant plus
performant que l'on aura choisi un ordre d'extension élevé de la source. Ceci nuit au caractère
systématique de la méthode. D'autre part, plus l'ordre d'extension est élevé, plus la table des
probabilités à transmettre sera longue. En guise d'exemple, si la source émet des symboles du
code ASCII étendu, il y a 256 caractères. La prise en compte de l'extension d'ordre deux de la
source nécessiterait la transmission d'une table de probabilités comportant
256 2 = 65536 nombres ! On imagine sans peine que le gain obtenu par la compression peut
être anihilé lorsque les messages sont courts.
Pour pallier cet inconvénient, on a introduit le code de Huffman adaptatif dont le principe
repose sur la mise à jour des statistiques sur les symboles au fur et à mesure de la lecture du
message: L'arbre est alors modifié en conséquence. Pour commencer, on peut initialiser
l'arbre avec les 256 caractères possibles en affectant à chacun le même poids. L'inconvénient
réside alors dans le fait que certains des 256 caractères peuvent n'être jamais utilisés, ce qui
aura pour effet d'amoindrir l'effet de compression. On peut alors imaginer de n'inclure les
symboles dans l'arbre qu'au fur et à mesure de leur apparition. Un code d'échappement sera
utilisé à chaque fois qu'un symbole apparaîtra pour la première fois. Le décodeur saura, en le
recevant, que l'on sort du contexte courant.
- Le codage de Huffman correspond à une des étapes de la compression des images suivant
les normes JPEG (Joint Photographic Experts Group) pour les images fixes, et MPEG
(Moving Photographic Experts Group) pour les images animées. Le procédé de compression
JPEG peut être schématisé comme suit:
image calcul de la DCT quantification compression image

originale compressée
L'image est représentée par une matrice dont les éléments correspondent aux valeurs prises
par les pixels. On la décompose en blocs de 8x8 = 64 pixels de façon à ce que les calculs de
DCT (Discrete Cosine Transform) puissent être effectués en un laps de temps raisonnable.
La DCT est une opération similaire au calcul de la transformée de Fourier discrète à deux
dimensions (variables d'espace). On obtient alors une nouvelle matrice de mêmes dimensions
que la première où les éléments correspondent à des mots de 11 éléments binaires (les termes
de la matrice initiale étaient codés sur 8 éléments binaires).
La quantification consiste à réduire le nombre d'éléments binaires pour représenter les

coefficients de la matrice. Ainsi les termes situés dans la partie haute gauche de la matrice se
verront accorder, pour les représenter, un nombre d'éléments binaires plus important que les
termes localisés dans la partie basse droite de la matrice. De cette opération découle une perte
d'information.
Ensuite les valeurs de la matrice sont rangées à partir d'une excursion en zig-zag effectuée sur
la matrice en débutant par le terme situé en haut à gauche.
DC
Chaque bloc de 8x8 possède un coefficient noté DC (situé en haut à gauche) et correspondant
en quelque sorte à la "valeur moyenne" des 63 autres coefficients notés AC.
Tenant compte du fait qu'il existe généralement une corrélation assez forte entre les
coefficients DC de blocs adjacents, on ne code pas la valeur de DC mais la différence entre le
coefficient DC du bloc précédent et celui que l'on vient de lire.
Pour les coefficients AC, le balayage en zig-zag est interprété sous la forme de couples de
symboles appelés respectivement symbole-1 et symbole-2.
Le symbole-2 comporte 'l'amplitude' du premier coefficient AC non nulle suivant la

précédente valeur codée.
Le symbole-1 comporte deux nombres: Le premier 'runlength' est le nombre de zéros

consécutifs depuis le dernier coefficient AC non nul (de zéro à quinze). Le second 'size' décrit
le nombre d'éléments binaires utilisés pour écrire la valeur de l'amplitude du symbole-2.
Si le nombre de zéros consécutifs lors du balayage en zig-zag dépasse 15, alors le symbole-1
prend la forme (15, 0).
Pour les coefficients AC et DC, le symbole-1 est encodé avec un code de Huffman. Le
symbole-2 est encodé à l'aide d'un code à longueur variable qui n'est pas un code de Huffman
mais qui doit vérifier certaines contraintes.
- Code arithmétique
Le principe de ce code consiste à affecter à l'ensemble du message un seul nombre en virgule

flottante.
Exemple
Soit à coder le message "BILL GATES".

On estime tout d'abord les probabilités des lettres source en les assimilant aux fréquences
relatives d'apparition dans le message. Pour notre exemple, on obtient:
A 1/10
B 1/10
E 1/10
G 1/10
I 1/10
L 2/10
S 1/10
T 1/10
espace 1/10
Ensuite, on attribue à chaque symbole un intervalle semi-ouvert contenu dans [0,1]. Ces
intervalles doivent être disjoints et de longueur égale à la fréquence d'apparition du symbole.
A B E G I L S T espace
[.1, .2[ [.2, .3[ [.3, .4[ [.4, .5[ [.5, .6[ [.6, .8[ [.8, .9[ [.9, 1[ [0, .1[
Le premier symbole à coder (ici "B") va déterminer l'intervalle dans lequel va se situer le
nombre représentant l'ensemble du message (ici [0.2, 0.3[).
Le second symbole "I" restreint le premier intervalle. Le nouvel intervalle est obtenu de telle
sorte que sa borne inférieure (resp supérieure) est égale à la somme de la borne inférieure de
l'intervalle précédent et du produit de la longueur de l'intervalle précédent par la borne
inférieure (resp supérieure) de l'intervalle du nouveau symbole (ici "I").
On obtient ainsi:
Pour "B" [0.2, 0.3[

pour "BI" [0.2+0.1x0.5, 0.2+0.1x0.6[ = [0.25, 0.26[
pour "BIL" [0.25+0.01x0.6, 0.25+0.01x0.8[ = [0.256, 0.258[
et ainsi de suite...
Finalement, on obtient pour le message complet:

[0.2572167752, 0.2572167756[
C'est la borne inférieure du dernier intervalle (ici 0.2572167752) qui codera l'ensemble du
message.
Pour décoder le premier symbole, on détermine le symbole dont l'intervalle contient le

nombre (à décoder). Ici 0.2572167752 est dans l'intervalle [0.2, 0.3[ donc "B" est la première
lettre du message. Ensuite, on soustrait du nombre codé la borne inférieure de l'intervalle de
"B" (0.2) et on divise par la longueur de l'intervalle associé à "B". On obtient 0.572167752 et
on recherche le symbole dont l'intervalle contient cette valeur. On trouve ainsi la seconde
lettre "I" du message et ainsi de suite... (Le décodeur doit connaître les intervalles associés
aux lettres).
- Code de Lempel-Ziv-Welch (LZW)
Le code LZW est une amélioration des deux précédentes versions LZ77 et LZ78. Il est utilisé
comme procédé de compaction dans le format GIF dans les fichiers ayant l'extension .Z
(commande Compress) et .gzip sous Unix et sur PC dans les fichiers à extension .zip.
Nous commencerons par présenter le codage LZ78. Le principe général consiste à fabriquer
un dictionnaire au fur et à mesure de la lecture du message à coder.
L'algorithme LZ78.
En 1978 les deux chercheurs Israéliens Jacob Ziv et Abraham Lempel ont publié, dans la
revue IEEE Transactions on Information Theory, un article intitulé "Compression of
Individual Sequences via Variable-Rate Coding" qui présente un algorithme de compression
appelé désormais LZ78.
La compression.
Au niveau de la compression, le principe de cet algorithme est de lire caractère par caractère
le texte à compresser et de vérifier si la chaîne ainsi construite se trouve bien dans un
dictionnaire.
Si la concaténation (⊕) de la chaîne précédente (P) avec le dernier caractère lu (c) se trouve
dans le dictionnaire, alors la lecture continue avec le caractère suivant.
Si ce n'est pas le cas, c'est à dire si P ⊕ c n'appartient pas au dictionnaire, alors le couple
(adresse de P, caractère c) est émis en sortie, puis la chaîne P ⊕ c est ajoutée au dictionnaire.
Au début, le dictionnaire est initialisé avec la chaîne vide placée à l'adresse 0.
Prenons pour exemple la phrase suivante dans laquelle les espaces sont représentés par le
symbole (∧) et les accents ne sont pas pris en compte.
Texte à compresser:
"si∧six∧scies∧scient∧six∧cypres∧alors∧ces∧six∧cypres∧seront∧scies∧par∧ces
∧six∧scies"
Le tableau suivant donne le déroulement de l'algorithme et permet de visualiser la

construction du dictionnaire.
adresse dans le chaîne dans le caractère lu signes émis

dictionnaire dictionnaire
_____________ _____________ __________ __________
0 S 0S
1 S I 0I
2 I ∧ 0∧
3 ∧ S,I 1I
4 SI X 0X
5 X ∧,S 3S
6 ∧S C 0C
7 C I,E 2E
8 IE S,∧ 1∧
9 S∧ S,C 1C
10 SC I,E,N 8N
11 IEN T 0T
12 T ∧,S,I 6I
13 ∧SI X,∧ 5∧
14 X∧ C,Y 7Y
15 CY P 0P
16 P R 0R
17 R E 0E
18 E S,∧,A 9A
19 S∧A L 0L
20 L O 0O
21 O R,S 17S
22 RS ∧,C 3C
23 ∧C E,S 18S
24 ES ∧,S,I,X 13X
25 ∧SIX ∧,C,Y 23Y
26 ∧CY P,R 16R
27 PR E,S,∧ 24∧
28 ES∧ S,E 1E
29 SE R,O 17O
30 RO N ON
31 N T,∧ 12∧
32 T∧ S,C,I 10I
33 SCI E,S,∧,P 28P
34 ES∧P A 0A
35 A R,∧ 17∧
36 R∧ C,E 7E
37 CE S,∧,S 9S
38 S∧S I,X 2X
39 IX ∧,S,C 6C
40 ∧SC I,E,S 8S
Déroulement de l'algorithme LZ78

L'ensemble des couples émis est donc le suivant:
0S, 0I, 0∧, 1I, 0X, 3S, 0C, 2E, 1∧, 1C,
8N, 0T, 6I, 5∧, 7Y, 0P, 0R, 0E, 9A, 0L,
0O, 17S, 3C, 18S, 13X, 23Y, 16R, 24∧, 1E, 17O,
0N, 12∧, 10I, 28P, 0A, 17∧, 7E, 9S, 2X, 6C,
8S
Il y a 41 couples. Dans un couple, le caractère est codé sur 1 octet.
Si l'indice de chaîne est codé sur 1 octet, on ne pourra "adresser" que 128 chaînes, ce qui est
insuffisant. Si cet indice de chaîne est codé sur 2 octets, c'est 65536 chaînes qui seront
accessibles (ceci est, peut être, encore insuffisant). Le message ci dessus utiliserait alors
(2+1)x41 = 123 octets au lieu des 82 octets du message initial ! Ceci laisse présager que
l'efficacité de la compression est liée à la longueur des fichiers.
L'algorithme LZW.
En 1984, Terry Welch à publié une variante de l'algorithme LZ78 dans IEEE Computer "A
technique for High-performance Data Compression".
L'amélioration consiste à ne plus émette un couple (adresse,caractère), mais seulement une
adresse. Pour cela le dictionnaire est initialisé avec l'ensemble des caractères de l'alphabet.
La compression.
Au niveau de la compression, le principe de cet algorithme est de lire caractère par caractère
le texte à compresser et de vérifier si la chaîne ainsi construite se trouve bien dans un
dictionnaire.
Si la concaténation (⊕) de la chaîne précédente (P) avec le dernier caractère lu (c) se trouve
dans le dictionnaire, alors la lecture continue avec le caractère suivant.
Si ce n'est pas le cas, c'est à dire si P ⊕ c n'appartient pas au dictionnaire l'adresse de P est est
émise en sortie, puis la chaîne P ⊕ c est ajoutée au dictionnaire et en fin le caractère c est
utilisé pour initialiser la chaîne P suivante.
Le tableau suivant montre, sur l'exemple précédent, le déroulement de cet algorithme.
adresse dans le chaîne dans le initialisation caractère lu signes émis

dictionnaire dictionnaire de P
0 ""
...
32 ∧
...
65 A
67 C
69 E
73 I
76 L
...
78 N
79 O
80 P
...
82 R
83 S
84 T
...
88 X
89 Y
...
255 "" S,I 83
256 SI I ∧ 73
257 I∧ ∧ S 32
258 ∧S S I,X 256
259 SIX X ∧ 88
260 X∧ ∧ S,C 258
261 ∧SC C I 67
262 CI I E 73
263 IE E S 69
264 ES S ∧ 83
265 S∧ ∧ S,C,I 261
266 ∧SCI I E,N 263
267 IEN N T 78
268 NT T ∧ 84
269 T∧ ∧ S,I 258
270 ∧SI I X 73
271 IX X ∧,C 260
272 X∧C C Y 67
273 CY Y P 89
274 YP P R 80
275 PR R E 82 276
RE E S,∧ 264
277 ES∧ ∧ A 32
adresse dans le chaîne dans le initialisation caractère lu signes émis

dictionnaire dictionnaire de P
278 ∧A A L 65
279 AL L O 76
280 LO O R 79
281 OR R S 82
282 RS S ∧,C 265
283 S∧C C E 67
284 CE E S,∧,S 277
285 ES∧S S I,X,∧ 259
286 SIX∧ ∧ C 32
287 ∧C C Y,P 273
288 CYP P R,E 275
289 PRE E S,∧,S,E 285
290 S∧SE E R 69
291 ER R O 82
292 RO O N 79
293 ON N T,∧ 268
294 NT∧ ∧ S,C,I,E 266
295 ∧SCIE E S,∧,P 277
296 ES∧P P A 80
297 PA A R 65
298 AR R ∧ 82
299 R∧ ∧ C,E 32
300 ∧CE E S,∧,S,I 285
301 ES∧SI I X,∧ 271
302 IX∧ ∧ S,C,I,E,S 295
303 ∧SCIES S 83
Une amélioration du LZW est le LZW15VC qui est capable de coder les adresses jusqu'à 15
bits. Il commence à coder sur 9 bits et il n'utilise 10 bits qu'après avoir codé 256 valeurs
supplémentaires. Le dictionnaire est vidé lorsqu'il est complètement rempli. Ceci permet de le
rendre aussi performant que d'autres codes pour les messages courts.
COMPARAISON DES PERFORMANCES DE QUELQUES CODES
On convient de mesurer les performances d'un code par le taux de compression défini comme
suit;
 taille du fichier compressé 

τ = 1 − *100 .
 taille du fichier original 
Ceci signifie que pour un fichier original de 100 caractères, un taux de compression de 70%
se traduit par une taille du fichier compressé égale à 30 caractères. Il est clair que pour un
même code le taux de compression diffère d'un fichier à l'autre. Ainsi, les chiffres du tableau
ci-dessous ont été obtenus en utilisant les mêmes fichiers (extraits du Dr Dobb's journal
février 1991). Ces fichiers constituent 6 M octets de données répartis en trois catégories à peu
près égales: fichiers textes, fichiers binaires (exécutables, données d'un tableur, ...), fichiers
graphiques.
codes graphiques binaires textes moyenne
code de
Huffman 27,22% 24,79% 40,38% 31,04%
code de
Huffman 32,59% 26,69% 40,72% 33,27%
adaptatif
code
arithmétique 27,78% 25,25% 40,81% 31,51%
LZW 12 bits
fixe 20,61% 15,07% 50,32% 29,20%
LZW 12 bits
variable 46,78% 36,61% 54,82% 45,81%
LZW 15 bits
variable 48,44% 36,15% 58,28% 47,31%
CODES BLOC
Soit une source émettant des lettres issues d'un alphabet de taille K. Considérons la nième
extension de la source (ensemble des mots source résultant de la concaténation de n lettres
source). Soit alors un alphabet de référence comportant D lettres code. Un code bloc peut être
formé en concaténant r lettres code. Si on ne souhaite pas perdre d'information, il faudra que
le nombre de mots code soit au moins égal au nombre de mots source. En d'autres termes, il
faudra vérifier D ≥ K . (Le premier théorème de Shannon énoncera une condition moins
r n
restrictive que D r ≥ K n en mettant en jeu l'entropie de la source).

r
Le taux du code ainsi constitué est le rapport R = qui représente le nombre de lettres code
n
nécessaires pour représenter une lettre source.
Avant d'énoncer le premier théorème de Shannon, nous aurons besoin du résultat

intermédiaire que constitue le théorème de Shannon-Mac Millan.
Théorème de Shannon-Mac Millan
Soit X une source discrète sans mémoire d'entropie H(X).

Alors ∀ ε > 0 ∀ η > 0 ∃ N / ∀ n ≥ N , les mots source c (ou suites) de longueur n
résultant de la concaténation de n lettres source peuvent être divisés en deux groupes:
- Le premier groupe est constitué des suites c dont la probabilité P(c ) vérifie:
1
H ( X ) + log P(c ) < η où la base du logarithme est celle utilisée pour le calcul de H(X). On
n
dit que ces suites sont typiques.
- Le second groupe est formé de toutes les autres suites. La somme cumulée de leur
probabilité ne dépasse pas ε. On dit que ces suites sont atypiques.
Autrement dit, les mots source c de longueur n ont presque sûrement (à ε près) une
probabilité P(c) telle que a ( ( ) ) < P(c ) < a ( ( )) .
− n η+ H X n η−H X
Une preuve heuristique de ce théorème peut être développée comme suit:

Notons x1 , x2 ,..., x K les valeurs possibles de la source X de probabilités p1 , p2 ,..., pK .

Considérons une séquence c de longueur n avec n "grand". Alors la loi faible des grands
nombres (ou plus exactement ici le théorème de Bernoulli) indique qu'il y aura à peu près
dans cette séquence:
np1 fois le symbole x1

np2 fois le symbole x2
... ... ...
... ... ...
npK fois le symbole xK
On aura donc P(c ) ≈ p1

np 1 np2 npK
p2 ... pK soit
log P (c) ≈ np1 log p1 + np2 log p2 +...+npK log pK , c'est-à-dire:
log P (c)
≈ p1 log p1 + p2 log p2 +...+ pK log pK = − H ( X ) (cqfd).
n
Pour montrer le théorème d'une façon plus rigoureuse, on peut procéder comme suit:
Tout d'abord si X1 , X2 ,...,X n sont n variables aléatoires indépendantes, alors
n
IX 1, X 2 ,..., Xn = ∑ I X j . En effet:
j =1
Soient X1 (resp. X2 ) une variable aléatoire prenant J (resp. K) valeurs α1 , α2 ,..., αJ

(resp. β1 ,β 2 ,...,β K ) avec les probabilités p1 , p2 ,..., pJ (resp. q1 ,q2 ,...,qK ). On a:
J K
IX 1 = − ∑ log pj 1I X =α
{ 1 j}
et IX 2 = − ∑ log pk 1I {X 2 =β k } . Et puisque X1 et X2 sont
j =1 k =1
J K
indépendantes, IX 1 , X 2 = − ∑ ∑ log p j qk 1I X = α 1I{X2 =β k } , soit:
j =1 k =1
{ 1 j}
IX 1, X 2 = − ∑ ∑(log p j + log qk )1I X =α 1I {X 2 =β k } .

J K
j =1 k =1
{ 1 j}
K K
En remarquant alors que ∑ log qk 1I{X 2 = βk } = − IX 2 et que ∑ log p j
1I {X 2 =β k } = log p j , on déduit
k =1 k =1
( )
J
IX 1, X 2 = − ∑ log p j − I X 2 1I{X =α } = IX 1 + I X 2 (cqfd).
1 j
j =1
On peut généraliser ce résultat à n variables aléatoires indépendantes.

Disposant du résultat précédent, on va appliquer l'inégalité de Chébychef à la variable

1 n
aléatoire ∑ I X i :
n i =1
1 n  σ I Xi
2
∀η > 0 P  ∑ I X i − H ( X ) > η  ≤ 2 2 c'est-à-dire:

î n i =1  n η
les suites cn de longueur n (cn = (α 1,α 2 ,..., αn ), avec pi = P {X = α i })

  σ 2I
∀η > 0 P n  ≤ 2 i2
X
î vérifiant − n ∑ log pi − H ( X ) > η

1 n η

i =1
soit:
  σ 2I
∀η > 0 P 1  n   ≤ 2 i2
X
vérifiant − log ∏ pi − H ( X ) > η n η

 n  i =1  
î 
n
La source X étant sans mémoire, P(cn ) = ∏ pi , d'où:
i =1

  σ 2I
∀η > 0 P 1  ≤ 2 i2
X
vérifiant − log P (cn ) − H( X ) > η  n η

î n 
C'est-à-dire:
  σ 2I X
∀η > 0 P 1  ≥ 1 − 2 i2
vérifiant − log P (cn ) − H( X ) < η  n η
î n 
σ 2X σXi
Il suffit donc de choisir n tel que 2 i 2 < ε c'est-à-dire n > . On aura alors, avec une
n η η ε
probabilité supérieure à 1 − ε :
log P(c n ) + H (X ) < η soit:

1
−η <
n
− n(η + H( X )) < log P (cn ) < n(η − H ( X )), soit encore:
< P(c n ) < a

− n( η + H( X ) ) n (η − H ( X ))
a
Remarque
En fait le théorème précédent reste vrai dans le cadre plus général d'une source ergodique
(donc pas forcément sans mémoire).
Commentaires
Si H(X) est mesurée en bits, c'est-à-dire si a = 2 , et si η << H (X ) , alors: P(c ) ≈ 2 −

nH ( X )
(pour
une suite typique). De plus si ε est très petit devant 1, cela signifie que la somme cumulée des
probabilités des suites typiques est proche de 1. Donc on peut considérer qu'il y a à peu près
nH ( X )
2 suites typiques de longueur n. Il faut donc log 2 2 nH (X ) bits pour coder toutes les suites
typiques, soit nH (X ) bits.
Si K représente la taille de l'alphabet source, il y a K n suites possibles de longueur n.

L'entropie maximum de la source serait, si ses valeurs étaient équidistribuées, H MAX = log 2 K .
Le nombre de suites typiques serait 2 nlog 2 K = K n : Toutes les suites seraient typiques et la
compaction d'une telle source est bien sûr impossible.

Supposant que la source possède de la redondance, c'est-à-dire que H (X ) < HMAX , on a
nH (X ) < nHMAX soit 2

nH ( X )
< 2 2 = K . Cela signifie que la réduction du nombre de suites
nlog K n
possibles au nombre de suites typiques est liée directement à la redondance de la source.
L'exploitation de ces résultats va consister à attribuer à chaque séquence typique un mot code
différent et à regrouper toutes les séquences atypiques sous un même mot code appelé mot
code par défaut. La détection du mot code par défaut entraînera une impossibilité d'associer
sans risque d'erreur un mot source. Ce procédé de codage permet d'énoncer le rpremier
théorème de Shannon.
PREMIER THÉORÈME DE SHANNON
Soit X une source discrète sans mémoire d'entropie H (X ) . Alors il est possible de trouver un
r
code bloc pour encoder les mots source de longueur n avec un taux R = tel que la
n
probabilité de ne pouvoir associer avec certitude un mot source à un mot code soit aussi petite
que l'on veut. Il suffit pour cela que, d'une part n soit suffisamment grand et d'autre part que
r H(X )
R vérifie: R = > où D représente la taille de l'alphabet de référence pour la
n log D
construction du code.
L'idée consiste à vérifier que les hypothèses du théorème sont telles que le nombre de suites
typiques est inférieur à D r .

r H( X )
> ⇒ r log D > n H ( X )
n log D
Donc ∃ ξ > 0 / r log D > n (H( X ) + ξ ). Choisissons alors η dans le théorème de Shannon-
Mac-Millan tel que 0 < η < ξ . On peut écrire r log D > n (H( X ) + η ). Or le nombre
n (H (X )+ η )
maximum de suites typiques est a (il correspond à l'inverse de la plus petite
probabilité pour les suites typiques). Et de la relation r log D > n (H( X ) + η ), on déduit:
n (H ( X ) + η )
< D . (cqfd).
r
nombre de suites typiques < a
Ainsi il suffit d'attribuer à chaque suite typique un mot code différent et de faire correspondre
à toutes les suites atypiques le même mot code (différent des autres mots code). En recevant
ce mot code appelé mot code par défaut, on ne sera pas en mesure de retrouver le mot source
sans risque d'erreur mais cette éventualité ne se produira qu'avec une probabilité inférieure à
ε , nombre fixé arbitrairement aussi petit que l'on veut.
Remarque
Ce type de codage ne correspond pas à une compaction, mais plutôt à une compression des
données avec perte d'information, négligeable si ε est très petit.
THÉORÈME RÉCIPROQUE DU PREMIER THÉORÈME DE SHANNON
Soient ε > 0 et une source discrète sans mémoire d'entropie H (X ) . On note D la taille de
H (X )
l'alphabet code de référence. Si R est un nombre positif vérifiant R < , alors pour tous
log D
les codes bloc de taux R encodant les mots source de longueur n et n suffisamment grand, la
probabilité pe de ne pouvoir associer sans risque d'erreur un mot source à un mot code vérifie
pe > 1− ε .
Notons r la longueur d'un mot code et C' l'ensemble des mots source de longueur n à chacun
desquels il correspond un mot

code différent des autres mots code. Alors:
r
Card C' ≤ D − 1 = D − 1 en posant R = . Le "-1" correspond au mot code par défaut et
r nR
n
l'inégalité signifie que toutes les combinaisons de r lettres code ne sont pas forcément utilisées
pour écrire tous les mots code. On a donc:
H (X )
Card C' < DnR = anR log a D = a [ a ]. De l'hypothèse R < , c'est-à-dire Rlog a D < H ( X ),
n R log D
log D
on déduit qu'il existe η > 0 tel que Card C' < a ( ( ) ) . En outre, la probabilité de pouvoir
n H X −η
associer sans risque d'erreur un mot source à un mot code est 1 − pe = ∑ P (s ) . En classant les
s∈C'
ε
suites s en suites typiques T et suites atypiques T' (de probabilité cumulée inférieure à ),
2
on peut écrire:
1 − pe = ∑ P(s ) + ∑ P(s)
s∈C' ∩T' s∈C' ∩T
ε
Or ∑ P (s) ≤ ∑ P (s) < 2
s ∈C' ∩T ' s∈T'
D'autre part:
∑ P (s) ≤ Card(C' ∩ T ) Max P (s) ≤ Card(T ) Max P (s), c'est-à-dire:

s ∈C' ∩T
s ∈C' ∩T s ∈T
 η
− n  H( X ) −  −n
η
η
∑ P (s) ≤ a
n (H ( X ) − η )
a  2
=a 2
(en prenant dans le théorème de Shannon-Mac-
s ∈C' ∩ T 2
Millan)
η η
ε −n −n
D'où 1 − pe < + a 2 . Or à η > 0 , a 2 → 0 lorsque n → +∞ .
2
η
−n ε ε ε
Donc pour n assez grand, on a a 2
< soit 1 − pe < + = ε c'est-à-dire pe > 1− ε .
2 2 2

Chapter 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapter 2

Transféré par

Droits d'auteur :

Formats disponibles

SOURCES DISCRETES

ENTROPIE D'UNE SOURCE DISCRETE ................................................................ ...3

CODAGE DE SOURCE ................................................................ ............................... 8

GENERALITES SUR LES CODES ................................................................ ....9

CODAGE D'UNE VARIABLE ALEATOIRE DISCRETE................................14

CODAGE D'UNE SOURCE ................................................................ .............. 16

CODES A LONGUEUR VARIABLE....................................................... 16

CODES BLOC................................................................ .......................... 35

ENTROPIE D'UNE SOURCE DISCRÈTE

XFOML RHKHJFFJUJ ZLPWCFWCKCYJFFJEYVKCQSGHYD

Lettre Fréquence Lettre Fréquence Lettre Fréquence

OCRO HLI RGWR NMIEL VIS EU LL NBNESEBYA TH EEI

ON IE ANTSOUTINYS ARE T INCORE ST BE S DEAMY ACHIN D

IS NO IST LAT WHEY CRATICT FROURE BIRS GROCID

lim H (U L / U1 ,U2 ,...,U L −1 ) .

- H L (U ) ≥ H(UL / U1 ,U 2 ,...,U L−1 ) (2)

- H L (U ) est une fonction décroissante de L (3) .

- En conséquence, on définira l'entropie par lettre de la source U par:

On a vu que le conditionnement diminue l'entropie (ie H ( X / Y ) ≤ H( X )),

donc: H (UL / U1 ,U2 ,...,U L−1 ) ≤ H (UL / U 2 ,...,U L −1 ) et par stationnarité:

H (UL / U 2 ,...,U L −1 ) = H (U L −1 / U1 ,U 2 ,...,U L− 2 ),

H (UL / U1,U2 ,...,U L−1 ) ≤ H (U L −1 / U1 ,...,U L− 2 ), ce qui montre le (1).

Montrons maintenant le (2).

H L (U ) = H(U1 , U2 ,...,U L ) = (H (U1 ) + H (U2 / U1 ) + H(U3 / U1, U2 )+...+ H (U L / U1 ,U2 ,..., UL −1 ))

(donc minorées). Elles sont donc convergentes.

H∞ (U ) ≥ lim H(UL / U1 ,U 2 ,...,U L −1 ).

Il nous reste donc à montrer que H∞ (U ) ≤ lim H(UL / U1 ,U 2 ,...,U L −1 ).

comme le conditionnement diminue l'entropie:

vers l'infini, on obtient:

Remarques (corollaire du théorème)

- Si U est une chaîne de Markov homogène d'ordre 1, alors H∞ (U ) = H (U 2 / U1 ) .

lorsque des contraintes de stockage ou de transmission de l'information sont imposées. Ceci

GÉNÉRALITÉS SUR LES CODES

Soit B un alphabet de référence, c'est-à-dire un ensemble de lettres (en général B est

{0,11,010} est uniquement déchiffrable.

100 101 110 111

{0,10,110,111} est un code préfixe.

b = nombre de lettres dans l'alphabet de référence

Remarque: La somme est effectuée sur tous les mots code.

sera satisfaite avec l'inégalité stricte.

Supposons maintenant que le code C possède au moins un mot c de longueur i strictement

sous-arbre engendré par c Longueur des mots

m1 b−1 + m 2 b−2 + m3 b−3 ≤ 1

(1') nous permet de construire les m1 mots de longueur 1 grâce à un arbre.

Dans (2') b 2 − m1 b représente la différence entre le nombre de mots possibles de longueur 2 et

longueur 1. De même pour (3'): b 3 représenterait le nombre de mots possibles de longueur 3

Considérons le polynôme énumérateur des longueurs du code C:

P( z ) = ∑ z = z 1 + z 2 +...+z avec n1 ≤ n2 ≤...≤ nM les longueurs des M mots code et

courts ont pour longueur 1 et k après concaténation.

CODAGE D'UNE VARIABLE ALÉATOIRE DISCRÈTE

Avant d'étudier le codage de source qui va concerner les réalisations successives de U

avec M = nombre de mots code

Puisque le code C est uniquement déchiffrable, on a ∑b

∑ −n(i)pi log b − ∑ pi logQ + H( X ) ≤ 0

d'où − n logb − logQ + H (X ) ≤ 0 soit

nlog b ≥ H (X ) − logQ ≥ H(X ) car Q ≤ 1 (cqfd).

nlog b < H (X ) + logb

assure l'existence d'un code préfixe. De plus:

n(i ) < − logb pi + 1 ⇒ n(i )pi < − pi logb + pi d'où:

Si a est la base du logarithme pour le calcul de H(X):

nlog b < H( X) + log b (cqfd).

CODAGE D'UNE SOURCE

CODES À LONGUEUR VARIABLE