FullCourseEPFL FR

EIDGENÖSSISCHE TECHNISCHE HOCHSCHULE – LAUSANNE
POLITECNICO FEDERALE – LOSANNA

ÉC O L E P O L Y T E C H N I Q U E SWISS FEDERAL INSTITUTE OF TECHNOLOGY – LAUSANNE
FÉ DÉR A L E D E L A U S A N N E
Faculté Informatique et Communications
Introduction à la Théorie de l’Information

et ses applications
F. Bavaud J.-C. Chappelier J. Kohlas
version 2.4FR – 20080130 – cours EPFL
Cours destiné aux étudiants :

Informatique BA-6
Mathématiques MA-2 (OPT)
Ecublens, Février 2008.

°
c sous licence « Creative Commons Attribution-NonCommercial-ShareAlike 2.5 License ».
Table des matières
1 Incertitude et Information 1
1.1 Entropie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Choix et incertitude . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Choix avec probabilité connue . . . . . . . . . . . . . . . . . . . . . . 9
1.1.3 Variables aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.1.4 Entropie conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.2 L’information et sa mesure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.2.1 Observations et événements . . . . . . . . . . . . . . . . . . . . . . . 28
1.2.2 Information mutuelle et divergence de Kullback-Leibler . . . . . . . . 34
1.2.3 Surprise, entropie et information . . . . . . . . . . . . . . . . . . . . . 42
2 Exercices du module C1 47
2.1 Entropie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2 La mesure de l’information . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3 Processus stationnaires & chaînes de Markov 53

3.1 Le taux d’entropie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2 Le théorème AEP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.2.1 Le concept d’ensemble typique : redondance et compressibilité . . . . . 58
3.3 Chaînes de Markov de premier ordre . . . . . . . . . . . . . . . . . . . . . . . 62
3.3.1 Matrice de transition en n étapes . . . . . . . . . . . . . . . . . . . . . 62
3.3.2 Chair et squelette. Classification des états. . . . . . . . . . . . . . . . . 63
3.3.3 Distribution stationnaire . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.3.4 Taux d’entropie d’une chaîne de Markov . . . . . . . . . . . . . . . . 67
3.3.5 Irréversibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.4 Chaînes de Markov d’ordre supérieur . . . . . . . . . . . . . . . . . . . . . . 71
3.4.1 Distribution stationnaire et taux d’entropie . . . . . . . . . . . . . . . 71
3.5 Reconstruction de modèles de Markov à partir des données . . . . . . . . . . . 73
3.5.1 Distributions empiriques et théoriques . . . . . . . . . . . . . . . . . . 74
3.5.2 La formule des types pour les chaînes de Markov . . . . . . . . . . . . 76
3.5.3 Vraisemblance maximale et malédiction de la dimensionnalité . . . . . 78
3.5.4 Tester l’ordre d’une chaîne de Markov . . . . . . . . . . . . . . . . . . 79
3.5.5 Simuler un processus de Markov . . . . . . . . . . . . . . . . . . . . . 83
4.1 Chaînes de Markov de premier ordre . . . . . . . . . . . . . . . . . . . . . . . 87
i
ii TABLE DES MATIÈRES
5 Codage efficace de l’information 89

5.1 Coder une variable aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.1.1 Codes sans préfixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.1.2 Arbres n-aires pour le codage . . . . . . . . . . . . . . . . . . . . . . 94
5.1.3 Inégalité de Kraft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2 Codage efficace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
5.2.1 Qu’est-ce qu’un code efficace ? . . . . . . . . . . . . . . . . . . . . . 101
5.2.2 Arbres n-aires probabilisés : longueur du chemin et incertitude . . . . . 102
5.2.3 Théorème du codage sans bruit . . . . . . . . . . . . . . . . . . . . . . 105
5.2.4 Codes de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

6.1 Coder une variable aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
6.2 Codage efficace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7 Compléments au Codage efficace de l’Information 121

7.1 Codes de longueur fixe : Code de Tunstall . . . . . . . . . . . . . . . . . . . . 121
7.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
7.1.2 Ensembles Propres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
7.1.3 Ensembles de messages de Tunstall . . . . . . . . . . . . . . . . . . . 124
7.1.4 Algorithme de construction du code de Tunstall . . . . . . . . . . . . . 126
7.2 Codage des Entiers Positifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
7.3 Codage de Sources à Mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . 130
7.3.1 Codage de Huffman par blocs . . . . . . . . . . . . . . . . . . . . . . 131
7.3.2 Schéma de Codage de Source de Elias-Willems . . . . . . . . . . . . . 132
7.3.3 Codages de Lempel-Ziv . . . . . . . . . . . . . . . . . . . . . . . . . 134
8 Exercices du module I1 139

8.1 Codes de longueur fixe : codes de Tunstall . . . . . . . . . . . . . . . . . . . . 139
8.2 Codage de séquences d’entiers positifs . . . . . . . . . . . . . . . . . . . . . . 139
8.3 Codage de sources à mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . 140
9 Transmission d’information en présence de bruit 143

9.1 Canal de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
9.1.1 Canaux de communication . . . . . . . . . . . . . . . . . . . . . . . . 145
9.1.2 Capacité d’un canal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
9.1.3 Canal symétrique à l’entrée . . . . . . . . . . . . . . . . . . . . . . . 149
9.1.4 Canal symétrique en sortie . . . . . . . . . . . . . . . . . . . . . . . . 150
9.1.5 Canal symétrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
9.1.6 Taux de transmission . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
9.2 Quelques lemmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
9.2.1 Lemme de l’utilisation multiple . . . . . . . . . . . . . . . . . . . . . 152
9.2.2 Lemme du traitement des données . . . . . . . . . . . . . . . . . . . . 152
9.2.3 Lemme de Fano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
9.3 Le théorème de codage en présence de bruit . . . . . . . . . . . . . . . . . . . 155
9.3.1 Codage par répétition . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
TABLE DES MATIÈRES iii
9.3.2 La partie réciproque du théorème de codage en présence de bruit pour

un DMC sans retour . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
9.3.3 Le théorème de codage en présence de bruit pour un DMC . . . . . . . 159

10.1 Canaux de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
10.2 Théorème de codage en présence de bruit . . . . . . . . . . . . . . . . . . . . 170
11 Codes correcteurs d’erreurs 171

11.1 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
11.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
11.1.2 Distance de Hamming et poids d’un mot de code . . . . . . . . . . . . 173
11.1.3 Décodage à distance minimale et à vraisemblance maximale . . . . . . 175
11.1.4 Détection et correction d’erreurs . . . . . . . . . . . . . . . . . . . . . 177
11.2 Codes linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
11.2.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
11.2.2 Quelques propriétés des codes linéaires . . . . . . . . . . . . . . . . . 181
11.2.3 Codage avec des codes linéaires . . . . . . . . . . . . . . . . . . . . . 183
11.2.4 Forme systématique d’un code linéaire . . . . . . . . . . . . . . . . . 184
11.2.5 Décodage : Matrice de vérification . . . . . . . . . . . . . . . . . . . . 186
11.2.6 Syndromes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
11.2.7 Distance minimale et matrice de vérification . . . . . . . . . . . . . . . 190
11.2.8 Codes de Hamming binaires . . . . . . . . . . . . . . . . . . . . . . . 192
11.3 Codes cycliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
11.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
11.3.2 Codes cycliques et polynômes . . . . . . . . . . . . . . . . . . . . . . 196
11.3.3 Décodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
11.4 Codes convolutionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
11.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
11.4.2 Codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
11.4.3 Définition générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
11.4.4 Représentation sous forme de treillis . . . . . . . . . . . . . . . . . . . 206
11.4.5 Décodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
11.4.6 Distance minimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

12.1 Codes linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
12.2 Codes cycliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
12.3 Codes de convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
13 Cryptographie 219
13.1 Cadre Général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
13.1.1 Buts de la Cryptographie . . . . . . . . . . . . . . . . . . . . . . . . . 220
13.1.2 Exemples Historiques . . . . . . . . . . . . . . . . . . . . . . . . . . 221
13.2 Confidentialité Parfaite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
13.2.1 Définition et Conséquences . . . . . . . . . . . . . . . . . . . . . . . . 224
13.2.2 Un Exemple : le One-Time Pad . . . . . . . . . . . . . . . . . . . . . 225
iv TABLE DES MATIÈRES
13.2.3 Confidentialité Imparfaite et Distance d’Unicité . . . . . . . . . . . . . 226

13.2.4 Distance d’Unicité Croissante : Codage Homophonique . . . . . . . . 228
13.3 Confidentialité en Pratique : Sécurité Algorithmique . . . . . . . . . . . . . . . 229
13.3.1 Complexité Algorithmique . . . . . . . . . . . . . . . . . . . . . . . . 230
13.3.2 Fonctions à Sens Unique . . . . . . . . . . . . . . . . . . . . . . . . . 232
13.3.3 DES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
13.4 Cryptographie à clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
13.4.1 Un peu de Mathématiques . . . . . . . . . . . . . . . . . . . . . . . . 236
13.4.2 Le Système de Distribution de Clés de Diffie-Hellman . . . . . . . . . 237
13.4.3 Fonctions à trappe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
13.4.4 RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
13.5 Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
13.5.1 Authentification et Sécurité . . . . . . . . . . . . . . . . . . . . . . . . 242
13.5.2 Authentification de Diffie-Lamport . . . . . . . . . . . . . . . . . . . 244
13.5.3 Authentification par RSA . . . . . . . . . . . . . . . . . . . . . . . . . 244
13.5.4 Secrets partagés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

14.1 Cadre général – Exemples historiques . . . . . . . . . . . . . . . . . . . . . . 253
14.2 Confidentialité parfaite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
14.3 Sécurité algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
14.4 Cryptographie à clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
14.5 Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Notations
VX : ensemble des valeurs de la variable aléatoire X.

ε : la chaîne vide.
E [X] : espérance de X.
P (X = 3) : probabilité.
pX (3) : distribution de probabilité de la variable X.
Notez que pX (3) = P (X = 3).
1 an
an ≅ bn : équivalence exponentielle asymptotique : lim log( ) = 0.
n→∞ n bn
X := Y , et Y =: X: égal par définition.
Dans les deux cas, il faut comprendre « X est par définition égal à Y ».
M T : transposée de la matrice M .
e
h(x) = −x log2 x − (1 − x) log2 (1 − x)
v
vi TABLE DES MATIÈRES
Chapitre 1
Module C1 : Incertitude et
information
par J ÜRG KOHLAS
O BJECTIFS PÉDAGOGIQUES DU CHAPITRE 1

Après avoir étudié ce module, vous devriez comprendre
– pourquoi il est important de mesurer le degré d’incertitude dans une situation de
choix ;
– en quoi l’entropie est une bonne unité de mesure de l’incertitude ;
– en quoi l’information et l’incertitude sont liées et, par conséquent, pourquoi
l’entropie a un rôle important dans la mesure de l’information ;
– que l’information est toujours relative à une question précise et à une information
préalable.
Introduction
Bienvenue dans cette première étape du monde de la théorie de l’information. De toute évi-
dence, dans un monde qui est en passe de devenir une société d’information, la notion et
le concept d’information devraient soulever une grande attention scientifique. En fait, bien
que le développement de l’information pragmatique, dans les ordinateurs, sur Internet et dans
d’autres réseaux informatiques, évolue à une allure extrêmement rapide, l’étude théorique et
conceptuelle de ce qu’est l’information et de la façon dont elle devrait être traitée ne suit pas
vraiment ce rythme frénétique.
La théorie de l’information, dans le sens technique qu’on lui donne aujourd’hui, remonte au
travail de Claude Shannon. Elle a été introduite comme moyen d’étudier et de résoudre les
problèmes de communication ou de transmission de signaux à travers des canaux. Bien que
ce soit une vision relativement étroite de l’information qui se penche plus particulièrement sur
la mesure du contenu de l’information, elle doit être incluse dans toute théorie – plus large –
de l’information. C’est pourquoi ce module est une introduction aux éléments de base de la
1
2 CHAPITRE 1. INCERTITUDE ET INFORMATION
théorie de l’information telle que Shannon et ses successeurs l’ont établie.

Mais, dans ce premier module déjà, nous tenterons d’élargir notre vision de l’information.
Nous soulignerons qu’une information doit toujours être considérée par rapport à des questions
précises. Une même information peut porter sur différentes questions, et son contenu d’infor-
mation sera différent selon chaque question. Dans le cas de certaines questions, le contenu peut
même être vide. La quantité contenue dans une information par rapport à une question donnée
sera mesurée par la réduction de l’incertitude concernant cette question et induite par l’in-
formation ou, plus généralement, par le changement de l’incertitude. Nous suivrons Shannon
en mesurant l’incertitude par l’entropie. Notre approche est dans l’esprit de celle de Shannon
dans la mesure où l’information est mesurée par changement d’entropie, mais, en indiquant
explicitement la question à laquelle l’information est appliquée, nous irons plus loin que lui.
Nous insisterons également sur l’importance de l’information préalable, par rapport à laquelle
la quantité d’information sera mesurée. Bien que ceci soit implicite dans l’approche de Shan-
non, l’expliciter rend le concept plus clair. En effet, de ce point de vue, il devient évident
que les probabilités sont elles-mêmes de l’information dont le contenu peut être mesuré par
changement d’entropie.
Au fil des discussions il devient clair que l’information a aussi une structure algébrique : l’in-
formation peut être combinée ou assemblée et doit être concentrée sur des questions spécifiées.
Cependant, nous ne traiterons pas cet aspect important en profondeur; cette tâche est réservée
à d’autres modules. Ceci est également valable pour l’application de la théorie classique de
l’information au codage, à la communication et à d’autres domaines.
Nous vous souhaitons beaucoup de plaisir dans l’étude de ce cours.
1.1 Entropie
O BJECTIFS PÉDAGOGIQUES DE LA SECTION 1.1

Après avoir étudié cette section, vous devriez
– savoir comment l’entropie est définie et quelles sont ses propriétés les plus impor-
tantes;
– comprendre en quoi l’entropie est une bonne mesure de l’incertitude.
1.1.1 Choix et incertitude
O BJECTIFS PÉDAGOGIQUES DE LA SOUS - SECTION 1.1.1

Après avoir étudié cette sous-section, vous devriez
– savoir comment décrire formellement une situation de choix ;
– comprendre comment un jeu de questions-réponses mène à une mesure de la quan-
tité d’incertitude dans une situation de choix;
– comprendre pourquoi cette mesure est un logarithme et quelles sont ses unités;
– comprendre comment des choix possibles peuvent être codés par l’utilisation du
jeu des questions-réponses.
Toute situation d’incertitude peut être décrite comme une situation dans laquelle il existe plu-
sieurs possibilités, sans que l’on sache laquelle sera sélectionnée. Un exemple typique lié aux
1.1. ENTROPIE 3
ordinateurs est la question : « quelle sera la prochaine frappe de l’utilisateur ? » Selon le type
de clavier, il y aura plusieurs douzaines de possibilités, si les frappes combinées sont permises.
Une situation d’incertitude plus complexe naîtra si l’on considère une séquence complète de
frappes dans une session de dialogue. Il existe bien sûr un grand nombre de situations d’in-
certitude dans la vie courante, dans la recherche et le diagnostic médicaux, ainsi que dans
l’inférence statistique et les enquêtes criminelles, etc. L’étude de l’incertitude et la mesure
de sa quantité dans une situation donnée présentent donc un intérêt certain. La mesure de la
quantité d’incertitude est même une question fondamentale en communication et en théorie de
l’information.
Commençons par la description formelle d’une situation d’incertitude. Supposons qu’il existe
un cas dans lequel il se trouve une possibilité parmi m différentes possibilités. Nous dési-
gnons ces possibilités par e1 , e2 , . . . , em . Un tel ensemble de possibilités, désigné par S =
{e1 , e2 , . . . , em } est appelé un schéma de choix (fini). L’idée est que l’une de ces possibilités
est sélectionnée par une personne, un processus ou un mécanisme etc. L’incertitude survient
parce que nous ignorons laquelle des m possibilités est sélectionnée.
Comment mesurer la quantité d’incertitude dans un schéma de choix S? Intuitivement, plus la
cardinalité |S| de S (le nombre d’éléments de S) est grande, plus l’incertitude sera grande. Ceci
semble clair. Aussi, pourquoi ne pas simplement prendre |S| comme mesure de l’incertitude?
En effet, c’est une possibilité. Mais nous allons suivre une autre approche. Imaginons le jeu
suivant : je sélectionne une possibilité de S et vous pouvez me poser des questions sur mon
choix. Toutefois, je n’accepte que les questions auxquelles je peux répondre par «oui» ou par
«non». Dans tous les cas nous pouvons considérer que les possibilités sont représentées par les
nombres 1, 2, . . . , m = |S|. Aussi pourriez-vous poser des questions telles que: «le nombre
que vous avez sélectionné est-il impair?», «est-il inférieur à 10?», «supérieur à 13?», etc. Plus
vous aurez besoin de poser des questions, plus l’incertitude sera grande. Donc l’idée est de
mesurer l’incertitude par le nombre de questions que vous aurez besoin de poser pour trouver
mon choix.
Bien entendu, vous devrez poser des questions habiles. Si vous choisissez de demander si le
nombre est 1, si non, si c’est 2, etc., vous pourriez avoir besoin des m questions pour découvrir
mon choix. Il est clair que ceci n’est pas une méthode optimale. Cependant, si vous demandez
d’abord si le nombre est inférieur à m/2, ma réponse vous permettra de limiter la suite de votre
investigation à la moitié des possibilités initiales seulement. Ensuite vous pourriez procéder
d’une façon similaire. Ceci semble donc être une façon habile de découvrir mon choix.
Pour être un peu plus formels, considérons d’abord que m est une puissance de 2, m = 2n .
Puis nous pourrions diviser S par la première question (votre choix est-il supérieur à 2n−1 ?)
en deux moitiés de taille égale : {1, . . . , 2n−1 } et {2n−1 + 1, . . . , 2n }. Chaque moitié peut être
encore divisée en deux avec la deuxième question. Si la réponse à la première question est
«non», alors la deuxième question détermine soit {1, . . . , 2n−2 } soit {2n−2 + 1, . . . , 2n−1 }.
Si la réponse à la première question était «oui», alors la question suivante fait la distinction
entre {2n−1 + 1, . . . , 2n−1 + 2n−2 } ou {2n−1 + 2n−2 + 1, . . . , 2n }. Ce processus de questions
et réponses est représenté en figure 1.1. Chaque question est représentée par un nœud, en
commençant par la première question. Un nœud de questions est désigné par l’ensemble des
possibilités identifiées jusque-là. Le premier nœud est donc désigné par tout l’ensemble S;
les nœuds du premier niveau par les deux demi-ensembles; au second niveau par les quatre
quarts d’ensembles, etc. Chaque réponse possible est indiquée par un arc quittant le nœud.
Nous désignons une réponse «non» par un ’0’ et une réponse «oui» par un ’1’.
Le processus de division des ensembles de possibilités en moitiés égales prend fin avec la
découverte du choix exact après exactement n étapes. Le nombre n n’est rien d’autre que le
4
1.1. ENTROPIE 5
Définition 1.1 La quantité d’incertitude d’un schéma de choix. Pour un système de

choix S avec |S| choix possibles, nous définissons la quantité d’incertitude h(|S|)
par
h(|S|) = log |S|.
Exemple 1.1 (Echiquier) Prenons comme premier exemple celui d’un échiquier vide. Il
existe exactement m = 64 = 26 possibilités de placer une pièce dessus. Ainsi, le système de
choix peut être représenté par S = {1, 2, . . . , 64}, où chaque nombre représente une case de
l’échiquier. La quantité d’incertitude du placement d’une pièce sur un échiquier est
h(|S|) = log 64 = 6 bit.
Comme toute définition, celle-ci est également arbitraire jusqu’à un certain degré. C’est fina-
lement son utilité et son élégance dans les applications qui la justifiera. Nous tenterons de le
faire dans la suite de ce module et dans d’autres.
On peut d’ailleurs également jouer aux questions-réponses avec des questions qui ont plus de
2 réponses possibles. Supposons que les questions ont k > 2 réponses possibles . Alors chaque
question permet de diviser l’ensemble de m possibilités en k sous-ensembles d’environ m/k
éléments. Donc, comme nous l’avons démontré plus haut, si |S| = k n , alors nous aurons
besoin d’exactement n = logk |S| questions. Cette fois nous utilisons le logarithme à base k.
Donc nous aurions pu définir
h(|S|) = logk |S|.
Mais nous avons
logk |S| = logk (2) · log2 |S|.
Changer la base du logarithme revient donc à changer d’unité de mesure, et ce n’est pas un
changement vraiment essentiel. Dorénavant, un log sans indication de la base a par défaut dans
ce chapitre, un logarithme en base 2.
Si nous avons un système de choix S et un arbre de questions correspondant, (comme en
figure 1.1), alors nous avons en même temps un codage des possibilités du système de choix.
En concaténant le “0” et le “1” sur le chemin de la racine à la possibilité en question, on
obtient un code de cette possibilité. Si nous utilisons des questions binaires, nous aurons un
code binaire pour le système de choix. Notez que la longueur du code de chaque possibilité
égale soit l’entier inférieur suivant, soit l’entier supérieur suivant de h(|S|) = log |S|. Ceci
est une première approche de la relation étroite entre l’incertitude et le codage. Ce point sera
étudié plus loin, dans le chapitre 5.
Exemple 1.2 (Arbre de questions binaires) Un système de choix est donné par S =
{1, 2, 3, 4, 5}. Sa quantité d’incertitude est
h(|S|) = log 5 ≈ 2, 3219 bit
Un arbre de questions binaires correspondant possible est représenté en figure 1.3. On voit
aisément que le code 001 représente la possibilité {2} et que sa longueur 3 est l’entier suivant
supérieur de h(|S|). La possibilité {3} a comme longueur de code 2, {4} a comme longueur
2, etc.
F IG . 1.3 – Example: L’arbre de questions binaires d’un sytème de 5 possibilités.
Voici maintenant quelques propriétés très simples de notre mesure de l’incertitude h(|S|) :
1. Si S1 et S2 sont deux systèmes de choix et |S1 | = |S2 |, alors h(|S1 |) = h(|S2 |). Seul le
nombre de possibilités importe dans un système de choix, et non leur nature.
2. Si S1 et S2 sont deux systèmes de choix et |S1 | < |S2 |, alors h(|S1 |) < h(|S2 |), puisque
le logarithme est une fonction croissante. C’est ce que nous attendons : l’incertitude
augmente avec le nombre de possibilités d’un choix.
3. Si S1 et S2 sont deux systèmes de choix et que S2 a le double des possibilités de S1
(|S2 | = 2 · |S1 |), alors, en utilisant le logarithme en base 2, nous obtenons h(|S2 |) =
h(|S1 |) + 1. Ceci découle de l’additivité du logarithme, et de log2 2 = 1,
h(|S2 |) = log2 |S2 | = log2 (2 · |S1 |) = log2 2 + log2 |S1 | = 1 + h(|S1 |).
4. Si S est un système de choix avec seulement deux possibilités, alors, avec la base 2 pour
le logarithme, h(|S|) = log2 2 = 1. Cette unité de mesure est appelée un bit (binary
information unit). Nous verrons que l’incertitude est étroitement liée à l’information, et
qu’on mesure cette dernière par les mêmes unités que l’incertitude. Nous pénètrerons
ainsi dans le royaume des ordinateurs. C’est pour cela que les questions binaires sont les
plus connues.
Si nous avons deux systèmes de choix S1 = {e1,1 , e1,2 , . . . , e1,n } et S2 = {e2,1 , e2,2 , . . . , e2,m },
alors les deux possibilités de choix correspondantes peuvent être assemblées en un système
combiné qui contient toutes les combinaisons n · m par paires de choix possibles :
{(e1,1 , e2,1 ), (e1,1 , e2,2 ), . . . , (e1,2 , e2,1 ), . . . , (e1,n , e2,m )} .
Un tel ensemble de paires est appelé produit cartésien des deux ensembles individuels, et se
présente comme suit :
S1 × S2 = {(e1,1 , e2,1 ), (e1,1 , e2,2 ), . . . , (e1,2 , e2,1 ), . . . , (e1,n , e2,m )} .
On appelle ce nouveau système de choix un système de choix indépendants. Ceci exprime

l’idée selon laquelle le choix, dans chacun des deux systèmes, se fait indépendamment du choix
dans l’autre système, afin d’obtenir le choix combiné. Comment la quantité d’incertitude d’un
tel système de choix indépendants est-elle reliée à la quantité d’incertitude dans chacun des
deux systèmes de choix ? La réponse, simple, est donnée dans le théorème ci-dessous.
1.1. ENTROPIE 7
Théorème 1.1 (Additivité de l’incertitude) L’incertitude du système de choix indé-

pendants est la somme de l’incertitude des deux systèmes simples.
h(|S1 × S2 |) = h(|S1 |) + h(|S2 |).
D ÉMONSTRATION La démonstration est simple, puisqu’il s’agit essentiellement de l’additi-

vité du logarithme. En fait,
h(|S1 × S2 |) = log |S1 × S2 | = log(|S1 | · |S2 |)

= log |S1 | + log |S2 | = h(|S1 |) + h(|S2 |).
Ce théorème est une parfaite justification de notre définition de la mesure de l’incertitude : on

pourrait s’attendre à ce que les incertitudes de deux situations indépendantes s’additionnent
lorsqu’elles sont considérées ensemble.
Exemple 1.3 (Echiquier - Suite) Retournons à la situation de l’échiquier, décrite dans

l’exemple 1.1. Nous avons vu que la quantité d’incertitude du placement d’une pièce sur
tout l’échiquier est h(|S|) = log 64 = 6. De la même façon, nous voyons que la quantité
d’incertitude du placement d’une pièce dans une seule rangée ou dans une seule colonne est
log 8 = 3. Nous obtenons donc le résultat attendu
6 = log 64 = log 8 + log 8.
Bien entendu, ceci peut être généralisé et étendu à la combinaison de plus de deux choix
indépendants. Admettons que S1 , S2 , . . . , Sm soient m systèmes de choix. Alors le produit
cartésien des m-tuples
S1 × S2 × · · · × Sm = {(e1,1 , e2,1 , . . . , em,1 ), . . .}
est le système de choix indépendants correspondant.
Corollaire 1.1
h(|S1 × S2 × · · · × Sm |) = h(|S1 |) + h(|S2 |) + · · · + h(|Sm |). (1.1)
Exemple 1.4 (Dé) Lançons un dé m fois et considérons que les lancers sont indépendants.
Ceci peut être modelé par m systèmes de choix indépendants S1 , . . . , Sm , dans lesquels
chaque système contient 6 possibilités. D’après le corollaire 1.1, nous obtenons que
h(|S1 × S2 × · · · × Sm |) = h(|S1 |) + h(|S2 |) + · · · + h(|Sm |) = m · log 6.
R ÉSUMÉ DE LA SOUS - SECTION 1.1.1
– Nous avons donné une forme précise à des situations d’incertitude par des systèmes de
choix S, dans lesquels une, parmi un nombre fini de possibilités, sera sélectionnée, sans
que l’on sache laquelle;
– L’incertitude associée à un système de choix est mesurée par le (plus petit) nombre de
questions à poser pour découvrir le choix réel. Ceci mène à poser log |S| comme mesure
de l’incertitude. Avec des questions binaires l’unité de mesure est appelée un bit;
– Le jeu des questions définit un arbre qui peut être utilisé pour définir des codes pour les
possibilités du système de choix S. La longueur de ces codes est approximativement égale
à la mesure de l’incertitude log |S|. Si des questions binaires sont utilisées, nous obtenons
des codes binaires;
– Nous avons découvert que les incertitudes de systèmes de choix indépendants s’addi-
tionnent.
Évaluation 1
Pour x ≥ 0, le logarithme log2 (x) est

1. toujours positif;
2. une fonction croissante;
3. maximal pour x = 10;
4. égal à 0 pour x = 0;
5. égal à 0 pour x = 1;
6. égal à 1 pour x = 2.
Évaluation 2
Si nous avons deux systèmes de choix S1 = {e1,1 , e1,2 , . . . , e1,n } et S2 = {e2,1 , e2,2 , . . . , e2,m },
alors le système de choix indépendants S1 × S2 a
1. n + m éléments;
2. n · m éléments.
Évaluation 3
Etant donné deux systèmes de choix S1 et S2 avec |S2 | = 2 · |S1 |, alors h(|S1 × S2 |) est égal à
1. h(|S1 |) + h(|S2 |);
2. 1 + 2 · h(|S1 |);
3. log(|S1 | · |S2 |);
4. h(|S1 |) · h(|S2 |);
1
5. 1 + 2 · h(|S2 |).
Évaluation 4
Retournons à la dernière control question. Laquelle des assertions correctes restera vraie, arbi-
trairement, pour S1 et S2 sans la propriété |S2 | = 2 · |S1 |.
1.1. ENTROPIE 9
1.1.2 Choix avec probabilité connue

Après avoir étudié cette sous-section, vous devriez
– comprendre comment l’incertitude est affectée, si les probabilités des choix pos-
sibles sont connues;
– connaître la définition de l’entropie et certaines de ses propriétés élémentaires;
– avoir une première appréciation de l’entropie comme mesure de l’incertitude.
Dans certaines situations, les probabilités des différentes possibilités qui pourraient se produire
sont connues. Par exemple, si l’on sait qu’une personne tape un texte en anglais, alors nous
savons que certaines lettres se présentent plus fréquemment que d’autres, et qu’elles sont donc
plus susceptibles d’être tapées. Ou, au niveau des mots, si l’on sait que l’utilisateur fait de
la programmation, alors nous savons que certains mots-clés tels que “si”, “alors”, “sinon”,
etc. sont plus susceptibles d’être tapés que la plupart des autres combinaisons de lettres. Nous
verrons dans cette section comment cette connaissance supplémentaire des probabilités affecte
la quantité d’incertitude dans un système de choix.
Pour commencer, nous introduisons formellement des probabilités dans un système de choix
S = {e1 , e2 , . . . , em } en assignant des probabilités pi aux possibilités ei pour i = 1, 2, . . . , m.
Ces probabilités doivent remplir les conditions suivantes :
m
X
0 ≤ pi ≤ 1, pour i = 1, 2, . . . m, pi = 1. (1.2)
i=1
La seconde condition exprime le fait qu’exactement une des m possibilités doit être sélectio-
née. Le système de choix S forme avec l’ensemble de probabilités P = {p1 , p2 , . . . , pm } un
système de choix probabiliste. Voici la définition formelle :
Définition 1.2 Système de choix probabiliste. Si S est un système de choix, et P un

ensemble de probabilités sur S remplissant les conditions (1.2), alors la paire (S, P )
est appelée un système de choix probabiliste. ¨
Si E ⊆ S est un sous-ensemble de S, soit un événement dans le langage de la théorie de la

probabilité, alors sa probabilité est donnée par
X
p(E) = pi .
ei ∈E
Quelle est la quantité d’incertitude dans un système de choix probabiliste ? Nous pourrions es-
sayer d’employer le même jeu de questions-réponses que dans la question précédente. Cepen-
dant, il n’est plus ingénieux de diviser l’ensemble de possibilités en sous-ensembles de taille
égale, parce que cette méthode ne tient pas compte des probabilités. Supposons par exemple
qu’une possibilité, disons e1 , est bien plus vraisemblable que toutes les autres. Alors, nous
devrions d’abord bien entendu demander si ceci est la bonne possibilité. Il y a de grandes
chances que nous frappions juste et trouvions la bonne possibilité avec une seule question.
C’est seulement si la réponse est “non” que nous devrons continuer. Examinons un exemple.
Exemple 1.5 (Arbres liés à un système de choix probabiliste) Posons un sys-

tème de choix probabiliste (S, P ) par S = {e1 , e2 , . . . , e8 } et P =

{0.3, 0.2, 0.1, 0.05, 0.05, 0.1, 0.15, 0.05}. Un arbre binaire correspondant ainsi qu’une
alternative est représentée sur les figures 1.4 et 1.5. Un simple calcul montre que la longueur
moyenne des mots pour le premier arbre binaire est de 3, et de 2.75 pour le second.
F IG . 1.4 – L’arbre binaire de notre exemple avec la longueur moyenne de mot de 3.
F IG . 1.5 – Dans cette alternative la longueur moyenne des mots est réduite à 2.75.
Comme l’exemple le démontre, nous devrions tenter de sélectionner nos questions de façon
à minimiser le nombre moyen de questions nécessaires. Ceci n’est pas une tâche banale. Ce-
pendant, la solution à ce problème est connue et fréquemment utilisée en théorie du codage
comme exposé dans le chapitre 5. L’idée-clé est de diviser l’ensemble des possibilités, non pas
en sous-ensembles de cardinalité égale, mais en sous-ensembles de probabilité égale. On sait
en particulier, d’après la théorie du codage, que le nombre moyen de questions est approxima-
tivement
m
X
− pi log pi .
i=1
1.1. ENTROPIE 11
Cette grandeur est appelée entropie, et nous proposons de l’utiliser comme mesure de la quan-
tité d’incertitude dans un système de choix probabiliste. Nous n’excluons pas que certaines
des probabilités pi tendent vers zéro, pi = 0. Dans ce cas nous adoptons la convention selon
laquelle 0 log 0 = 0, ce qui est raisonnable étant donné que limx→0 x log x = 0.
Définition 1.3 La quantité d’incertitude dans un système de choix probabiliste. Ad-

mettons que (S, P ) soit un système de choix probabiliste. Alors nous définissons la
quantité d’incertitude dans (S, P ) comme l’entropie
m
X
H(P ) = − pi log pi . (1.3)
i=1
Une fois de plus, cette définition comporte un certain degré d’arbitraire. La base k du loga-
rithme dans l’entropie correspond, comme dans la section précédente, au nombre k de réponses
possibles à chaque question dans le jeu des questions-réponses. Nous laissons ceci ouvert, étant
donné qu’un changement de la base correspond seulement à un changement d’unité. Comme
précédemment, le logarithme en base 2 est le plus populaire; l’unité correspondante est le bit;
nous allons généralement l’employer dans les exemples.
Exemple 1.6 (Arbres liés à un système de choix probabiliste - Suite) Nous complétons
l’exemple 1.5 en calculant la quantité d’incertitude dans le système de choix probabiliste; ce
qui revient à calculer l’entropie.
8
X
H(P ) = − pi log pi
i=1
= −0.3 · log 0.3 − 0.2 · log 0.2 − 0.2 · log 0.1
−0.15 · log 0.05 − 0.15 · log 0.15
≈ 2.7087 bit
Donc H(P ) est inférieur à la longueur moyenne des mots dans le meilleur arbre.
L’entropie est réellement une notion fondamentale dans la théorie de l’information et de la

communication, comme le démontrera la suite de ce cours. Il est donc utile d’étudier ses pro-
priétés. Notez que nous écrivons parfois
H(P ) = H(p1 , p2 , . . . , pm ),
si P = {p1 , p2 , . . . , pm }.
Nous établissons d’abord le lien entre la notion générale d’entropie telle qu’elle est introduite
ici, et la mesure de l’incertitude pour des systèmes de choix sans probabilités comme nous
l’avons défini dans la sous-section précédente. Nous voyons que si P est la distribution uni-
forme sur m choix, alors
µ ¶ Xm
1 1 1 1 1
H ,..., =− log = − log = log m = h(m).
m m m m m
i=1
Propriété 1.1 L’entropie de la distribution de probabilité uniforme sur m possibili-

tés égale la mesure de l’incertitude du système correspondant de choix sans probabi-
lité.
Ceci est une expression du principe de raison insuffisante de Laplace qui dit que si vous n’avez
pas d’autre information, posez des probabilités égales. Dans ce contexte ceci fonctionne bien.
En ce sens, l’entropie couvre aussi le cas particulier des systèmes de choix sans probabilités.
Pour un système de choix S avec |S| = m, intuitivement, nous avons une incertitude maxi-
male si nous ne connaissons pas les probabilités, ou si nous posons des probabilités uniformes
(égales) sur toutes les possibilités.
H(P ) ≤ h(|S|) = log m.
Ceci est vrai et peut être démontré.

Afin de démontrer ce résultat, nous avons besoin du lemme suivant.
Lemme 1.1 Soient p1 , p2 , . . . , pm et q1 , q2 , . . . , qm deux distributions de probabilité

sur le même nombre de m possibilités. Alors
m
X m
X
pi log qi ≤ pi log pi (1.4)
i=1 i=1
avec égalité si, et seulement si, pi = qi .
D ÉMONSTRATION Nous avons log x = log e·ln x, où ln représente le logarithme naturel (en
base e). ln x est une fonction concave, ce qui signifie que tous les points de son diagramme
sont sous sa tangente (see Figure 1.6). Si nous prenons la dérivée de ln x dans le point x = 1,
alors nous obtenons ln x ≤ x − 1 avec égalité si, et seulement si, x = 1. Par conséquent,
nous avons
qi qi
ln ≤ − 1,
pi pi
d’où
m
X X m
X m
qi
pi ln ≤ qi − pi = 1 − 1 = 0.
pi
i=1 i=1 i=1
Nous en concluons que

m
X m
X m
X qi
pi log qi − pi log pi = log e pi ln ≤ 0.
pi
i=1 i=1 i=1
Ceci montre que (1.4) est vérifié avec l’égalité si, et seulement si, qi /pi = 1 pour tous i,
c’est-à-dire pi = qi . ¥
En appliquant ce lemme, on a
m
X m
X 1
H(P ) − log m = − pi log pi + pi log ≤ 0,
m
i=1 i=1
avec égalité si, et seulement si, pi = 1/m. Nous avons démontré le théorème suivant :
1.1. ENTROPIE 13
F IG . 1.6 – Convexité de la fonction y = ln x et la tangente au point x = 1.
Théorème 1.2
max H(P ) = log m, (1.5)
où le maximum est pris sur toutes les distributions de probabilité P pour m possibi-
lités. Ce maximum est atteint pour la distribution équiprobable uniquement.
Citons ci-dessous d’autres propriétés élémentaires de l’entropie :
1. Si (S1 , P1 ) et (S2 , P2 ) sont deux systèmes de choix probabilistes avec |S1 | = |S2 | et
P1 = P2 , alors H(P1 ) = H(P2 ). Ceci signifie que l’entropie dépend uniquement de
la distribution de probabilités, et non pas de la nature des possibilités ei dans le sys-
tème de choix. Ceci découle directement de la définition de l’entropie (1.3) qui dépend
uniquement des probabilités pi .
2. Nous avons
H(p1 , p2 , . . . , pn ) = H(p1 , p2 , . . . , pn , 0).
qui résulte de la convention 0 · log 0 = 0. Elle signifie que les possibilités à probabilité
tendant vers zéro importent peu pour la quantité d’incertitude. Ceci est raisonnable, étant
donné que nous pouvons être sûrs que de telles possibilités ne sont jamais sélectionnées.
3. Considérons un schéma à deux niveaux comme illustré sur la figure 1.7. Au premier
niveau, une des deux possibilités est sélectionnée, avec les probabilités p et q = 1 − p.
Si au premier niveau, la première possibilité est sélectionnée, alors au second, une des
n possibilités est sélectionnée avec les probabilités pi /p. Si la seconde possibilité est
sélectionnée au premier niveau, alors une des m possibilités est sélectionnée au second
niveau avec les probabilités qi /q. Ici il est admis que
n
X m
X
pi = p, qi = q.
i=1 i=1
Notez que cela implique
p1 + p2 + · · · pn + q1 + q2 + · · · qm = 1,
c’est-à-dire {p1 , . . . , pn , q1 , . . . , qm } est une distribution de probabilité sur n + m élé-

ments. Ensuite nous avons l’égalité suivante entre les entropies des deux niveaux :
H(p1 , p2 , . . . , pn , q1 , q2 , . . . , qm )
p1 p2 pn q1 q2 qm
= H(p, q) + pH( , , . . . , ) + qH( , , . . . , ).
p p p q q q
Ceci peut être vérifié d’après la définition de l’entropie.
F IG . 1.7 – Un système de choix probabiliste à deux niveaux dans lequel une des deux possibi-
lités est sélectionnée avec les probabilités p et q = 1 − p et, au second niveau, soit une des n
possibilités avec la probabilité pi /p soit une des m possibilités avec la probabilité qi /q.
Quelques propriétés plus techniques de l’entropie :
Proposition 1.1 1. H(p1 , p2 , . . . , pn ) = H(pπ(1) , pπ(2) , . . . , pπ(n) ) pour chaque

permutation π.
2. H(p1 , p2 , . . . , pn ) est continue dans toutes ses variables.
3. Nous avons l’équation
H(p1 , . . . , pn ) = H(p1 + p2 , p3 , . . . , pn )
p1 p2
+(p1 + p2 )H( , ),
p1 + p2 p1 + p2
pour chaque distribution de probabilité p1 , . . . , pn avec n ≥ 2.
4. H( n1 , . . . , n1 ) est croissant avec n.
Ces propositions sont très faciles à démontrer. Leur importance réside dans le fait qu’elles
sont des propriétés caractérisantes pour l’entropie. Cela signifie que lorsque nous imposons
ces quatre conditions raisonnables sur une mesure d’incertitude, nous obtenons nécessairement
l’entropie pour cette mesure.
1.1. ENTROPIE 15
D ÉMONSTRATION (1) Résulte directement de la définition de l’entropie et de la commutati-

vité de l’addition.
(2) Résulte du fait que le logarithme est une fonction continue.
(3) Résulte de quelques calculs simples :
H(p1 , p2 , . . . , pn )
n
X
= −p1 log p1 − p2 log p2 − pi log pi
i=3
n
X
= −(p1 + p2 ) log(p1 + p2 ) − pi log pi
i=3
+p1 log(p1 + p2 ) − p1 log p1 + p2 log(p1 + p2 ) − p2 log p2
µ ¶
p1 p1 p2 p2
= H(p1 + p2 , p3 , . . . , pn ) − (p1 + p2 ) log + log
p1 + p2 p1 + p2 p1 + p2 p1 + p2
p1 p2
= H(p1 + p2 , p3 , . . . , pn ) + (p1 + p2 )H( , ).
p1 + p2 p1 + p2
(4) Résulte du fait que H( n1 , . . . , n1 ) = log n et que le logarithme est une fonction croissante.
¥
1.1.3 Variables aléatoires
À titre de référence supplémentaire, introduisons une notion alternative. Un schéma de choix

probabiliste peut aussi être représenté par une variable aléatoire finie X, qui prend des valeurs
ei de S = {e1 , e2 , . . . , em }. La probabilité que X = ei est alors pX (ei ) et P est appelé
la densité de probabilité de X. Inversement, chaque variable aléatoire à nombre fini d’états
donne lieu à un système de choix probabiliste. Formellement, une variable aléatoire à valeurs
dans S est une application d’un échantillon d’espace Ω dans S. Une distribution de probabilité
dans S est alors induite par
X
pX (x) = p(ω),
ω∈Ω:X(ω)=x
si {p(ω) : ω ∈ Ω} sont les probabilités définies sur l’échantillon d’espace fini Ω. L’ensemble
{pX (x) : x ∈ S} définit alors les probabilités sur l’espace de choix S. Nous pouvons donc
aussi bien parler de variables aléatoires au lieu de systèmes de choix probabilistes, et définir,
en conséquence :
Définition 1.4 (Entropie d’une v.a.) L’entropie de la variable X avec des valeurs
dans S est définie par :
X
H(X) = − pX (x) log pX (x).
x∈S
Ceci mesure donc l’incertitude associée à la variable aléatoire X. Dans ce qui suit, ce sera
souvent une façon plus commode de voir les choses.
Exemple 1.7 (Bernoulli) Admettons que X soit une variable aléatoire binomiale représen-
tant n épreuves de Bernoulli, soit avec
µ ¶
n x
pX (x) = p (1 − p)n−x .
x
L’entropie de X est donnée par

n µ ¶
X µµ ¶ ¶
n i n−i n i n−i
H(X) = − p (1 − p) · log p (1 − p) .
i i
i=0
Prenons n = 4 et p = q = 0.5. D’où

4 µ ¶
X µµ ¶ ¶
4 i 4−i 4 i 4−i
H(X) = − (0.5) · (0.5) · log (0.5) · (0.5)
i i
i=0
= −0.1250 log 0.0625 − 0.5 log 0.25 − 0.375 log 0.375
≈ 2.0306 bit.
Théorème 1.3 L’entropie d’une variable aléatoire X à valeurs dans S est bornée
par :
0 ≤ H(X) ≤ log |S|
Les bornes peuvent être atteintes :
– H(X) = 0 dans le cas d’un système déterministe (une seule valeur de S a un
probabilité de 1, toutes les autres ont une probabilité nulle).
– H(X) = log |S| dans le cas d’un système équiréparti (voir théorème 1.2).
R ÉSUMÉ DE LA SOUS - SECTION 1.1.3
– Nous avons vu que pour un choix probabiliste, représenté par un système de choix proba-
biliste, on doit employer une stratégie différente dans le jeu des questions-réponses : au
lieu de diviser l’ensemble de possibilités en sous-ensembles de cardinalité égale, nous le
divisons en sous-ensembles de probabilité presque égale. Ceci mène, approximativement,
à l’entropie en tant que logarithme du nombre moyen de questions et, ainsi, comme mesure
appropriée de l’incertitude;
– Nous avons vu que l’incertitude d’un système de choix égale l’entropie d’un choix proba-
biliste à probabilités égales, soit une distribution de probabilité uniforme. Ceci correspond
au principe de raison insuffisante de Laplace. Donc le concept d’entropie couvre aussi le
cas de systèmes de choix non probabilistes;
– En fait, des probabilités égales, ou des systèmes de choix sans probabilités connues repré-
sentent, pour un ensemble S d’une cardinalité donnée, la plus grande incertitude;
– L’entropie dépend uniquement de la distribution de probabilité d’un système de choix, et
non pas de la nature des possibilités;
– Nous avons vu quelques propriétés simples de l’entropie qui caractérisent ce concept.
Évaluation 5
1.1. ENTROPIE 17
Soit un système de choix probabiliste (S, P ) par S = {e1 , e2 , . . . , en } et P = {p1 , p2 , . . . , pn }.

Alors, H(P )
P
1. = − ni=1 pi log pi
2. = h(n)
3. ≤ log n
4. ≤ h(|S|)
5. > 0
Évaluation 6
Etant donné l’arbre binaire représenté en figure 1.8, calculez

1. la longueur moyenne des mots;
2. l’entropie.
0.21 0.79
0.11 0.10 0.10 0.69
0.10 0.01 0.03 0.07

0.05 0.05 0.40 0.29
F IG . 1.8 – Calculez la longueur moyenne des mots et l’entropie dans cet arbre binaire.
Évaluation 7
Etant donné un système de choix probabiliste (S, P ) par S = {e1 , e2 , . . . , en } et P = {p1 , p2 ,

. . . , pn }. Alors, H(p1 , p2 , . . . , pn )
1. = H(0, p1 , . . . , pn );
2. = H(p1 + p2 , p3 , . . . , pn ) + (p1 + p2 )H( p1p+p
1
, p2 );
2 p1 +p2
3. = H(p1 + pn , p2 , . . . , pn−1 ) + (p1 + pn )H( p1p+p

1
, pn );
n p1 +pn
P
4. = ni=1 pi log p1i .
1.1.4 Entropie conditionnelle

– savoir comment l’entropie de systèmes de choix composés ou comment des va-
riables multidimensionnelles sont liées à l’entropie des composantes ou des va-
riables uniques;
– comprendre comment la connaissance du choix dans une composante ou de la
valeur d’une variable affecte l’incertitude des composantes ou variables restantes.
Commençons par considérer deux systèmes de choix S1 et S2 et le système de choix indépen-

dants S1 × S2 = {(e1,1 , e2,1 ), (e1,1 , e2,2 ), . . . , (e1,n , e2,m )} qui lui est associé. En affectant les
probabilités pi,j au choix composé (e1,i , e2,j ), nous étendons le système de choix indépendants
à un système de choix probabiliste composé (S1 × S2 , P ), où P = {pi,j ; i = 1, 2, . . . , n; j =
1, 2, . . . , m}. Nous devons avoir
n X
X m
0 ≤ pi,j , pi,j = 1.
i=1 j=1
Ceci est une distribution de probabilité bi-dimensionnelle. Nous pouvons calculer les deux
(1) (1) (1) (2) (2) (2)
distributions marginales P1 = {p1 , p2 , . . . , pn }, et P2 = {p1 , p2 , . . . , pm }, définies
par
m
X n
X
(1) (2)
pi = pi,j , pj = pi,j . (1.6)
j=1 i=1
Ceci nous donne donc deux systèmes de choix probabilistes associés (S1 , P1 ) et (S2 , P2 ).
Nous allons introduire une variable aléatoire pour chaque système de choix probabiliste comme
expliqué à la fin de la sous-section précédente. Donc, admettons que X soit associé au système
(S1 , P1 ) et Y au système (S2 , P2 ). La paire de variables (X, Y ) est alors associée au système
probabiliste composé (S1 ×S2 , P ). Nous avons la distribution de probabilité bi-dimensionnelle
p(X,Y ) (e1,i , e2,j ) = pi,j pour la paire de variables aléatoires (X, Y ). La variable X possède
(1) (2)
la distribution marginale pX (e1,i ) = pi et Y la distribution marginale pY (e2,j ) = pj .
Rappelons que deux systèmes de choix probabilistes, ou deux variables aléatoires X et Y sont
appelés indépendants, si, et seulement si,
pX,Y (x, y) = pX (x) · pY (y), pour toutes les paires (x, y) ∈ S1 × S2 .
Nous avons trois entropies différentes associées aux trois systèmes de choix probabilistes : les
deux variables uniques X et Y et la variable bi-dimensionnelle (X, Y ),
X X
H(X, Y ) = − pX,Y (x, y) log pX,Y (x, y),
x∈S1 y∈S2
X
H(X) = − pX (x) log pX (x),
x∈S1
X
H(Y ) = − pY (y) log pY (y).
y∈S2
1.1. ENTROPIE 19
Exemple 1.8 (Système de choix probabiliste composé) Etant donné un système de choix
indépendants composés
S1 × S2 = {(e1,1 , e2,1 ), (e1,1 , e2,2 ), (e1,2 , e2,1 ), (e1,2 , e2,2 )},

P = {0.5, 0.1, 0.3, 0.1},
et deux variables aléatoires (X, Y ) associées à (S1 × S2 , P ), il est aisé d’identifier les sys-
tèmes de choix ’simples’
S1 = {e1,1 , e1,2 }, S2 = {e2,1 , e2,2 }.
En appliquant (1.6) nous obtenons les deux distributions marginales P1 = {0.6, 0.4} et P2 =
{0.8, 0.2}. Nous sommes maintenant en mesure de calculer les entropies
X X
H(X, Y ) = − pX,Y (x, y) log pX,Y (x, y)
x∈S1 y∈S2
= −0.5 · log 0.5 − 0.1 · log 0.1 − 0.3 · log 0.3 − 0.1 · log 0.1
≈ 1.6855 bit,
X
H(X) = − pX (x) log pX (x) = −0.6 log 0.6 − 0.4 log 0.4
x∈S1
≈ 0.9710 bit,
X
H(Y ) = − pY (y) log pY (y) = −0.8 log 0.8 − 0.2 log 0.2
y∈S2
≈ 0.7219 bit.
La question qui se pose est la suivante : « comment les trois entropies ci-dessus sont-elles
liées ? » La réponse se trouve dans le théorème suivant
Théorème 1.4 Pour toute paire de variables aléatoires X et Y , nous avons
H(X, Y ) ≤ H(X) + H(Y ). (1.7)
Il y a égalité si, et seulement si, X et Y sont des variables aléatoires indépendantes.
D ÉMONSTRATION Ce théorème est démontré par un simple calcul et en employant le lemme

1.1 :
H(X) + H(Y )
Ã !
X X
= − pX (x) log pX (x) + pY (y) log pY (y)
x y
Ã !
XX XX
= − pX,Y (x, y) log pX (x) + pX,Y (x, y) log pY (y)
x y x y
Ã !
XX
= − pX,Y (x, y) log pX (x) · pY (y) .
x y
A présent, le lemme 1.1 nous donne l’inégalité suivante,

Ã !
XX
− pX,Y (x, y) log pX (x) · pY (y)
x y
Ã !
XX
≥− pX,Y (x, y) log pX,Y (x, y)
x y
= H(X, Y ).
ce qui démontre l’inégalité (1.7). D’après le lemme 1.1 nous avons l’égalité dans la dernière
inégalité si, et seulement si, pX,Y (x, y) = pX (x) · pY (y), ce qui signifie que X et Y sont
indépendants. ¥
Ce théorème nous apprend que les entropies de deux variables ne s’ajoutent à l’entropie des
variables bi-dimensionnelles composées que si les variables sont indépendantes. Si ce n’est
pas le cas, il y a moins d’incertitude dans la situation composée que dans les deux systèmes
de choix simples. La raison en est que l’inter-dépendance des variables, (leur corrélation) crée
certaines parties d’incertitude “communes” aux deux variables.
Exemple 1.9 (Système de choix probabiliste composé - Suite) Dans l’exemple 1.8 nous
avons les variables aléatoires X et Y . Vérifiez vous-même que H(X, Y ) < H(X) + H(Y ).
Le théorème 1.4 peut aisément être étendu à plus de deux variables. Notons X le vecteur
(X1 , X2 , . . . , Xm ) de m variables aléatoires Xi . Cette variable aléatoire vectorielle possède
la distribution de probabilité pX (x), où x = (x1 , x2 , . . . , xm ) et chaque variable Xi a la
distribution marginale
X
pXi (xi ) = pX (x1 , x2 , . . . , xi−1 , xi , xi+1 , . . . , xm ).
x1 ,...,xi−1 ,xi+1 ,...,xm
Les variables aléatoires X1 , X2 , . . . , Xm sont appelées (mutuellement) indépendantes, si, et

seulement si,
pX (x) = pX1 (x1 ) · pX2 (x2 ) · · · pXm (xm )
L’entropie commune de la variable multidimensionnelle X est définie par

X
H(X) = − pX (x) log pX (x).
x
Ensuite le théorème 1.4 est généralisé, comme l’indique le corollaire suivant.
Corollaire 1.2 Pour toute variable aléatoire multidimensionnelle X =

(X1 , X2 , . . . , Xm ) nous avons
m
X
H(X) ≤ H(Xi ).
i=1
Il y a égalité si, et seulement si, les variables X1 , X2 , . . . , Xm sont mutuellement

indépendantes.
1.1. ENTROPIE 21
D ÉMONSTRATION (Par récurrence sur m) Le corollaire est valable pour m = 2 d’après le

théorème 1.4. Supposons qu’il soit valable pour m. Considérons ensuite la paire de variables
aléatoires Xm = (X1 , X2 , . . . , Xm ) et Xm+1 , telle que Xm+1 = (Xm , Xm+1 ). Ici encore,
d’après le théorème 1.4 et par l’hypothèse d’induction, nous avons
m
X m+1
X
H(Xm+1 ) ≤ H(X ) + H(Xm+1 ) ≤ H(Xi ) + H(Xm+1 ) = H(Xi ).
i=1 i=1
Exemple 1.10 (Indépendance) Supposons que X1 , . . . , Xn soient des variables aléatoires

indépendantes fournissant le résultat 0 avec la probabilité 0.5 et 1 avec la probabilité 0.5, ce
qui signifie que
pXi (0) = 0.5, pXi (1) = 0.5, pour i = 1, . . . , n.
D’où H(X1 , . . . , Xn ) = n · H(X1 ) = n.
Revenons au cas de deux entités et considérons une variable aléatoire X liée à une situation
de choix probabiliste (S, P ), et supposons qu’un événement E ⊆ S est observé. En quoi cela
affecte-t-il l’incertide ?
L’observation de l’événement E change la variable aléatoire X en variable conditionnelle XE
liée à la nouvelle situation de choix probabiliste (E, PXE ).
Définition 1.5 Soit X une variable aléatoire liée à une situation de choix probabiliste
(S, P ). On note XE la variable aléatoire conditionnelle X étant donné un événement
E ⊆ S ; i.e. XE est liée à la nouvelle situation de choix probabiliste (E, PXE ).
Sa distribution de probabilité est donnée par :
pX (x)
pXE (x) = , pour x ∈ E.
pX (E)
Cette nouvelle situation engendrée par l’observation de l’événement E, a l’incertitude qui

correspond à l’entropie conditionnelle H(XE ) :
X
H(XE ) = − pXE (x) log pXE (x).
x∈E
L’observation de E change donc l’incertitude de H(X) à H(XE ), qui est appelée entropie
conditionnelle.
Exemple 1.11 (Entropie conditionnelle) Soit X une variable aléatoire liée à la situation de
choix probabiliste (S, P ) donnée par S = {1, 2, 3, 4}, P = {0.5, 0.25, 0.125, 0.125}, et
E = {1, 3} un événement. Ainsi
H(X) = −0.5 log 0.5 − 0.25 log 0.25 − 0.125 log 0.125 − 0.125 log 0.125
= 1.75bit.
Avec pX (E) = 0.625, pXE (1) = pX (1)/pX (E) = 0.8 et pXE (3) = pX (3)/pX (E) = 0.2
( )
( )
( )= ( ) log ( )
( )
0 ( ) 0 = ( )
2
60 CHAPITRE 3. PROCESSUS STATIONNAIRES & CHAÎNES DE MARKOV
F IG . 3.1 – Le théorème AEP : pour 0 < h∞ < log m et n grand, presque toutes les séquences
de Ωn sont non-typiques (grains de sable) et leur contribution au volume total est négligeable.
Par contraste, le nombre relatif de séquences typiques (galets) est négligeable, mais leur vo-
lume représente la quasi-totalité du volume total.
d’information n h∞ portée par une séquence de longueur n avec un taux d’entropie h∞ sur un
alphabet m peut, de façon équivalente, être obtenue
A) par l’ensemble de séquences de longueur effective neff = (1−R)n distribuée équiproba-
blement sur m catégories; le taux d’entropie de ce nouveau processus atteint maintenant
son maximum log m.
B) par l’ensemble de séquences de longueur n distribuées équiprobablement sur m(1−R)
catégories, avec un taux d’entropie correspondant de log m(1−R) = (1 − R) log m.
Modifier le processus original ne modifie pas l’information totale, qui reste égale à nh∞ :
neff log m = n (1 − R) log m = n h∞ (A)

n log m(1−R) = n (1 − R) log m = n h∞ (B)
Cependant, la redondance du processus modifié est à présent de zéro dans les deux cas: l’ap-
plication de 3.11 produit
log m (1 − R) log m
RA = 1 − = 0 (A) RB = 1 − = 0 (B)
log m (1 − R) log m
Les façons précises et détaillées dont les séquences initiales peuvent être compressées (du point
de vue de leurs longueurs (A) ou de la taille de leur alphabet (B)) constitue une partie de la
théorie du codage (voir module C2).
Exemple 3.5 L’entropie d’un texte « représentatif » en anglais simplifié avec m = 27 caté-
gories (pas de ponctuation ni de distinction minuscule/majuscule, soit 26 lettres un caractère
« espace ») a été estimée à environ h∞ = 1.3 bits par lettre, correspondant à une redon-
dance d’environ R = 1 − 1.3/ log2 27 = 0.73 (Shannon 1950, cité dans Cover and Thomas
1991). Ce qui signifie qu’un roman de 300 pages pourrait tout à fait être réduit à un roman
de 300(1 − 0.73) = 81 pages avec le même alphabet, ou à un roman de même longueur avec
seulement 27(1−0.73) = 2.43 (c’est-à-dire au moins 3) symboles. L’aspect d’un échantillon
de ce texte pourrait ressembler à ceci
MUUMMXUUMMMMUMXXUMXMMXMMUXMUMXMMMMXXXUUXMXMUUXMUXMUXMU
UMUXUMUUUXMMUUUMXMMMXXXXMUMXXMMXXMUMXUMUUXMUUXMMMXMUXX
3.2. LE THÉORÈME AEP 61
UXXXUXXUUMMUXUXMUUMXUUXMUXXUXUMUUUXXXMMXXUMXUUUMMUXMXM
La redondance de ce nouveau texte est maintenant de zéro, ce qui signifie que la plus petite
modification modifierait le contenu de l’ouvrage. Par contraste, la redondance élevée (R =
0.73) de l’anglais standard permet de corriger et de récupérer un texte altéré, qui contiendrait
par exemple des fautes d’orthographe.
Note : l’exemple ci-dessus présuppose que l’anglais écrit est produit par un processus sto-
chastique stationnaire, ce qui est bien entendu discutable.
Évaluation 19
Un processus stochastique stationnaire produit une séquence de n symboles consécutifs (n

grand) ou un alphabet avec m signes. Supposons que la redondance du processus soit R =
0.25. Alors
1. il est possible de compresser (sans diminuer l’information totale) la longueur de la sé-

quence de n à 0.75 × n? Réponses possibles : oui - non - cela dépend de n.
2. il est possible de compresser (sans diminuer l’information totale) la longueur de l’alpha-

bet de m à 0.75 × m? Réponses possibles : oui - non - cela dépend de m.
Exemple 3.6 Des prévisions météorologiques largement simplifiées placent chaque journée
dans l’une de ces trois catégories: « belle » (N), « pluvieuse » (R) ou « neigeuse » (S). Par
exemple, « NNRNSRN » constitue une semaine météorologique possible. Il y a un maximum
de 3n séquences différentes de n jours; chacune de ces séquences serait équiprobable (avec la
probabilité 3−n ) si le temps suivait effectivement un processus parfaitement aléatoire (avec
un taux d’entropie maximum de h∞ = log 3, comme l’indique le théorème 3.2). Cependant,
le temps réel n’est certainement pas un processus totalement aléatoire, c’est-à-dire que sa
redondance R est strictement positive:
– si R = 0.5 par exemple, alors, parmi toutes les 3n différentes séquences posssibles de n
jours, 3(1−0.5) n = 1.73n sont typiques.
– si R = 0.75, seules 3(1−0.75) n = 1.32n séquences de n jours sont typiques.
– si R = 1, seule 3(1−1) n = 30 = 1 séquence est typique, soit la seule séquence générée par
le processus en l’occurrence déterministe.
Dans cet exemple, le nombre effectif de types de temps possibles pour le jour suivant (tel
qu’il est mesuré par l’incertitude conditionnelle du jour précédent) passe de 3 à 1.73, 1.32 et
même à 1 puisque R augmente de 0 à 1.
3.3 Chaînes de Markov de premier ordre

– connaître le concept de chaîne de Markov (de premier ordre), sa matrice de transi-
tion et leurs itérations, ainsi que le concept de distribution stationnaire.
– être capable de classer les états comme récurrents, transients, absorbants et pério-
diques.
– comprendre la signification théorique de l’entropie associée ainsi que son calcul.
– comprendre la nature de l’irréversibilité produite par l’évolution temporelle.
Définition 3.6 Une chaîne de Markov de premier ordre, ou, plus simplement, une
chaîne de Markov, est un processus stochastique discret dont la mémoire est limitée
au dernier état, c’est-à-dire:
p(xt+1 |xt−∞ ) = p(xt+1 |xt ) ∀t ∈ Z
Admettons que Ω := {ω1 , . . . , ωm } représente les m états du système. La chaîne de

Markov est entièrement déterminée par la matrice de transition m × m
pjk := P (Xt+1 = ωk |Xt = ωj ) = p(ωk |ωj )
obéissant aux conditions de consistance

m
X
pjk ≥ 0 pjk = 1
k=1
Exemple 3.7 Considérons un processus à deux étapes avec un espace des états Ω = {a, b}.
Lorsque le système est dans l’état a, il reste dans le même état avec la probabilité 0.7 (et se
déplace vers l’état b avec la probabilité 0.3). Lorsque le système est dans l’état b, il reste dans
le même état avec la probabilité 0.6 (et se déplace vers l’état a avec la probabilité 0.4). Les
probabilités conditionnelles sont p(a|a) = 0.7, p(b|a) = 0.3, p(b|b) = 0.6 et p(a|b) = 0.4.
En numérotant a en 1 et b en 2, les probabilités s’expriment de façon équivalente comme
p11 = 0.7, p12 = 0.3, p21 = 0.4 et p22 = 0.6, ou, sous forme matricielle,
µ ¶
0.7 0.3
P = (3.12)
0.4 0.6
On observe que la somme de chaque ligne vaut 1.
3.3.1 Matrice de transition en n étapes
Considérons un processus gouverné par une chaîne de Markov qui est dans un état ωj au temps
t. Par définition, sa probabilité d’être dans l’état k au temps t + 1 est pjk . Mais qu’en est-il de
sa probabilité d’être dans l’état k au temps t + 2 ?
F IG . 3.3 – L’état a s’atteint lui-même et atteint les états b, c, d et e. L’état b s’atteint lui-même
et atteint les états c, d et e. L’état c s’atteint lui-même et atteint les états d et e. L’état d s’atteint
lui-même et atteint les états c et e, etc. Les classes d’équivalence de communication sont {a},
{b}, {c, d, e}, {f }, {g} et {h}.
Définition 3.7
– l’état j atteint l’état k, ce que l’on note j → k, s’il y a un chemin jl1 l2 · · · ln−1 k de
longueur n ≥ 0 tel que pjl1 pl1 l2 · · · pln−1 k > 0, c’est-à-dire s’il y a un n ≥ 0 tel que
(n) (0)
pjk > 0. Comme pjj = 1 > 0, chaque état s’atteint lui-même par construction:
j → j pour tout j.
– les états j et k commmuniquent, ce que l’on note j ↔ k, si et seulement si j → k
et k → j.
La relation « → » est donc réflexive (j → j) et transitive (j → l et l → k impliquent j → k).

En outre, la relation de communicabilité « ↔ » est symétrique (j ↔ k implique k ↔ j). Ce
qui signifie que la relation « communique avec » est une relation d’équivalence qui sépare les
états en groupes d’états, chaque état à l’intérieur d’un groupe communicant avec tous les autres
états à l’intérieur du même groupe.
Notez que les aspects « squelette » (c’est-à-dire la possibilité ou l’impossibilité d’une tran-
sition) dominent les aspects « chair » (c’est-à-dire la question de la probabilité exacte d’une
transition possible) dans la classification ci-dessus. Cela signifie que j et k communiquent si
(n) (n′ )
et seulement si il y a des entiers n et n′ avec pjk > 0 et pkj > 0; la question des valeurs
(n) (n′ )
exactes de pjk > 0 et pkj > 0 est secondaire relativement au fait que ces deux grandeurs
sont strictement positives.
Exemple 3.9 Considérons une chaîne de Markov avec un squelette donné en figure 3.3. Les
flèches dénotent l’atteignabilité dans une étape. L’état a s’atteint lui-même et atteint les états
b, c, d et e. Cependant, a ne peut être atteint qu’à partir de lui-même. Ainsi, la classe d’équi-
valence de a (relativement à la relation « ↔ ») contient a lui-même. Si l’on pousse le rai-
sonnement plus loin, on découvre que les classes d’équivalence sont {a}, {b}, {c, d, e}, {f },
{g} et {h}.
Définition 3.8 L’état j est récurrent (ou persistant, ou ergodique) si la probabilité

que le processus commençant en j finisse aussi en j vaut 1. L’état j est transient s’il
n’est pas récurrent, c’est-à-dire si la probabilité de non-retour à j à partir de j est non
nulle. ¨
On peut montrer que les états appartenant à la même classe d’équivalence sont soit tous récur-
rents, soit tous transients, ce qui justifie la définition suivante :
3.3. CHAÎNES DE MARKOV DE PREMIER ORDRE 65
F IG . 3.4 – Exemple 3.10 : Les classes d’équivalence de communication sont {a}, {e} (classes
récurrentes) et {b, c, d} (classe transiente). Les états a et e sont absorbants.
Définition 3.9 Les classes récurrentes sont des classes d’équivalence dont tous les
éléments sont récurrents. Les classes transientes sont des classes d’équivalence dont
tous les éléments sont transients. ¨
Dans l’exemple 3.9, les classes récurrentes sont {c, d, e} et {h}. Toutes les autres classes sont
transientes.
Exemple 3.10 Considérons la matrice de transition de Markov ci-dessous
 
1 0 0 0 0
 0.5 0 0.5 0 0 
 
P =  0 0.5 0 0.5 0 

 (3.14)
 0 0 0.5 0 0.5 
0 0 0 0 1
dont le squelette est représenté en figure 3.4. Il y a deux classes récurrentes, à savoir {a} et
{e}, et une classe transiente, à savoir {b, c, d}. Les états récurrents qui sont les seuls de leur
classe, comme a et e, ne peuvent pas être quittés une fois atteints. On dit que de tels états
sont absorbants. Une condition nécessaire et suffisante pour qu’un état j soit absorbant est
pjj = 1, comme cela a été démontré dans les rangées 1 et 5 de 3.14.
(n)
Il peut arriver que pjj = 0 pour tout n ne soit pas divisible par d, et que d soit le plus grand
entier ayant cette propriété. Ceci signifie que si la chaîne est dans un état j à un temps t, elle
ne peut qu’y retourner aux temps de la forme t + md où m est un entier. On dit alors que l’état
(n)
j est de la période d. On dit qu’un état avec la période d = 1 est apériodique. Si pjj = 0 pour
tout n ≥ 0, l’état j a une période infinie d = ∞. On peut montrer que les états appartenant à
la même classe d’équivalence ont tous la même période: par exemple, en figure 3.4, les états a
et e sont apériodiques, tandis que b, c et d sont de la période d = 2.
Exemple 3.11 Un arbre est un graphe ne contenant pas de circuit. La figure 3.5 gauche
représente une chaîne de Markov sur un arbre symétrique: il y a une seule classe d’équi-
valence récurrente {a, b, c, d, e, f } dont tous les états ont la période d = 2. En ajoutant un
seul circuit tel qu’en figure 3.5 milieu ou droite, on conserve la classe d’équivalence unique
{a, b, c, d, e, f }, mais tous les états sont maintenant apériodiques (d = 1).
3.3.3 Distribution stationnaire
A partir de maintenant, on considère uniquement les chaînes de Markov régulières.

F IG . 3.5 – Example 3.11. Gauche : le squelette sous-jacent est un arbre symétrique, et tous les
états sont de la période d = 2. L’adjout d’un seul circuit (milieu ou droite) rend tous les états
apériodiques (d = 1).
Définition 3.10 (Chaîne de Markov régulière) Une chaîne de Markov régulière

consiste en une seule classe récurrente apériodique. De façon équivalente, chaque
état peut être atteint à partir de chaque autre après un laps de temps suffisant, c’est-à-
(n)
dire qu’il existe un entier N tel que pjk > 0 pour tous les états j, k et tous les temps
n ≥ N. ¨
Théorème 3.7 Soit P = (pjk ) la matrice de transition m × m d’une chaîne de

Markov régulière sur m états. Alors
– pour n → ∞, les puissances P n approchent une matrice de transition P ∞ de la
forme
 
π1 π2 · · · πm−1 πm
 π1 π2 · · · πm−1 πm  Xm
 
P =
∞
 · · · · · · · · · · · · · · · 
 avec π j > 0 et πj = 1 (3.15)
 π1 π2 · · · πm−1 πm  j=1
π1 π2 · · · πm−1 πm
– la distribution π = (π1 , π2 , . . . , πm )T est la seule solution de l’équation

m
X
πj pjk = πk ∀k i.e. PTπ = π (3.16)
j=1
Pm
obéissant à la condition de normalisation j=1 πj = 1.
La distribution π est qualifiée de distribution stationnaire ou d’équilibre associée à la chaîne P .
Exemple 3.12 Considérons la matrice de transition suivante

 
0.823 0.087 0.045 0.044
 0.058 0.908 0.032 0.001 
P =  0.030 0.032 0.937 0.001

 (3.17)
0.044 0.002 0.001 0.952
Certaines de ses puissances successives sont

 
0.431722 0.262400 0.159454 0.141811
 0.174831 0.661191 0.136434 0.022850 
P (5) = 
 0.106409 0.136458

0.741758 0.014806 
0.141905 0.036039 0.020341 0.796752
 
0.19967 0.30232 0.28125 0.19724
 0.20108 0.34353 0.30090 0.13496 
P (25) =
 0.18813

0.30168 0.38828 0.11189 
0.19752 0.20453 0.16520 0.40992
   
0.2 0.3 0.3 0.2 π1 π2 π3 π4
 0.2 0.3 0.3  
0.2   π1 π2 π3 π4 
P (∞) =
 0.2 = 
0.3 0.3 0.2   π1 π2 π3 π4 
0.2 0.3 0.3 0.2 π1 π2 π3 π4
et
Pla distribution d’équilibre correspondante est π = (0.2, 0.3, 0.3, 0.2). On peut vérifier que
m
j=1 πj pjk = πk est valable pour chaque k: en effet,
0.2 · 0.823 + 0.3 · 0.058 + 0.3 · 0.030 + 0.2 · 0.044 = 0.2 (k = 1)

0.2 · 0.087 + 0.3 · 0.908 + 0.3 · 0.032 + 0.2 · 0.002 = 0.3 (k = 2)
0.2 · 0.045 + 0.3 · 0.032 + 0.3 · 0.937 + 0.2 · 0.001 = 0.3 (k = 3)
0.2 · 0.044 + 0.3 · 0.001 + 0.3 · 0.001 + 0.2 · 0.952 = 0.2 (k = 4)
3.3.4 Taux d’entropie d’une chaîne de Markov
Théorème 3.8 Le taux d’entropie d’une chaîne de Markov régulière de premier

ordre de matrice de transition P = (pjk ) est
X X
h∞ (X) = − πj pjk log pjk (3.18)
j k
où π est la distribution stationnaire associée à la matrice de transition P .
D ÉMONSTRATION Le théorème 3.1 donne

(a)
h∞ (X) = lim H(Xn |X1n−1 ) = lim H(Xn |Xn−1 )
n→∞ n→∞
m
X m
X X X
(b) (n−1) (c)
= lim pj [− pjk log pjk ] = − πj pjk log pjk
n→∞
j=1 k=1 j k
où (a) découle de la définition 3.6, (b) découle de la définition H(Xn |Xn−1 ) impliquant la
(n−1)
quantité pj , la probabilité que le système soit dans l’état j au temps n − 1, et (c) découle
(n−1)
du théorème 3.7, impliquant la quantité limn→∞ pj = πj . ¥
F IG . 3.6 – Une chaîne de Markov de premier ordre sur Ω = {a, b}.
Exemple 3.13 On considère la chaîne de Markov (d’ordre 1) sur 2 états Ω = {a, b}, avec
p(a|a) = 2/3, p(b|a) = 1/3, p(b|b) = 2/3 et p(a|b) = 1/3 (figure 3.6). Par symétrie, la
distribution stationnaire correspondante est π(a) = π(b) = 0.5. Compte tenu de 3.18, son
taux d’entropie est
h∞ (X) = h2 (X) = −π(a) [p(a|a) ln p(a|a) + p(b|a) ln p(b|a)]

−π(b) [p(a|b) ln p(a|b) + p(b|b) ln p(b|b)] =
1 2 2 1 1 1 1 1 2 2
− [ ln + ln ] − [ ln + ln ] = 0.325 nats = 0.469 bits
2 3 3 3 3 2 3 3 3 3
Exemple 3.14 On considère la table de mobilité N = (njk ), donnant l’effectif croisé « pro-
fession du père » (lignes j = 1, . . . , 5) par « premier emploi à plein temps du fils » (colonnes
k = 1, . . . , 5) pour 19’912 hommes américains en 1973 dans cinq catégories: a = « non-
manuel supérieur »; b = « non-manuel inférieur »; c = « manuel supérieur »; d = « manuel
inférieur »; e = « travail agricole » (source: Hout 1986, cité dans Mirkin 1996).
 
a b c d e total
 ′
a 1 414 521 302 643 ′
40 2 920 
 
 b 724 524 254 703 48 2′ 253 
 
N =
 c 798 648 856 1′ 676 108 4′ 086 
 (3.19)
 d 756 914 771 ′
3 325 237 6′ 003 
 
 e 409 357 441 1 611 1 832 4′ 650
′ ′ 
′ ′ ′
total 4 101 2 964 2 624 7′ 958 2′ 265 19′ 912
En divisant chaque cellule njk par le total de ses rangées nj• on obtient ume matrice de
transition P = (pjk ) avec pjk := njk /nj• donnant les probabilités conditionnelles qu’un
individu (dont le père possède la profession j) ait un premier métier k:
 
a b c d e
 a 0.48 0.18 0.10 0.22 0.01 
 
 b 0.32 0.23 0.11 0.31 0.02 
P =   (3.20)
c 0.20 0.16 0.21 0.41 0.03 
 
 d 0.12 0.15 0.13 0.55 0.04 
e 0.09 0.08 0.09 0.35 0.39
Les composantes de la solution stationnaire π associée à la matrice de transition 3.20 sont

πa = 0.26, πb = 0.17, πc = 0.13, πd = 0.40 et πe = 0.04. Ce qui signifie que, sous la
fiction d’une matrice de transition constante 3.19, on observera à long terme que 26% des
P a, 17% dans la catégorie b, etc. Les entropies conditionnelles
individus sont dans la catégorie
H(Xn |Xn−1 = j) = − k pjk log pjk , mesurant l’incertitude quant au métier du fils Xn
(connaissant la profession du père Xn−1 = j) sont (en bits):
H(Xn |Xn−1 = a) = 1.85 H(Xn |Xn−1 = b) = 2.01

H(Xn |Xn−1 = c) = 2.02 H(Xn |Xn−1 = d) = 1.83
H(Xn |Xn−1 = e) = 1.95
Le métier du fils est donc le plus incertain lorsque le père est manuel supérieur (2.02 pour
Xn−1 = c) et le moins incertain lorsque le père est manuel inférieur (1.83 pour Xn−1 = d).
En moyenne, l’incertitude est
5
X
πj H(Xn |Xn−1 = j) = 0.26 × 1.85 + 0.17 × 2.01 + 0.13 × 2.02 +
j=1
+0.40 × 1.83 + 0.04 × 1.95 = 1.90 = h∞
ce qui n’est rien d’autre que le taux d’entropie du processus h∞ en raison de 3.18: comme
prévu et par construction, le taux d’entropie d’un processus de Markov mesure l’incertitude
conditionnelle moyenne sur l’état suivant, connaissant l’état
P précédent. Par contraste, l’incer-
titude totale (non conditionnelle) correspondante est − j πj log πj = 2.05 bits, ce qui est
plus grand que h∞ = 1.90 mais plus petit que l’incertitude uniforme log2 5 = 2.32 bits.
Évaluation 20
Vrai ou faux?
1. le taux d’entropie h∞ (X) d’une chaîne de Markov de premier ordre ne peut jamais
excéder son entropie totale (non conditionnelle) H(X) Réponses possibles: vrai - faux
2. le taux d’entropie h∞ (X) d’une chaîne de Markov de premier ordre ne peut jamais
égaler son entropie totale (non conditionnelle) H(X) Réponses possibles: vrai - faux
3. le taux d’entropie h∞ (X) d’une chaîne de Markov de premier ordre n’est pas défini si
la chaîne n’est pas régulière Réponses possibles : vrai - faux
4. le taux d’entropie h∞ (X) associé à une chaîne avec m catégories ne peut jamais excéder
log m. Réponses possibles : vrai - faux
3.3.5 Irréversibilité
Considérons une matrice de transition (m × m) P = (pjk ) définissant un processus de Markov

(0) P (0)
régulière, avec la distribution stationnaire associée π. Soit fj ≥ 0 (obéissant à m j=1 fj =
1) la distribution initiale (t = 0) du système sur ses différents états possibles j = 1, . . . , m. Au
(1) P (0)
temps t = 1, la distribution devient fk = m j=1 fj pjk . Plus généralement,la distribution
f (n) au temps t = n est donnée par
m
X
(n) (0) (n)
fk = fj pjk (3.21)
j=1
(n) (n)
Comme limn→∞ pjk = πk d’après le théorème 3.7, la formule 3.21 montre que limn→∞ fk =
Pm (0)
j=1 fj πk = πk . Ce qui signifie qu’indépendamment du profil de la distribution initiale
f (0) , la distribution à long terme f (n) converge à long terme n → ∞ vers la distribution sta-
tionnaire π. On parle d’équilibre si f (0) = π. En résumé, un profil général non-équilibré
f (0) 6= Pm π évolue vers le profil d’équilibre f (∞) = π où il reste alors inchangé, puisque
πk = j=1 πj pjk en raison de 3.16.
La dynamique de Markov est donc irréversible : toute distribution initiale f (0) évolue toujours
vers la (seule) distribution stationnaire π, et jamais dans l’autre sens; aussi, la dissemblance
entre deux distributions, quelles qu’elles soient, disparaît durant l’évolution, comme le montre
le théorème suivant:
Théorème 3.9 Soient f (n) et g (n) deux distributions dont l’évolution 3.21 est gou-
vernée par le même processus de Markov régulier P = (pjk ). L’évolution rend les
deux distributions de plus en plus similaires (et de plus en plus similaires à la distri-
bution stationnaire π) au sens où
K(f (n+1) ||g (n+1) ) ≤ K(f (n) ||g (n) )
où f (n+1) et g (n+1) sont les distributions « au temps d’après » correspondantes, à

savoir
m
X m
X
(n+1) (n) (n+1) (n)
fk = fj pjk gk = gj pjk (3.22)
j=1 j=1
Cas particuliers:
K(f (n+1) ||π) ≤ K(f (n) ||π) (obtenu avec g (n) := π, ce qui implique g (n+1) = π): l’entropie
relative de f (n) relativement à π diminue avec n: de nouveau, limn→∞ f (n) = π.
K(π||g (n+1) ) ≤ K(π||g (n) ) (obtenu avec f (n) := π, ce qui implique f (n+1) = π): l’entropie
relative de π relativement à g (n) diminue avec n.
K(f (n+1) ||f (n) ) ≤ K(f (n) ||f (n−1) ) (obtenu avec g (n) := f (n−1) , ce qui implique g (n+1) =
f (n) ): la dissemblance entre la distribution actuelle et la précédente (telle que mesurée
par K(f (n) ||f (n−1) )) diminue avec n.
Exemple 3.15 (suite de l’exemple 3.13) Supposons que la distribution initiale f (0) soit
f (0) (a) = 0.9 et f (0) (b) = 0.1. En employant 3.21 et le théorème 3.6, les distributions
successives f (n) au temps t = n et leur divergence K(f (n) ||π) (en nats) relativement à la
distribution stationnaire π = f (∞) (avec π(a) = π(b) = 0.5) sont, dans l’ordre,
n f (n) (a) f (n) (b) K(f (n) ||π)

0 0.9 0.1 0.3681
1 0.633 0.367 0.0358
2 0.544 0.456 0.0039
3 0.515 0.485 0.0005
... ... ... ...
∞ 0.5 0.5 0
Évaluation 21
Déterminez la seule réponse correcte:

3.4. CHAÎNES DE MARKOV D’ORDRE SUPÉRIEUR 71
1. une fois qu’il a quitté un état, le système y retournera avec la probabilité un si l’état est
a) transient; b) absorbant; c) récurrent; d) apériodique.
2. la matrice d’identité I est la matrice de transition d’une chaîne de Markov dont tous les
états sont a) transients; b) absorbants; c) irréversibles; d) apériodiques.
3. soit P une matrice de transition deux-par-deux. Le nombre minimal de composants non-
zéro de P assurant la régularité de la chaîne de Markov est a) 1; b) 2; c) 3; d) 4.
4. supposons que P 5 = I, où P soit une matrice de transition de Markov finie et I la
matrice d’identité. Alors P est a) indéterminée; b) régulière; c) I; d) apériodique.
3.4 Chaînes de Markov d’ordre supérieur

Après avoir étudié cette section et la suivante, vous devriez
– être capable de généraliser les concepts de la section précédente aux chaînes de
Markov d’ordre arbitraire r
– comprendre les fondements théoriques du test de l’ordre de la chaîne et être capable
de l’appliquer
– connaître le concept de sur-paramétrage et ses conséquences sur la simulation de
texte
Définition 3.11 Une chaîne de Markov d’ordre r > 0 est un processus stochastique
discret dont la mémoire est limitée aux r états passés, soit:
p(xn |x1n−1 ) = p(xn |xn−r

n−1
) ∀n ≥ r + 1
Une chaîne de Markov d’ordre r = 0, également appelée processus de Bernoulli, est

un processus stochastique sans mémoire, c’est-à-dire
p(xn |x1n−1 ) = p(xn ) ∀n ≥ 1
Une chaîne de Markov d’ordre zéro est donc clairement un processus indépendant.
Tous les processus de Markov considérés ici sont stationnaires, c’est-à-dire que leurs
n−1
probabilités de transition p(xn |xn−r ) sont indépendantes du temps. Ces dernières
sont généralement dénotées ici par p(ω|α) où ω ∈ Ω est l’état actuel et α ∈ Ωr spéci-
états immédiatement antérieurs. Par construction, p(ω|α) := p(αω)/p(α) ≥
fie les rP
0 avec ω∈Ω p(ω|α) = 1. ¨
3.4.1 Distribution stationnaire et taux d’entropie
Une chaîne de Markov de r-ième ordre sur Ω définie par les transitions p(ω|α) où ω ∈ Ω et
α ∈ Ωr peut formellement être considérée comme une chaîne de Markov de premier ordre sur
Ωr avec une matrice de transition de probabilité (mr × mr ) Q = (qαβ ) (où α = α1r ∈ Ωr et
β = β1r ∈ Ωr ) donnée par
qαβ = q(β|α) := δβ1 α2 δβ2 α3 . . . δβr−1 αr p(βr |α1r ) (3.23)

F IG . 3.7 – Une chaîne de Markov d’ordre r (ici k = 4) sur Ω est spécifiée par l’ensemble de
probabilités conditionnelles de la forme p(β4 |α1 α2 α3 α4 ). La même chaîne peut être consi-
dérée comme une chaîne de Markov de premier ordre qαβ sur Ωr où α = (α1 α2 α3 α4 ) et
β = (β1 β2 β3 β4 ); comme exprimé par 3.23, la matrice de transition qαβ est zéro, à moins que
β1 = α2 , β2 = α3 et β3 = α4 .
où δab := 1 si a = b et δab := 0 si a 6= b. L’équation 3.23 nous dit que la transition α → β est

possible si et seulement si les r − 1 premiers états élémentaires de β correspondent aux r − 1
derniers états élémentaires de α (voir figure 3.7)
Supposons en outre que la chaîne Q = (qαβ ) soit régulière (c’est-à-dire que chaque état Ωr
communique avec chaque état de Ωr et que la chaîne soit apériodique). Il y a alors une seule
distribution stationnaire π(α) = π(α1r ) sur Ωr satisfaisant 3.16 sur Ωr , c’est-à-dire, en em-
ployant 3.23:
X
π(α1 , α2 , . . . , αr ) p(αr+1 |α1 , α2 , . . . , αr ) = π(α2 , . . . , αr , αr+1 ) (3.24)
α1 ∈Ω
P P
De la même façon, 3.18 montre que le taux d’entropie correspondant h∞ est h∞ = − α π(α) β qαβ log qαβ
ou, en employant 3.23
X X
h∞ = − π(α) p(ω|α) log p(ω|α) (3.25)
α∈Ωr ω∈Ω
Rappel : en général, l’entropie conditionnelle hk (X) := H(Xk |X1k−1 ) est décroissante dans
k. D’autre part, 3.25 montre que le taux d’entropie h∞ (X) coïncide avec hr+1 (X). En conclu-
sion :
Théorème 3.10 Pour une chaîne de Markov de r-ième ordre, h∞ (X) = hr+1 (X).
C’est-à-dire
h1 (X) ≥ h2 (X) ≥ hr (X) ≥ hr+1 (X) = hr+2 (X) = hr+3 (X) = . . . = h∞ (X)
(3.26)
Le comportement 3.26 de hk (X) est illustré en figure 3.10 b) pour r = 1 et en figure 3.10 c)
pour r = 3.
Cas particuliers :
r = 1: le taux d’entropie devient
X X X X
h∞ = − π(α) p(ω|α) log p(ω|α) = − πj pjk log pjk
α∈Ω ω∈Ω j k
qui est la même expression que 3.18.

3.5. RECONSTRUCTION DE MODÈLES DE MARKOV À PARTIR DES DONNÉES 73
F IG . 3.8 – Une chaîne de Markov de second ordre p(ω|α) sur Ω = {a, b} (exemple 3.16) écrite
comme une chaîne de premier ordre qαβ sur les bigrammes α = α1 α2 ∈ Ω2 et β = β1 β2 ∈ Ω2 .
Les transitions sont interdites si α2 6= β1 : par exemple, la transition de α = ab à β = aa est
impossible.
r = 0: le taux d’entropie devient

X X
h∞ = − p(ω) log p(ω) = − πk log πk
ω∈Ω k
qui est l’entropie de la distribution stationnaire correspondante.

Exemple 3.16 Considérons (figure 3.8) la chaîne de Markov d’ordre r = 2 on m = 2 états
Ω = {a, b}, avec
p(a|aa) = 0.3 p(b|aa) = 0.7 p(a|ab) = 0.6 p(b|ab) = 0.4

p(a|ba) = 0.7 p(b|ba) = 0.3 p(a|bb) = 0.4 p(b|bb) = 0.6
Par symétrie, la distribution stationnaire π(α1 , α2 ) obéissant à 3.24 s’avère être la distribution
uniforme sur Ω2 , soit π(aa) = π(ab) = π(ba) = p(bb) = 41 . Par exemple, on vérifie que
l’égalité suivante est valable
1 1 1
π(aa) p(a|aa) + π(ba) p(a|ba) = 0.3 + 0.7 = = π(aa)
4 4 4
ainsi que d’autres égalités impliquées dans 3.24. Le taux d’entropie 3.25 est
h∞ = −π(aa) [p(a|aa) log p(a|aa) + p(b|aa) log p(b|aa)]

−π(ab) [p(a|ab) log p(a|ab) + p(b|ab) log p(b|ab)]
−π(ba) [p(a|ba) log p(a|ba) + p(b|aa) log p(b|ba)]
−π(bb) [p(a|bb) log p(a|bb) + p(b|bb) log p(b|b)] =
1
− [0.3 log 0.3 + 0.7 log 0.7 + 0.6 log 0.6 + 0.4 log 0.4] = 0.189 nats
2
3.5 Reconstruction de modèles de Markov à partir des données
Jusqu’à présent, nous avons considéré que les divers modèles qui nous intéressaient (station-
naire, Markov d’ordre r, Markov d’ordre 1, etc.) étaient donnés. Très souvent, cependant, nous
ne disposons que d’une réalisation empirique d’un processus, c’est-à-dire que seules les don-
nées D sont connues, et que les modèles M doivent être inférés à partir des données D. Ce
P
F IG . 3.9 – L’identité γ∈Ωl n(βγ) = n(β) a lieu si et seulement si il n’y a pas d’occurrence
d’un symbole de β dans les l derniers symboles de xn1 .
type de situation est paradigmatique en statistique inférentielle (voir module S1). Par souci de
clarté, les grandeurs empiriques (respectivement théoriques) seront dorénavant indexées par la
lettre D (respectivement M ).
3.5.1 Distributions empiriques et théoriques
Une séquence de k états consécutifs xl+r−1

l ∈ Ωk est appelée un k-gramme. Etant donnés le
k-gramme β ∈ Ωk et le l-gramme γ ∈ Ωl , le k + l-gramme obtenu en concaténant γ à la
droite de β est simplement dénoté par βγ. La longueur d’une sous-séquence α est simplement
dénotée |α|: par exemple, k = |β| et l = |γ|.
Les données D consistent en xn1 , la séquence complète observée de taille n. Soit n(β) l’effectif
empirique du k-gramme β ∈ Ωk , à savoir le nombre de fois que la sous-séquence β se produit
dans xn1 (par exemple, le bigramme β = 11 est contenu n(β) = 3 fois dans la séquence
x71 = 0111011). Le nombre de tous les k-grammes contenus dans une séquence de longueur n
est (pour n ≥ k)
X
n(β) = n − k + 1
β∈Ωk
Aussi avons-nous
X
n(βγ) ≤ n(β)
γ∈Ωl
où l’égalité est atteinte ssi les données xn1 ne contiennent pas d’occurences d’éléments de β
plus proches que l endroits du bord de droite (voir figure 3.9).
La distribution empirique et la distribution empirique conditionnelle sont définies comme
n(β) n(βγ)
f D (β) := f D (γ|β) := P ′
β ∈ Ωk γ ∈ Ωl (3.27)
n−k+1 γ ′ ∈Ωl n(βγ )
P
où les dénominateurs assurent une normalisation correcte, à savoir β∈Ωk f D (β) = 1 et
P D
γ∈Ωl f (γ|β) =P1. Asymptotiquement, soit pour n grand, nous avons approximativement
∼ ∼
n − k + 1 = n et γ∈Ωl n(βγ) = n(β), et ainsi
n(β) n(βγ)
f D (β) ∼
= f D (γ|β) ∼
= β ∈ Ωk γ ∈ Ωl (3.28)
n n(β)
Afin de souligner le contraste avec les ditributions empiriques, nous dénoterons dorénavant les
distributions théoriques correspondantes f M (β) et f M (γ|β) avec
p(βγ)
f M (β) := p(β) f M (γ|β) :=
p(β)
où p(. . .) est la mesure de probabilité compatible définie dans la section 3.
Exemple 3.17 La l-ième séquence Thue-Morse Dl est une séquence binaire construite ré-
cursivement comme suit:
D0 = 1 Dl+1 = Dl · D̄l
où · dénote la concaténation et l’inversion binaire D̄ remplaçant chaque symbole de D (dans

l’ordre) par son complément, à savoir 1̄ = 0 et 0̄ = 1. Les premières séquences Thue-Morse
sont
l Séquence Thue-Morse Dl
0 1
1 10
2 1001
3 10010110
4 1001011001101001
5 10010110011010010110100110010110
6 1001011001101001011010011001011001101001100101101001011001101001
En général, la l-ième séquence Dl contient 2l symboles binaires en proportions égales (pour

l ≥ 1). Dl peut également être obtenue en appliquant l fois la règle de substitution 1 → 10
et 0 → 01 à la séquence initiale D0 = 1. Les entrées impaires de Dl+1 reproduisent Dl .
Bien qu’elles soient purement déterministes, les séquences Dl peuvent être utilisées pour
définir les distributions empiriques f D (β) et les distributions conditionnelles empiriques
f D (γ|β). Par exemple, pour D = D6 , on trouve
symbole 1 0 total
1 1
fréquence empirique relative 2 2 1
bigramme 11 10 01 00 total
fréquence empirique relative 10 ∼
= 1 21
= 1 21
= 1 11 ∼
= 1
1
63 6 63 3 63 3 63 6
trigramme 111 110 101 100 011 010 001 000 total
fréquence rel. emp. 0 10 ∼
= 16 10 ∼
= 16 11∼
= 16 10∼
= 16 10 ∼
= 16 11∼
= 16 0 1
62 62 62 62 62 62
symbole conditionnel 1|11 0|11 total 1|10 0|10 total

fréquence empirique relative 0 1 1 10 ∼
= 12 11 ∼
= 12 1
21 21
symbole conditionnel 1|01 0|01 total 1|00 0|00 total

1 1
fréquence empirique relative 2 2 1 1 0 1
Le comportement de hk pour k ≥ 1 pour la séquence D14 (contenant 16’384 symboles

binaires) est illustré en figure 3.10.
Les valeurs des distributions empiriques f D (β) et les distributions conditionnelles f D (γ|β)
(comme celles trouvées dans l’exemple 3.17) peuvent servir à définir un modèle, i.e. des distri-
butions théoriques f M (β) et f M (γ|β). De nouvelles séquences stochastiques D̃ peuvent à leur

tour être simulées à partir de chaînes des Markov avec les paramètres f M (β) et f M (γ|β). Par
construction, les propriétés statistiques de la séquence résultante D̃ seront similaires à celles
de la « séquence d’apprentissage » D:
3.5.2 La formule des types pour les chaînes de Markov
Considérons une chaîne de Markov de r-ième ordre définie par la distribution conditionnelle
f M (ω|α) où ω ∈ Ω et α ∈ Ωr . La probabilité d’observer les données xn1 est
n
Y Y Y
P (xn1 ) = p(xr1 ) p(xi |xi−1 r
i−r ) = p(x1 ) f M (ω|α)n(αω)
i=r+1 α∈Ωr ω∈Ω
Pour r fixé et pour n → ∞, la contribution du terme p(xr1 ) devient négligeable relativement à

la contribution du produit. Ainsi, asymptotiquement, soit pour n grand, les « effets de bord »
causés par la finitude de n et se produisant au tout début ou tout à la fin de la séquence xn1
deviennent négligeables, et l’on peut écrire approximativement
Y Y
P (xn1 ) ∼
= f M (ω|α)n(αω) (3.29)
α∈Ωr ω∈Ω
Dans la même approximation (cf. 3.27) nous avons

n(α) n(αω)
f D (α) ∼
= f D (ω|α) ∼
= α ∈ Ωr ω∈Ω (3.30)
n n(α)
Intuitivement, nous pouvons nous attendre à ce que pour n grand, la distribution empirique
f D (ω|α) tende vers f M (ω|α) avec des fluctuations autour de cette valeur. Le théorème suivant
(où, par commodité, les entropies sont exprimées en nats) montre que c’est effectivement le
cas; de plus, la fluctuation des valeurs empiriques autour des valeurs théoriques est contrôlée
par la divergence conditionnelle de Kullback-Leibler Kr (f D ||f M ) d’ordre r:
Théorème 3.11 (formule des types pour les chaînes de Markov) Pour les chaînes
de Markov d’ordre r, la probabilité d’observer la distribution empirique condition-
nelle f D (ω|α) (pour tout ω ∈ Ω et α ∈ Ωr ) est, asymptotiquement,
P (f D | f M ) ≅ exp(−n Kr (f D ||f M )) (3.31)
où
X
Kr (f D ||f M ) := f D (α) K([f D ||f M ]|α) (3.32)
α∈Ωr
X f D (ω|α)
K([f D ||f M ]|α) := f D (ω|α) ln (3.33)
f M (ω|α)
ω∈Ω
En particulier, pour des effectifs donnés n(αω) (et donc pour des f D (α) donnés et pour des
f D (ω|α)) donnés, la probabilité 3.31 est maximale si et seulement si f˜M (ω|α) = f D (ω|α):
comme prévu, l’estimation de vraisemblance maximale du modèle M est simplement donnée
par la grandeur empirique correspondante (voir module S1 pour une exposition plus détaillée
du cas indépendant).
Remarque : K0 (f D ||f M ) est la divergence (inconditionnelle) régulière :

X f D (ω)
K0 (f D ||f M ) = K(f D ||f M ) = f D (ω) log
f M (ω)
ω∈Ω
D ÉMONSTRATION Rappel : an ≅ bn signifie limn→∞ n1 log(an /bn ) = 0. Par exemple,

l’approximation de Stirling est n! ≅ nn exp(−n).
Q
La valeur de f D (ω|α) est la même pour toutes n(α)!/( ω∈Ω n(αω)!) données xn1 possédant
les mêmes effectifs n(αω) mais différant de par l’ordre d’occurence. Ainsi
Y Y 1
P (f D | f M ) ∼
= n(α)! f M (ω|α)n(αω)
n(αω)!
α∈Ωr ω∈Ω
Prendre le logarithme en employant 3.30 et l’approximation de Stirling donne

" #
X X n(α)n(αω) M
D M ∼ n(αω)
ln P (f | f ) = ln f (ω|α) =
α∈Ωr ω∈Ω
n(αω)n(αω)
X X f M (ω|α) X X f D (ω|α)
D D
= n(αω) ln = −n f (α) f (ω|α) ln
f D (ω|α) f M (ω|α)
α∈Ωr ω∈Ω r α∈Ω ω∈Ω
Exemple 3.18 Considérons une chaîne de Markov de premier ordre avec deux états a et b.
Dans un état donné (a ou b), le système reste dans le même état avec la probabilité 0.9, et
change avec la probabilité 0.1. C’est-à-dire f M (a|a) = 0.9, f M (b|a) = 0.1, f M (b|b) = 0.9
et f M (a|b) = 0.1. Supposons que les données soient de la forme
D ≡ aaaa
| ·{z
· · aaaa}
n fois
Alors f D (a) = 1, f D (b) = 0, f D (a|a) = 1 et f D (b|a) = 0. Alors
f D (a|a) f D (b|a)
K([f D ||f M ]|a) = f D (a|a) ln M
+ f D (b|a) ln M =
f (a|a) f (b|a)
1 0
= 1 ln + 0 ln = 0.105 nats
0.9 0.1
D’autre part, ni f D (a|b) ni f D (b|b) ne sont définis, puisque le système n’a jamais été observé
dans l’état b: les équations 3.27 ou 3.28 retournent la valeur indéterminée 0/0 (que l’on
considère finie). Donc K([f D ||f M ]|b) n’est pas défini, mais K1 (f D ||f M ) l’est:
K1 (f D ||f M ) = f D (a) K([f D ||f M ]|a) + f D (b) K([f D ||f M ]|b) =

= 1 × 2.30 + 0 × K([f D ||f M ]|b) = 0.105 nats
Ainsi
P (f D | f M ) ≅ exp(−n 0.105) = (0.9)n
Par exemple, la probabilité d’observer la séquence aaaaaaaaaa sous le modèle (n = 10)

est approximativement (0.9)10 = 0.35 (la formule est exacte au terme initial près P (X1 =
a), déjà négligé dans 3.29); la probabilité d’observer la séquence aaaaaaaaaaaaaaaaaaaa
(n = 20) est (0.9)20 = 0.12, etc.
Exemple 3.19 (exemple 3.18, suite). Par symétrie, la probabilité stationnaire associée à la
chaîne est π(a) = π(b) = 0.5, et le taux d’entropie est
h∞ = −π(a)[f M (a|a) ln f M (a|a) + f M (b|a) ln f M (b|a)] − π(b)[f M (a|b) ·

· ln f M (a|b) + f M (b|b) ln f M (b|b)] = −0.9 ln 0.9 − 0.1 ln 0.1 = 0.325 nats
Donc la taille de l’ensemble des séquences typiques augmente jusqu’à |Tn (ε)| ∼ = exp(0.325 ·
n n
n) = (1.38) , au lieu de 2 pour un processus maximalement aléatoire (= indépendant +
uniforme). En d’autres termes, la dynamique du système observé se comporte comme si
seuls 1.38 choix effectifs étaient à disposition à chaque étape, au lieu de 2 choix effectifs (à
savoir a et b) pour la dynamique maximalement aléatoire.
3.5.3 Vraisemblance maximale et malédiction de la dimensionnalité
Supposons que l’on observe une séquence xn1 ∈ Ωn de longueur n avec m := |Ω| états dont
on pense qu’ils sont générés par une chaîne de Markov d’ordre r. La spécification complète de
cette dernière nécessite que l’on détermine toutes les grandeurs de la forme f M (ω|α) pour tout
ω ∈ Ω et α ∈ Ωr soit un total de mr (m − 1) grandeurs (les grandeurs P f M (ω|α) ne sont pas
complètement libres, mais elles doivent obéir aux mr contraintes ω∈Ω f M (ω|α) = 1 pour
tout α ∈ Ωr , d’où le facteur m − 1).
Mais même pour des valeurs relativement modestes de m et r, le nombre de paramètres libres
mr (m − 1) augmente très rapidement (par exemple 48 paramètres libres pour m = 4 et r = 2,
ou 54 paramètres libres pour m = 3 et r = 3). Par conséquent, la quantité de données D
requise pour estimer tous ces paramètres avec une marge d’erreur raisonnable devient très
grande! Ce phénomène, que l’on appelle parfois la malédiction de la dimensionnalité, repré-
sente un inconvénient majeur qui restreint énormément l’emploi des modèles markoviens pour
r grand, malgré la généralité et la flexibilité de ces derniers.
Concrètement, considérons l’estimation de vraisemblance maximale qui consiste à estimer
f M (ω|α) comme la valeur f˜M (ω|α) maximisant P (f D |f M ) pour une f D donnée. La formule
des types 3.31 démontre alors que la recherche de la fˆM (ω|α) estimée est simplement donnée
par la distribution empirique correspondante f˜M (ω|α) = f D (ω|α). Mais une séquence D =
xn1 de longueur n contient un maximum de n−r transitions distinctes α → ω, et si m ou r sont
assez grands, la majorité des transitions observées théoriquement ne se produiront simplement
pas dans D = xn1 , et les estimations de vraisemblances maximales correspondantes seront
données par la valeur fˆM (ω|α) = 0, même si f M (ω|α) > 0.
Ce problème de transitions inobservées se produit chaque fois que le nombre d’états pos-
sibles m ainsi que l’ordre de la chaîne r sont grands en comparaison de la taille échantillon
n. Différents remèdes ont été proposés afin de pallier à ce problème, comme la « stratégie du
trigramme » qui consiste à estimer f M (ω3 |ω1 ω2 ) (pour une chaîne de Markov d’ordre r = 2)
comme
fˆM (ω3 |ω1 ω2 ) = λ0 f D (ω3 ) + λ1 f D (ω3 |ω2 ) + λ2 f D (ω3 |ω1 ω2 )
où le choix optimal des poids non-négatifs λ0 , λ1 et λ2 , obéissant à λ0 + λ1 + λ2 = 1 est
typiquement déterminé par essai et erreur et a pour but de maximiser un indice de performance
relativement à une application donnée.
Bien qu’elles soient parfois satisfaisantes pour une application pratique donnée, de telles es-
timations manquent de fondements théoriques et de justification formelle. Cette situation est
quelque peu analogue au problème des espèces inobservées qui se produit chaque fois que
le nombre d’états possibles m est si grand en comparaison de la taille échantillon n qu’il se
peut que certains états n’aient pas été observés du tout dans les données D. Bien qu’il ait
été identifié clairement dans les données textuelles et biologiques depuis un certain temps, ce
problème n’a pas reçu de solution simple et universellement convenue; on peut toutefois se
référer au module L1 pour une stratégie qui vise à estimer le nombre total d’états (= observés
+ inobservés) possibles.
3.5.4 Tester l’ordre d’une chaîne de Markov
Dénotons f D (. . .) la fonction de distribution empirique déterminée d’après les données D =

xn1 ∈ Ωn , et dénotons f M (. . .) ≡ p(. . .) sa contrepartie théorique relativement à un modèle M .
Les entropies correspondantes empiriques et théoriques hk (X) introduites dans la section 3.1
sont respectivement
X X
k−1
hM k
k (X) = H(X1 ) − H(X1 )=− f M (α) f M (ω|α) ln f M (ω|α)
α∈Ωk−1 ω∈Ω
X X
hD
k (X) := − D
f (α) f D (ω|α) ln f D (ω|α)
Supposons que le modèle M soit une chaîne de Markov d’ordre r. Alors le théorème 3.10
implique
hM M M M M M M
1 ≥ h2 ≥ hr ≥ hr+1 = hr+2 = hr+3 = . . . = h∞ = h
M
De façon équivalente, la grandeur dM

k définie pour k ≥ 1 par
k−1
dM M M k
k := hk − hk+1 = 2H(X1 ) − H(X1 ) − H(X1k+1 )
obéit, pour une chaîne de Markov d’ordre r, aux conditions :
dM
1 ≥0 dM
2 ≥0 dM
r ≥0 dM M M
r+1 = dr+2 = . . . d∞ = 0
Donc le plus grand k pour lequel dM k est strictement positif indique l’ordre r = k de la chaîne
M
de Markov M . Intuitivement, dk mesure la réduction de l’incertitude lorsque le dernier sym-
bole d’une séquence est prédit à l’aide d’un passé de longueur k au lieu de k − 1, d’où dMk =0
si k > r.
Comme avec tout problème inférentiel en statistique, la difficulté est due au fait que les entro-
pies conditionnelles hM k
k sont des grandeurs théoriques définies par (m − 1)m paramètres qui
n
ne sont pas directement observables. Mais si les données D = x1 sont assez nombreuses, on
s’attend à ce que hD M
k soit proche de hk , pour k petit. Aussi le rapport « nombre de paramètres
log n
à estimer/nombre de données » est-il petit si et seulement si k est petit relativement à log m.
Donc les estimations empiriques sont bonnes tant que k ≤ kmax , où kmax est de l’ordre de
log n
log m . Les figures 3.10 et 3.11 suggèrent que
1 log n
kmax := (3.34)
2 log m
est un choix pragmatique satisfaisant.
Par conséquent, pour k ≤ kmax , de grandes valeurs de dDk constituent un signe que le modèle
est probablement d’ordre k, comme le confirme le test de vraisemblance maximale ci-dessous:
Le test d’ordre
Considérons un processus de Markov sur |Ω| = m états observés n fois successives, à propos
duquel, pour k ≤ kmax , deux hypothèses sont en compétition, à savoir:
H0k : : « le processus est gouverné par une chaîne de Markov d’ordre k − 1 »
H1k : « le processus est gouverné par une chaîne de Markov d’ordre (strict) de k »
Alors H0k est rejetée au niveau α si
2n dD D D 2 2 k−1
k = 2n [hk − hk+1 ] ≥ χ1−α [(m − 1) m ] (3.35)
où dD
k est mesuré en nats.
Le test peut être appliqué successivement pour k = 1, 2, ... ≤ kmax := 21 ln ln n

m . Des modèles
candidats potentiels de k-ième ordre sont signalés par des valeurs élevées de dDk . Par exemple,
si tous les dk sont petits, un modèle d’indépendance peut être considéré (voir figure 3.11). Si
tous les dk sont grands, chaque k + 1-ième modèle bat le modèle d’ordre k immédiatement
inférieur. La figure 3.11 montre que l’ordre r de la chaîne est signalé par un pic à dD k (pour
k ≤ kmax ).
Exemple 3.20 Soit M une chaîne de Markov binaire d’ordre 3 spécifiée par f M (ω4 |ω1 ω2 ω3 )
sur Ω = {a, b}. Une séquence de longueur n = 1024 est générée à partir de ce modèle,
d’après lequel les distributions empiriques f D sont déterminées et les entropies condition-
nelles hD
k (X) calculées.
Les valeurs de hD D 2 2 k−1 au niveau

k (X) et dk ainsi que le seuil χ1−α [df] avec df = (m − 1) m
de signification α = 0.001 sont:
k hD
k dDk 2n dDk df χ20.999 [df]
1 0.692 0 0 1 10.8
2 0.692 0.001 2.05 2 13.8
3 0.691 0.054 110.59 4 16.3
4 0.637 0.006 12.29 8 18.
5 = kmax 0.631 0.0088 18.022 16 20.5
D ÉMONSTRATION Les stratégies de rapport de vraisemblance, dont Neyman et Pearson ont

montré qu’elles minimisent les erreurs des deux types (voir module S1), conduisent à prendre
comme variable de décision le rapport de probabilités correspondant aux deux modèles ou,
ce qui est équivalent, leur rapport de vraisemblance logarithmique LL
P (f D |f˜k ) P (f D |f˜k )
LL := log
P (f D |f˜k−1 ) P (f D |f˜k−1 )
où f˜k est, (dans le sens ML), le meilleur modèle de f D par une chaîne de Markov d’ordre
k, et f˜k−1 est le meilleur modèle pour f D d’ordre k − 1. Le premier est plus général que le
dernier et va donc aboutir à un meilleur ajustement, soit P (f D |f˜k ) ≥ P (f D |f˜k−1 ), c’est-à-
dire LL ≥ 0. D’autre part, la formule 3.31 des types P (f D | f M ) ≅ exp(−n Kr (f D ||f M ))
donne
LL = n [Kk−1 (f D ||f˜k−1 ) − Kk (f D ||f˜k )] ≥ 0

F IG . 3.10 – Les valeurs observées hD M

k (ligne continue) et les valeurs théoriques hk (ligne
pointillée) en termes de k pour différents modèles. Dans a), b) et c), les estimations de vrai-
semblance maximale empirique hD k coïncident approximativement avec les valeurs théoriques
M 1 log n
hk tant que k ≤ kmax = 2 log m . Les estimations avec k > kmax ne sont pas fiables en raison
de la prolifération de transitions inobservées. a): processus uniforme et indépendant (pile ou
face équilibrés) de longueur n = 1024 sur m = 2 états. b): chaîne de Markov d’ordre r = 1 de
longueur n = 1024 sur m = 2 états (voir exemple 3.13). c): chaîne de Markov d’ordre r = 3
de longueur n = 1024 sur m = 2 états (voir exemple 3.20). d): la figure représente les valeurs
empiriques hD k obtenues d’après la 14-ième séquence D
14 de longueur n = 214 sur m = 2
états (voir exemple 3.17).

F IG . 3.11 – Valeurs observées (ligne) et attendues (points) de dk = hk (X) − hk+1 (X) en

termes de k pour les modèles présentés en figure 3.10.
Finalement, les divergences conditionnelles Kr (f D ||f˜r ) sont, pour n grand, bien représen-
tées par leurs approximations quadratiques, les « khi-carrés » 21n χ2 (f D ||f˜r ). On peut dé-
montrer que ces derniers suivent sous le modèle f˜r , une distribution du khi-carré χ2 [df] où
df est le nombre de paramètres libres associés au modèle d’ordre r. On a donc démontré que
la différence 2n[Kk−1 (f D ||f˜k−1 ) − Kk (f D ||f˜k )], causée par les fluctuations de f D possi-
blement produites par f˜k mais non par f˜k−1 , se comporte comme un χ2 [df] avec df égal à la
différence des nombres de paramètres libres entre les deux modèles.
En assemblant les les pièces, on obtient la recette inférentielle « rejeter le modèle f˜k−1 et
accepter le modèle f˜k au niveau α si 2n [Kk−1 (f D ||f˜k−1 ) − Kk (f D ||f˜k )] ≥ χ21−α [df] » où
df est ici (m − 1) mk − (m − 1) mk−1 = (m − 1)2 mk−1 .
La démonstration sera complète si nous montrons que Kk−1 (f D ||f˜k−1 ) = hD
k (et que
Kk (f D ||f˜k ) = hD
k+1 ). Mais il résulte de 3.2 que
X X
k−1
hD k
k (X) = H(X1 ) − H(X1 )=− f D (β) log f D (β) + f D (α) log f D (α)
β∈Ωk α∈Ωk−1
(a) X X X
=− f D (αω) log f D (αω) + f D (α) log f D (α)
ω∈Ω α∈Ωk−1 α∈Ωk−1
(b) X X
=− f D (α) f D (ω|α) log f D (ω|α)
3.5.5 Simuler un processus de Markov
Etant données les n observations xn1 , et sous l’hypothèse que le processus sous-jacent est une
chaîne de Markov d’ordre r,
– on détermine tout d’abord l’ordre k de la chaîne (avec k ≤ 12 ln ln n
m ) à l’aide du test 3.35.
– on estime ensuite les transitions théoriques correspondantes f M (ω|α) (avec ω ∈ Ω et
α ∈ Ωr ) par les transitions empiriques f D (ω|α) := n(αω) α (estimation de vraisemblance
maximale).
A ce stade, on est en position de simuler le processus de Markov en faisant tourner un processus
de k-ième ordre avec la matrice de transition f D (ω|α) à partir d’un état initial α ∈ Ωr tiré avec
la probabilité f D (α).
Exemple 3.21 Ecrite avec m = 27 états (l’alphabet + les espaces, sans ponctuation), la
version anglaise de la Déclaration Universelle des Droits de l’Homme constitue un texte xn1
de longueur n = 8′ 149 à partir duquel les distributions empiriques conditionnelles f D (ω|α)
peuvent être calculées. On peut imaginer que le texte a été produit par une chaîne de Markov
d’ordre r définie par l’ensemble de probabilités conditionnelles théoriques {f M (ω|α)} où α
est un r-gramme. Ces probabilités théoriques peuvent être estimées (estimation ML) d’après
les estimations empiriques correspondantes, soit f˜M (ω|α) := f D (ω|α), et, en raison de 3.34,
log n 1 log 8′ 149
l’estimation est garantie fiable pour r ≤ 21 log m = 2 log 27 = 1.36, qui est plutôt petit! Les
simulations basées sur f˜M (ω|α) = f D (ω|α) avec |ω| = r produisent:
r = 0 (Processus indépendant)
iahthire edr pynuecu d lae mrfa ssooueoilhnid nritshfssmo
nise yye noa it eosc e lrc jdnca tyopaooieoegasrors c hel
niooaahettnoos rnei s sosgnolaotd t atiet
Les fréquences relatives de tous les m = 27 symboles sont correctement échantillonnées; en

particulier, la proportion d’espaces (16.7%) est respectée, et les mots ont à peu près la bonne
longueur. Il est toutefois évident que les transitions originales entre les symboles ne sont pas
reproduites correctement.
r = 1 (Chaîne de Markov de premier ordre)

erionjuminek in l ar hat arequbjus st d ase scin ero tubied
pmed beetl equly shitoomandorio tathic wimof tal ats evash
indimspre tel sone aw onere pene e ed uaconcol mo atimered
Les transitions de premier ordre sont prises en compte, ce qui rend cet échantillon plus lisible
que le premier (en particulier, les transitions consonnes-voyelles sont respectées).
r = 2 (Chaîne de Markov de second ordre)

mingthe rint son of the frentery and com andepent the halons
hal to coupon efornitity the rit noratinsubject will the the
in priente hareeducaresull ch infor aself and evell
L’échantillon commence à ressembler à de l’anglais, mais avec un zeste de latin....
r = 3 (Chaîne de Markov de troisième ordre)

law socience of social as the right or everyone held
genuinely available sament of his no one may be enties the

right in the cons as the right to equal co one soveryone
Le texte ressemble nettement à de l’anglais, avec des mots entiers reproduits correctement.
Cependant, nous sommes au-delà de la limite prudente de kmax = 1.36: le texte simulé
trahit son origine, à savoir la Déclaration Universelle des Droits de l’Homme, et non un autre
texte anglais original de taille comparable comme une recette culinaire ou un texte traitant de
mathématiques. De façon équivalente, les estimations de modèle f˜M (ω|α) = f D (ω|α) avec
|α| = 3 sont sur-paramétrées.
r = 4 (Chaîne de Markov de quatrième ordre)

are endowed with other means of full equality and to law no
one is the right to choose of the detent to arbitrarily in
science with pay for through freely choice work
Tous les mots simulés sont à présents de véritables mots anglais, ce qui reflète la grande
redondance de l’anglais R ∼= 0.73 (voir exemple 3.5). Entre-temps, le problème de sur-
paramétrage empire....
r = 9 (Chaîne de Markov d’ordre 9)

democratic society and is entitled without interference and
to seek receive and impartial tribunals for acts violating
the fundamental rights indispensable for his
Le sur-paramétrage a atteint des niveaux scandaleux d’après les standards statistiques: l’en-
semble {f M (ω|α)} de transitions d’ordre neuf (|α| = 9) contient (27 − 1) 279 = 6.1 × 1013
paramètres estimés d’après un texte de longueur n = 8.1 × 103 seulement! Par conséquence,
des morceaux entiers du texte original sont reproduits sans altération dans le texte simulé.
Évaluation 22
Déterminez la seule réponse correcte:
1. la « malédiction de la dimensionnalité » fait allusion à un problème a) de visualisation

dans des espaces de grandes dimensions; b) de manque de régularité des chaînes de
Markov; c) d’incapacité d’effectuer un test d’hypothèses; d) de sur-paramétrage.
2. le nombre d’arguments de la fonction de la distribution stationnaire associée à une chaîne

de Markov d’ordre r est a) 1; b) r − 1; c) r; d) variable.
3. l’observation d’une transition interdite par un modèle de Markov a) est un événement

rare; b) est possible si l’échantillon est suffisamment petit; c) devrait se produire dans
une proportion inférieure au niveau de signification; d) indique l’impossibilité du modèle
considéré.
4. la divergence conditionnelle de Kullback-Leibler Kr (f D ||f M ) d’ordre r a) est zéro si et

seulement si une transition interdite se produit; b) est infinie si et seulement si une transi-
tion interdite se produit; c) augmente dans r; d) augmente avec la probabilité P (f D |f M ).
Histoire et bibliographie
Section 3.3.5. Le comportement irréversible a été reconnu clairement et officiellement pour
la première fois en Thermodynamique au milieu du XIXième siècle sous le nom de Se-
cond Principe de Thermodynamique, déclarant que « l’entropie (physique) d’un système
physique isolé non-équilibré augmente jusqu’à atteindre l’équilibre ». La formulation
moderne du second principe, en termes de théorie de l’information pure, est donnée
(dans le cadre des processus de Markov) par le théorème 3.9. Elle montre en particu-
lier que K(f (n) ||π) diminue jusqu’à zéro pour n → ∞. Si la distribution stationnaire
π est uniforme (c’est-à-dire πj = 1/m pour tout j = 1, . . . , m), alors K(f (n) ||π) =
log m − H(f (n) ) où H(f ) est l’entropie de Shannon de la distribution f : ici le théorème
3.9 confirme que H(f (n) ) augmente en effet dans n avec la limite log m. Mais dans le
cas général, où π n’est pas uniforme, le Second Principe devrait être exposé plus correc-
tement comme suit: « l’entropie relative (relativement à π) d’un système physique isolé
non-équilibré diminue jusqu’à ce que l’équilibre soit atteint ».
Section 3.5. La Déclaration Universelle des Droits de l’Homme a été adoptée par l’assemblée
générale de l’ONU (résolution 217 A (III)) du 10 décembre 1948.
Pour aller plus loin

– Cover,T.M. et Thomas,J.A. Elements of Information Theory, Wiley (1991)
– Hillman, C. An entropy primer, http://www.math.washington.edu/ hillman/PUB/primer.ps,
(1996)
– Jelinek,F. Statistical Methods for Speech Recognition, The MIT Press, Cambridge, MA
(1998)
– Mirkin,B. Mathematical Classification and Clustering, Kluwer, Dordrecht, (1996)
– Shields, P.C. The Ergodic Theory of Discrete Sample Paths, Graduate Studies in Mathema-
tics, Volume 13, American Mathematical Society (1996)
– Xanthos, A. Entropizer 1.1: un outil informatique pour l’analyse séquentielle. Proceedings
of the 5th International Conference on the Statistical Analysis of Textual Data (2000).
Chapitre 4
Exercices du module C3
par F. BAVAUD
4.1 Chaînes de Markov de premier ordre
Exercice 4.1.1:
Une étudiante suivant un certain programme peut échouer à ses examens une fois; si elle échoue
deux fois, elle est éliminée du programme. Afin de formaliser le processus, considérons un mo-
dèle à cinq états Ω = {a, b, c, d, e} où a = « enregistrée dans le programme sans s’être encore
présentée », b = « première tentative réussie », c = « première tentative infructueuse, seconde
tentative à faire », d = « seconde tentative réussie » et e = « seconde tentative infructueuse
(éliminée) ».
A)
– dessinez le diagramme des transitions possibles entre les cinq états.
– quels états atteignent quels états ?
– quels états communiquent avec quels états ?
– énumérez toutes les classes récurrentes et transientes.
– énumérez tous les états absorbants.
B) Identifiez les états b et d (qui correspondent tous deux à une tentative réussie) et répondez
aux mêmes questions.
Exercice 4.1.2:
Considérons la table de changement d’opinion suivante N = (njk ), qui donne les effectifs
croisés de l’opinion de 493 Danois sélectionnés au hasard en ce qui concerne la CEE en Oc-
tobre 1971 (lignes j = 1, . . . , 3) par leur opinion envers la CEE en décembre 1973 (colonnes
87
88 CHAPITRE 4. EXERCICES DU MODULE C3
k = 1, . . . , 3) (source : Anderson 1990)

 
oui non indécis total
 oui 167 36 15 218 
 
N =
 non 19 131 10 160   (4.1)
 indécis 45 50 20 115 
total 231 217 45 493
1. calculez la matrice de transition P associée à la table de contingence N donnée en 4.1.

2. calculez la distribution stationnaire π associée à la matrice de transition P .
3. supposons que la dynamique du changement d’opinion en 26 mois ( = décembre 1973
moins octobre 1971) obéisse à un processus de Markov à la matrice de transition constante
P.
(a) si tout le monde était initialement en faveur de la CEE (= « oui »), quelle serait la
proportion d’individus restant dans l’état « oui » après 26 mois ? après 52 mois ? à
long terme ?
(b) quelle est l’incertitude à long terme sur l’état d’une personne ?
(c) quelle est l’incertitude conditionnelle sur l’état d’une personne, connaissant son
état 26 mois avant ?
(d) sans faire le calcul, écrivez la formule donnant l’incertitude conditionnelle sur
l’état d’une personne, connaissant son état 52 mois avant.
Chapitre 5
Module C2 : Codage efficace de

l’information
par J.-C. C HAPPELIER

Dans ce chapitre, nous présentons :
1. les bases du codage des sources d’information discrètes afin d’en compresser
les messages ;
2. les conditions qu’un code doit remplir pour compresser de façon efficace ;
3. la limite fondamentale à la compression des données ;
4. et une méthode pour produire des codes de compression efficaces.
Introduction
Dans le chapitre précédent, nous avons introduit la mesure d’incertitude de Shannon et plu-
sieurs de ses propriétés. Cependant, nous n’avons pas encore montré à quel point cette mesure
peut être utile sur un plan pratique. Dans ce chapitre, nous présentons le premier exemple de
problème pratique qui tire avantage de la mesure de Shannon. Ce problème est celui du codage
d’une source d’information discrète à l’aide d’une séquence de symboles. Nous développons
également quelques méthodes efficaces pour effectuer de tels codages, puis nous étudions sous
quelles conditions de tel codages peuvent être efficaces. Dans le cadre précis des code non am-
bigus, l’entropie s’avère être la limite fondamentale à la compression de données, c’est-à-dire
qu’elle est fortement liée à la longueur moyenne de code minimale possible.
Mais demandons nous d’abord pour quelles raisons code-t-on une source ? Il y a en fait trois
raisons principales :
– coder pour compresser les données, c’est-à-dire pour réduire (en moyenne) la longueur des
messages.
Pour ce faire, il faut tenter de supprimer un maximum de redondance des messages.
89
90 CHAPITRE 5. CODAGE EFFICACE DE L’INFORMATION
Ut Zt
Source Codeur
F IG . 5.1 – Schéma de base pour le codage d’une source : le symbole Ut , émis par la source au
temps t, est transformé en un mot de code Zt .
– coder pour assurer une bonne qualité de transmission en présence de bruit.

Pour ce faire, il faut ajouter de la redondance afin de pouvoir corriger les messages bruités.
– coder par souci de discrétion en rendant le message impossible (ou difficile) à déchiffrer par
des lecteurs non autorisés. Pour ce faire, il faut rendre l’accès au contenu d’information du
message difficile.
Ce chapitre, ainsi que le chapitre 7, examine le premier aspect du codage, à savoir coder par
souci d’efficacité. Le chapitre 9, ainsi que le chapitre 11, examinent le second aspect, à savoir
le codage correcteur d’erreurs. Le chapitre 13 examine le dernier aspect, soit le codage pour
garantir une certaine confidentialité.
Le présent chapitre aborde le problème du codage d’une source d’information discrète. Mais
qu’est-ce que cela signifie ? La section suivante répond à cette question. Nous examinons en-
suite l’efficacité du codage dans le but de compresser les données. Enfin, la dernière section
fournit un algorithme pour construire un code efficace.
5.1 Coder une variable aléatoire

Après avoir étudié cette section, vous devriez savoir :
1. ce que signifie «coder une source d’information discrète sans mémoire» ;
2. quelles sont les propriétés générales d’un code ;
3. quelle relation existe entre les codes et les arbres ;
4. sous quelles conditions certains codes peuvent exister.
Une source d’information∗ est un générateur de messages∗ c’est-à-dire un générateur de sé-

quences de symboles. Un symbole est simplement un élément d’un ensemble, appelé alphabet.
Dans ce cours, seuls les alphabets finis seront abordés. Lorsque l’alphabet est fini, on dit que
la source d’information est discrète ; et la taille de l’alphabet est appelée l’arité∗ de la source.
Par ailleurs, seuls les messages de longueur finie seront considérés.
Par exemple, un journal peut être considéré comme une source d’information discrète dont les
messages sont les textes contenus dans le journal, les symboles étant simplement les lettres de
l’alphabet ordinaire (y compris les espaces et autres signes de ponctuation).
Les messages de la source entrent alors dans un codeur qui les transforme en une séquence de
mots de code∗ . Le schéma de base d’une telle structure de codage est donné en figure 5.1.
Un mot de code∗ est simplement une séquence (non vide) de symboles pris dans l’alphabet de
codage, un autre alphabet employé par le codeur. Par conséquent, le codage fait correspondre
les symboles-sources et les mots de code, un mot de code pouvant être composé de plusieurs
symboles-codes.
5.1. CODER UNE VARIABLE ALÉATOIRE 91
Plus formellement, une source d’information∗ Ut , (plus généralement U lorsque l’indexation

explicite par le temps t n’est pas pertinente), est un processus aléatoire sur un alphabet donné
VU ; c’est-à-dire une séquence de variables aléatoires sur VU .
Chaque symbole a une probabilité P (Ut = ui ) d’être émis par la source à l’instant t. On dit
que la source est sans mémoire si la probabilité qu’un symbole ui soit émis ne dépend pas des
valeurs émises précédemment, c’est-à-dire si :
∀t ≥ 1 ∀ui ∈ VU P (Ut = ui |U1 ...Ut−1 ) = P (Ut = ui ).
En outre, seules les sources stationnaires∗ , c’est-à-dire les sources pour lesquelles P (Ut =
ui ) ne dépend pas de t, sont prises en considération dans ce chapitre. Dans un tel cas, et
lorsqu’il n’y a pas d’ambiguïté possible, P (U = ui ) sera dans la suite noté simplement pi .
Nous supposons que pi 6= 0 pour tout symbole considéré ui dans l’alphabet de la source ; ce
qui signifie que nous ne nous préoccupons pas des symboles de probabilité nulle.
En ce qui concerne le codeur, seul le cas le plus simple où un seul mot de code est associé
à chaque symbole-source est pris en considération. Techniquement parlant, le processus de
codage Z := f (U ) est une application de l’alphabet de la source VU à l’ensemble de mots de
code VZ .
Soit Z ∗ l’ensemble de toutes les séquences de longueur finie d’éléments de l’alphabet Z.
L’ensemble des mots de code VZ est un sous-ensemble de Z ∗ qui ne contient pas la chaîne
vide (c’est-à-dire la séquence de longueur 0).
En outre, nous nous concentrons sur les codes dans lesquels deux symboles différents de la
source correspondent à deux mots de code différents. Techniquement parlant, l’application f
est injective.
De tels codes, où Z = f (U ) est une application injective, sont appelés codes non-singuliers∗ .
Définition 5.1 (Code non-singulier) On dit que le code d’une source d’informa-
tion discrète est non-singulier lorsque deux symboles différents de la source cor-
respondent à deux mots de code différents.
Formellement, en notant zi le mot de code correspondant au symbole-source ui , nous
avons :
ui 6= uj =⇒ zi 6= zj .
Tous les codes pris en considération dans le reste de ce chapitre sont non-singuliers.
Puisqu’il n’y a pas de raison de créer des mots de code qui ne sont pas utilisés, c’est-à-dire
qui ne correspondent pas à un symbole de la source, l’application f de VU à VZ est surjective ;
c’est donc une bijection.
Exemple 5.1 (Codage d’une source finie) Un exemple de code très courant est celui du
code Morse. Ce code est utilisé pour coder des lettres usuelles. Il emploie essentiellement
deux symboles : un point (·) et un tiret (–).1 Par exemple, les lettres E, A et K sont respective-
ment codées «·», «· –» et «– · –».
Étant donné que nous ne nous intéressons pas uniquement au codage de symboles seuls, mais
également au codage de messages (c’est-à-dire des séquences de symboles), nous examinons
1
En réalité quatre symboles sont employés en Morse : des séparateurs de lettres et des séparateurs de mots sont
également utilisés.
des codes qui permettent de décoder chaque message individuellement. De tels codes sont
appelés des codes non-ambigus∗ .
Définition 5.2 (Codes non-ambigus) On dit que le code d’une source discrète est
non-ambigu si et seulement si chaque séquence (de longueur finie) de mots de code
ne correspond qu’à un seul message de la source. ¨
Plus formellement, on dit qu’un code est non-ambigu si et seulement si l’extension triviale fˆ de
l’application f à l’ensemble de messages VU∗ , prenant sa valeur dans l’ensemble de séquences
de mots de code de longueur finie VZ∗ (fˆ : VU∗ → VZ∗ ), est une bijection.
Exemple 5.2 (Code ambigu) Considérons la source composée des trois symboles a, b et
c. Ses messages peuvent être n’importe quelle séquence de ces symboles ; par exemple
«aabca» est un message de cette source.
Le codage suivant de cette source :
a 7→ 1 b 7→ 00 c 7→ 11
est ambigu.
Par exemple, une fois codés, il n’y a aucun moyen de distinguer le message «aaaa» du
message «cc». En effet, tous deux sont codés «1111».
Exemple 5.3 (Code non-ambigu) Conservons la source de l’exemple précédent et considé-

rons à présent le code suivant :
a 7→ 1 b 7→ 00 c 7→ 10
On peut montrer que ce code est non-ambigu. Par exemple, la séquence «10000» se décode
«abb» et la séquence «1000» se décode «cb».
5.1.1 Codes sans préfixe
Parmi les codes non-ambigus, certains présentent un intérêt particulier. Ce sont les codes sans
préfixe. Avant de définir ce qu’est un tel code, il nous faut introduire la notion de préfixe∗ .
On dit qu’une séquence z de longueur n (n ≥ 1) est un préfixe∗ d’une autre séquence z ′ si et
seulement si les n premiers symboles de z ′ forment exactement la séquence z. Par exemple,
abba est un préfixe de abbabc. Notez que toute séquence est trivialement son propre préfixe.
Définition 5.3 (Code sans préfixe) On dit que le code d’une source discrète est sans
préfixe lorsqu’aucun mot de code n’est le préfixe d’un autre mot de code.
Plus formellement, on dit qu’un code Z, dont l’alphabet est Z et dont l’ensemble de
mots de code est VZ , est sans préfixe si et seulement si
∀z ∈ VZ ∀y ∈ Z ∗ (zy ∈ VZ =⇒ y = ε)
(ε représentant la chaîne vide, c’est-à-dire la chaîne de longueur 0 ). ¨

Codes généraux
Codes non−singuliers
Codes non−ambigus
Codes instantanés
F IG . 5.2 – Comment les différents types de codes sont reliés.
Exemple 5.4 (Code sans préfixe) Considérons la source composée des trois symboles a, b
et c.
Le code suivant de cette source :
a 7→ 0 b 7→ 10 c 7→ 11
est sans préfixe.
D’autre part, le code suivant :
a 7→ 1 b 7→ 00 c 7→ 10
n’est pas sans préfixe puisque 1 (le mot de code pour a) est un préfixe de 10 (le mot de code
pour c).
Pourquoi se focaliser sur des codes sans préfixe ? La réponse se trouve dans les deux propriétés
suivantes (5.1 et 5.2), qui soulignent leur intérêt.
Propriété 5.1 Tout code sans préfixe est non-ambigu.
Cependant, il est important de remarquer qu’il existe des codes non-ambigus qui ne sont pas
sans préfixe comme l’exemple 5.3 le montre.
Venons-en maintenant à la seconde propriété intéressante des codes sans préfixe.
Définition 5.4 On dit qu’un code est instantané∗ si et seulement si chaque mot de
code dans toute chaîne de mots de code peut être décodé dès que l’on a atteint sa fin.
¨
Propriété 5.2 Un code est instantané si et seulement si il est sans préfixe.
Cette définition garantit qu’il n’est ni nécessaire de mémoriser les mots de code reçus ni d’at-
tendre les suivants pour effectuer le décodage. Un tel code permet d’économiser du temps et
de l’espace dans le processus de décodage d’un message codé.
Jusqu’à présent, nous avons rencontré différents types de codes : non-singulier, non-ambigu,
instantané. La façon dont ces différents types de codes sont reliés les uns aux autres est résumée
sur la figure 5.2.
Évaluation 23
noeuds
intérieurs racine
profondeur
feuilles
F IG . 5.3 – Résumé des termes se rapportant aux arbres.
Considérons une source d’information U , dont les symboles sont u1 = 1, u2 = 2, u3 = 3, et

u4 = 4, avec la distribution de probabilité suivante :
ui 1 2 3 4
P (U = ui ) 0.5 0.25 0.125 0.125
Considérons donc le codage suivant de cette source, (où zi est le mot de code pour ui ) :
z1 z2 z3 z4
0 10 110 111
1. Le code est-il non-ambigu ?

2. Codez le message 1423312.
3. Décodez la séquence 1001101010.
Évaluation 24
Ces codes sont-ils sans préfixe ? Non-ambigus ? Instantanés ?

a. z1 =00, z2 =10, z3 =01, z4 =11
b. z1 =0, z2 =1, z3 =01
c. z1 =1, z2 =101
5.1.2 Arbres n-aires pour le codage
Afin d’étudier plus en détail les propriétés des codes instantanés, nous devons introduire plus
de définitions et formuler quelques théorèmes. Parmi ceux-ci, l’outil le plus utile à l’étude des
codes instantanés est sans doute les arbres n-aires.
Pour commencer, résumons le concept d’arbre, ainsi que les termes qui s’y rapportent (cf
figure 5.3). Un arbre est un graphe (nœuds et arcs) qui commence par un nœud de racine
(simplement «la racine»). Chaque nœud du graphe est soit une feuille soit un nœud intérieur.2
2
Notez que d’après cette définition, la racine d’un arbre non réduit à un seul nœud est aussi un nœud intérieur.
Un nœud intérieur a un ou plusieurs fils et est appelé le parent de ses fils. L’arité∗ d’un nœud
est le nombre de ses fils. Un nœud feuille est un nœud sans fils, soit un nœud d’arité 0.
Contrairement à un arbre réel, la racine est généralement représentée au sommet de la figure
Donnons à présent la démonstration du théorème 5.1.
D ÉMONSTRATION
=⇒ Supposons tout d’abord qu’il existe un code instantané D-aire dont les longueurs de
mots de code sont l1 , l2 , . . . , lN . Soit L := max li + 1. Considérons la construction de l’arbre
i
de codage correspondant Tcode consistant à élaguer Tcomplet ,3 l’arbre D-aire de profondeur L.
0 1
Tcode
Tcomplet 0 1 0 1
0 1 0 1 0 1 0 1
En raison de la condition «instantané», aucun nœud correspondant à un mot de code ne

peut être au-dessous d’un autre nœud correspondant à un autre mot de code. Par conséquent,
chaque nœud correspondant à un mot de code élague son propre sous-arbre de Tcomplet . En
examinant le ième mot de code et en appliquant la propriété 5.3 à li (qui est < L), Tcode a,
pour ce nœud uniquement, DL−li feuilles de moins que Tcomplet .
P ³P ´
En considérant maintenant tout le code, Tcode a N
i=1 D L−li = D L N
i=1 D −li feuilles de
moins que Tcomplet .

Toutefois, au plus DL feuilles peuvent être retirées, étant donné que Tcomplet a précisément
DL feuilles. Par conséquent ÃN !
X
DL D−li ≤ DL ,
i=1
c’est-à-dire
N
X
D−li ≤ 1.
i=1
En outre, dans le cas où le code considéré est complet, tous les nœuds correspondent à un
mot de code ; donc tous les sous-arbres correspondants dans Tcomplet ont été «élagués», et, par
XN
L
conséquent, les D feuilles de Tcomplet ont été retirées. Ceci signifie que DL−li = DL ,
i=1
N
X
c’est-à-dire D−li = 1.
i=1
⇐= Inversement, supposons que l1 , l2 , . . . , lN soient des entiers positifs, de façon à ce
que (5.1) soit vérifiée. Soit L le plus grand de ces nombres L := max li , et nj le nombre de
i
ces li qui sont égaux à j (1 ≤ j ≤ L).
L
X L−1
X
−j L
L’inégalité peut donc être notée (5.1) nj D ≤ 1, c’est-à-dire nL ≤ D − nj DL−j .
j=1 j=1
Étant donné que nL ≥ 0, nous avons :
L−2
X
L
D nL−1 ≤ D − nj DL−j ,
j=1
c’est-à-dire
L−2
X
nL−1 ≤ DL−1 − nj DL−j−1 .
j=1
Et étant donné que tous les nj sont entiers, nous obtenons successivement, pour 0 ≤ k ≤
L−1
L−k−1
X
L−k
nL−k ≤ D − nj DL−j−k .
j=1
Ces inégalités constituent le point-clé de la construction d’un code avec des longueurs de
mots de code l1 , l2 , . . . , lN :
1. commençons par un nœud (la racine)
2. pour tout k de 0 à L :
(a) on assigne chaque mot de code à un nœud de profondeur courante (k) tel que
li = k. Ces nk nœuds deviennent donc des feuilles de l’arbre de codage.
(b) on étend tous les nœuds restants de profondeur courante avec D fils.
X
Ce faisant, le nombre de nœuds qui sont étendus à l’étape (2b) est Dk − nj Dk−j menant
j≤k
X
k+1 k+1−j
àD − nj D nouveaux nœuds pour l’étape suivante. En raison des inégalités
j≤k
précédentes, ce nombre est plus grand que nk+1 , laissant ainsi suffisamment de nœuds pour
l’étape suivante (2a).
L’algorithme peut donc toujours assigner des nœuds aux mots de code et construire ensuite
tout l’arbre de codage pour le code.
Par conséquent, si les li satisfont l’inégalité (5.1), nous sommes en mesure de construire un
code instantané avec les longueurs de mots de code correspondant aux li .
P
En outre, dans le cas où i D−li = 1, le nombre de nœuds restants après l’étape (2a) lorsque
j = L est
X N
X X
L L−j L
D − nj D =D − DL−li = DL (1 − D−li ) = 0,
j≤L i=1 i
ce qui signifie que tous les nœuds ont été affectés à un mot de code, c’est-à-dire que le code
est complet. ¥
Notez que cette démonstration de l’inégalité de Kraft contient un algorithme efficace pour la
construction effective d’un code D-aire instantané étant données des longueurs de mots de
code (lorsqu’un tel code existe).
5.2. CODAGE EFFICACE 103
D ÉMONSTRATION La probabilité de chaque nœud est égale à la somme des probabilités des
feuilles du sous-arbre issu de ce nœud. Donc la somme des probabilités des nœuds intérieurs
est une somme sur les probabilités des feuilles.
En outre, la probabilité d’une feuille apparaît dans cette somme exactement autant de fois
que la profondeur d de la feuille correspondante. En effet, une feuille à la profondeur d est
couverte par exactement d nœuds intérieurs : tous les nœuds qui sont sur le chemin de la
racine à cette feuille.
Ainsi, la somme des probabilités de tous les nœuds intérieurs est égale à la somme des pro-
duits de chaque probabilité de feuille et sa profondeur. Cette somme est précisément la défi-
nition de la profondeur moyenne des feuilles.
Plus formellement, soit νi , 1 ≤ j ≤ M le M des nœuds intérieurs et soit λj , 1 ≤ i ≤ N
les N feuilles. En outre, soit Pi la probabilité du nœud intérieur νi et pj la probabilité de la
feuille λj . Enfin, soit δ(λj ) la profondeur de la feuille λj . Dénotons par νi ≥ λj le fait que
le nœud intérieur νi couvre la feuille λj .
Alors la somme des probabilités des nœuds intérieurs est égale à :
 
XM XM X XN X XN X
Pi = pj = pj = pj  1 .
i=1 i=1 j:νi ≥λj j=1 i:νi ≥λj j=1 i:νi ≥λj
X
En outre, 1 n’est rien d’autre que le nombre de feuilles couvrant la feuille λj . Par
i:νi ≥λj
conséquent, X
1 = δ(λj )
i:νi ≥λj
et
M
X N
X
Pi = pj δ(λj ) =: E [δ] .
i=1 j=1
Exemple 5.12 (Lemme de la longueur de chemin) Dans l’exemple précédent, la profon-

deur moyenne des feuilles était 1+0.3+0.7+0.3+0.1 = 2.4 par le lemme de la longueur de
chemin. À titre de vérification, notez que (définition de l’espérance de la longueur de code)
2 · 0.1 + 2 · 0.2 + 2 · 0.4 + 3 · 0.2 + 4 · 0.1 = 2.4 .
Considérons à présent quelques mesures d’entropie sur un arbre n-aire probabilisé.
Définition 5.11 (Entropie d’une feuille d’arbre n-aire probabilisé) Soit N le

nombre de feuilles d’un arbre n-aire probabilisé et p1 , p2 , . . . , pN leurs probabilités.
L’entropie des feuilles d’un tel arbre est définie comme
X
Hfeuilles = − pi log pi (5.3)
i
Propriété 5.5 Pour l’arbre n-aire probabilisé correspondant à l’arbre de codage

instantané d’une source d’information U , nous avons :
Hfeuilles = H(U ) (5.4)
D ÉMONSTRATION Soit Z le code instantané en question. Par définition (d’un arbre de co-
dage), pi est la probabilité du ième mot de code et, par conséquent, Hfeuilles = H(Z).
En outre, étant donné que le code est non-singulier (Z = f (U ) est injective), H(Z) = H(U ).
Par conséquent, Hfeuilles = H(U ). ¥
Définition 5.12 Soit M le nombre de nœuds intérieurs d’un arbre n-aire probabilisé
et P1 , P2 , . . . , PM leurs probabilités. En outre, soient qi1 , qi2 , . . . , qini les probabilités
des ni fils (feuilles comprises) du ième nœud intérieur (dont la probabilité est Pi ).
L’entropie de branchement Hi à ce nœud est définie par
ni
X qij qij
Hi = − log , (5.5)
Pi Pi
j=1
Notez qu’en raison de la seconde propriété de la définition d’un arbre n-aire proba-
bilisé (definition 5.10), nous avons
ni
X
Pi = qij .
j=1
Exemple 5.13 Supposons que les M = 5 nœuds pour l’arbre des exemples 5.9, et 5.11,
page 5.11, soient numérotés de telle façon que P1 = 1, P2 = 0.3, P3 = 0.7, P4 = 0.3 et
P5 = 0.1.
Alors
5
X
Hfeuilles = − pi log pi ≃ 2.12 bit.
i=1
Nous avons n1 = 2 et q11 = 0.3 et q12 = 0.7, ainsi
H1 = −0.3 log 0.3 − 0.7 log 0.7 ≃ 0.881 bit.
De même, n2 = 2 et q21 = 0.1, q22 = 0.2, ainsi

0.1 0.1 0.2 0.2
H2 = − log − log ≃ 0.918 bit.
0.3 0.3 0.3 0.3
Nous vous laissons, à titre d’exercice, le soin de montrer que H3 ≃ 0.985 bit, H4 ≃ 0.918 bit,
H5 = 0.
Théorème 5.2 (Théorème de l’entropie des feuilles) L’entropie des feuilles d’un
arbre n-aire probabilisé est égale à la somme sur tous les nœuds intérieurs (racine
comprise) de l’entropie de branchement de ce nœud pondérée par sa probabilité. En
employant les notations définies ci-dessus :
M
X
Hfeuille = Pi Hi (5.6)
i=1
Exemple 5.14 Suite de l’exemple 5.13. Nous calculons Hfeuille par (5.6) pour obtenir
Hfeuille = 1 · H1 + 0.3 · H2 + 0.7 · H3 + 0.3 · H4 + 0.1 · H5

≃ 0.881 + 0.3 · 0.918 + 0.7 · 0.985 + 0.3 · 0.918 + 0 bit
≃ 2.122 bit.
conformément au calcul direct effectué dans l’exemple 5.13.
Théorème 5.3 Pour deux codes instantanés de la même source d’information, celui
qui a la longueur moyenne du code la plus courte a le plus haut taux d’entropie par
symbole.
En résumé, compresser les données sans perte d’information (i.e. code instantané) augmente
l’entropie par symbole.
5.2.3 Théorème du codage sans bruit
Nous allons maintenant employer les résultats des sections précédentes pour obtenir une borne
inférieure fondamentale à l’espérance de la longueur de code d’un code instantané d’une source
d’information.
Borne inférieure à l’espérance de la longueur moyenne du code pour les codes instanta-
nés.
Théorème 5.4 (Théorème de Shannon sur le codage, 1ère partie) Pour toute
source d’information discrète sans mémoire d’entropie H(U ), l’espérance de la
longueur de code E [L] de tout code D-aire instantané pour cette source satisfait :
H(U )
E [L] ≥ , (5.7)
log D
La limite (5.7) aurait pu être anticipée de façon intuitive. Il faut H(U ) bits d’information pour
spécifier la valeur de U . Mais chaque chiffre D-aire du mot de code peut, d’après le théo-
rème 1.2 et la définition de l’information mutuelle (équation (1.17)), fournir tout au plus log D
bits d’information sur U . Nous aurons donc certainement besoin d’au moins H(U )/ log D
symboles de code en moyenne pour spécifier U .
Formalisons davantage la démonstration du théorème.
D ÉMONSTRATION
N
X N
X
H(U ) log pi
E [L] − = pi l i + pi
log D log D
i=1 i=1
XN ³ ´
= pi − logD D−li + logD pi
i=1
N
X
Soit Q = D−li et qi = D−li /Q. On a alors :
i=1
N
X
H(U )
E [L] − = pi (− logD qi + logD pi − logD Q)
log D
i=1
ÃN !
X pi
= pi log − logD Q
qi
i=1
= K(pi , qi ) − logD Q
Or K(pi , qi ) ≥ 0 par les propriétés de la divergence de Kullback-Leibler (à noter que qi est

bien une distribution de probabilités), et logD Q ≤ 0 puisque Q ≤ 1 par l’inégalité de Kraft.
Donc
H(U )
E [L] − ≥ 0.
log D
Évaluation 29
Considérons une source d’information U dont les symboles sont u1 = 1, u2 = 2, u3 = 3, et

u4 = 4, avec la distribution de probabilité suivante :
ui 1 2 3 4
P (U = ui ) 0.5 0.25 0.125 0.125
Considérons ensuite le codage suivant de cette source (où zi est le mot de code pour ui ):
z1 z2 z3 z4
0 10 110 111
1. Quelle est l’espérance de la longueur de code ?

2. Le code considéré est-il efficace, c’est-à-dire optimal du point de vue de l’espérance de
la longueur de code ?
Le théorème ci-dessus est le premier exemple pour lequel la réponse à une question technique
est naturellement exprimée en fonction de l’entropie de Shannon. Ceci n’est toutefois pas une
justification complète de l’utilisation de l’entropie, puisque seul un minorant a été spécifié.
Par exemple, la valeur «1» serait aussi un autre minorant à l’espérance de la longueur de code,
mais nous ne prétendrions pas que cette limite est une justification de quoi que ce soit! Ce n’est
que lorsque le minorant donné est, dans un sens, la meilleure borne inférieure possible, qu’il
peut être utilisé comme justification. Afin de montrer que la limite exprimée dans le théorème
ci-dessus est effectivement la borne inférieure, nous devons montrer qu’il existe des codes dont
l’espérance de la longueur de code peut être arbitrairement proche de celle-ci.
Codes instantanés de Shannon-Fano
Nous montrons ici comment construire des codes instantanés «efficaces». Bien qu’ils ne soient
pas optimaux en général, ils sont suffisamment proches de la borne inférieure à l’espérance de
la longueur de code.
L’idée-clé est d’utiliser comme mot de code pour ui , un mot dont la longueur est
» ¼
log pi
li = − ,
log D
où ⌈x⌉ dénote pour tout x le seul entier tel que x ≤ ⌈x⌉ < x + 1.
Un tel code est appelé un code de Shannon-Fano. En effet, la technique est implicite dans
l’article écrit par Shannon en 1948, mais elle sera rendue explicite par Fano.
Mais un tel code instantané existe-t-il toujours ? La réponse est «oui» en raison de l’inégalité
de Kraft.
En effet, étant donné que par définition li ≥ − log pi
log D , nous avons
X X log pi X X
D−li ≤ D log D = DlogD pi = pi = 1.
i i i i
Mesurons à quel point un tel code est «bon» en termes de son espérance de la longueur de
code. Par définition de li nous avons :
log pi
li < − + 1. (5.8)
log D
En multipliant les deux côtés par pi et en sommant sur i, nous obtenons :

X P
− i pi log pi X
pi l i < + pi , (5.9)
log D
i i
c’est-à-dire
H(U )
E [L] < + 1. (5.10)
log D
Nous voyons que le code de Shannon-Fano a une espérance de longueur de code qui est à l’in-
térieur d’un symbole de la borne inférieure (5.7) valable pour tous les codes instantanés. Ce
code est donc plutôt bon. En effet, d’après la première partie du théorème de codage vu précé-
demment, nous savons qu’aucun code instantané ne peut «battre» l’espérance de la longueur de
code du code de Shannon-Fano de plus d’un symbole. Par conséquent, lorsque l’entropie de la
source codée H(U ) est grande, le codage de Shannon-Fano est presque optimal. Mais lorsque
H(U ) est petite, nous pouvons généralement faire bien mieux que le codage de Shannon-Fano,
comme nous le discuterons dans la section suivante.
Concentrons-nous à présent sur la seconde partie du premier théorème de codage de Shannon.
Théorème 5.5 (Théorème de codage de Shannon, 2ème partie) Pour toute source
d’information discrète sans mémoire d’entropie H(U ), il existe au moins un code
instantané D-aire dont l’espérance de la longueur de code E [L] satisfait :
H(U )
E [L] < + 1. (5.11)
log D
Ce théorème de codage ne donne pas vraiment de justification complète de l’entropie de Shan-

non parce que la borne supérieure ne peut pas être arbitrairement rapprochée de la borne in-
férieure. La justification complète doit attendre le chapitre 7, où le codage pour une source
d’information qui émet des messages avec des dépendances internes (soit une source à «mé-
moire») est considéré.
Exemple 5.15 Considérons le codage binaire (D = 2) de Shannon-Fano pour la source

d’arité 4 U pour laquelle p1 = 0.4, p2 = 0.3, p3 = 0.2 et p4 = 0.1. Un tel codage aura pour
longueurs de mots de code (étant donné que log2 (2) = 1)
l1 = −⌈log2 0.4⌉ = 2, l2 = −⌈log2 0.3⌉ = 2,

l3 = −⌈log2 0.2⌉ = 3, et l4 = −⌈log2 0.1⌉ = 4.
Nous construisons donc le code par l’algorithme donné dans la démonstration de l’inégalité
de Kraft, pour obtenir le code dont l’arbre binaire est
0 1
0 1 0 1
u1 u2
1
u3
0 1
u4
Par le lemme de la longueur de chemin, nous avons :
E [L] = 1 + 0.7 + 0.3 + 0.3 + 0.1 = 2.4,
et un calcul direct donne :
H(U ) = 0.4 log 0.4 + 0.3 log 0.3 + 0.2 log 0.2 + 0.1 log 0.1 ≃ 1.8 bit.
Nous voyons bien que (5.11) est satisfait.

Notez toutefois que ce code est clairement non-optimal. Si nous avions simplement employé
les 4 mots de code possibles de longueur 2, nous aurions eu un code plus court (E [L] = 2).
e-nnexe : Le théorème du codage sans bruit de Shannon
Évaluation 30
Considérons une source U dont l’entropie est 2.15 bit. Pour les valeurs suivantes : 2.75, 2.05,
3.25, 2.15, pensez-vous qu’il existe un code binaire instantané de U avec une telle espérance de
longueur de code ? Pensez-vous qu’il peut exister un meilleur code, soit un autre code binaire
instantané de U avec une espérance de longueur de code plus courte ? (oui, non, ou peut-être)
espérance de la existe-t-il un meilleur code ?

longueur de code peut exister ? non peut-être oui, bien sûr
2.75
2.05
3.25
2.15
5.2.4 Codes de Huffman
Algorithme de codage de Huffman
Nous montrons ici comment construire un code instantané D-aire pour une source d’informa-
tion discrète sans mémoire U avec n symboles. L’algorithme pour la construction d’un tel code
optimal est le suivant:
1. Choisissez n nœuds (qui seront finalement les feuilles de l’arbre de codage) correspon-
dant aux n symboles de la source u1 , u2 , . . . , un .
Assignez la probabilité pi au nœud ui pour 1 ≤ i ≤ n.
Marquez ces n nœuds comme «actifs».
Calculez le reste r de la division de 1 − n par D − 1. Notez que, bien que 1 − n soit
négatif, r est positif par définition d’un reste.
Notez également que dans le cas binaire (D = 2), r est toujours nul.
2. Groupez, en tant que fils d’un nœud nouvellement créé, les D − r nœuds actifs les moins
probables et les r nœuds (feuilles) inutilisés:
nouveau
noeud
... ...
... ...
D−r feuilles r feuilles
utiles inutiles
Marquez les D − r nœuds actifs comme «non actifs» et le nœud nouvellement créé
comme «actif».
Assignez au nœud nouvellement créé une probabilité égale à la somme des probabilités
des D − r nœuds qui viennent d’être désactivés.
3. S’il n’y a qu’un seul nœud actif, arrêtez (ce nœud est alors la racine de l’arbre de codage).
Autrement, posez r = 0 et retournez à l’étape 2.
Le code instantané résultant d’un tel algorithme de codage est appelé un code de Huffman∗ ,
puisque l’algorithme simple décrit ici fut découvert par D. Huffman dans les années cinquante.
Exemple 5.16 (Codage binaire de Huffman) Considérons une source d’information U

telle que
U u1 u2 u3 u4 u5 u6
pi 0.05 0.1 0.15 0.27 0.20 0.23
Un code de Huffman pour U est donné par :

0 1
0 1 0 1
u
z1 z2 z3 z4 z5 z6
0 1 4 u5 u6
0000 0001 001 01 10 11
0 1 u3
u1 u2
Les probabilités associées aux nœuds intérieurs sont les suivantes :
v1 = u 1 ⊕ u 2 v2 = v1 ⊕ u 3 v3 = u 5 ⊕ u 6 v4 = v2 ⊕ u 4 v5 = v4 ⊕ v 3
0.15 0.30 0.43 0.57 1
Enfin, notez que E [L] = 2 (0.2 + 0.23 + 0.27) + 3 (0.15) + 4 (0.1 + 0.05) = 2.45 (ou par
le lemme de la longueur de chemin : E [L] = 1 + 0.57 + 0.43 + 0.30 + 0.15 = 2.45), et
X6
H(U ) = − pi log pi = 2.42 bit.
i=1
Exemple 5.17 (Codage ternaire de Huffman) Pour la même source U de l’exemple précé-
dent et en employant un code ternaire (D = 3), nous avons pour le reste de 1 − n := 1 − 6 =
−5 par D − 1 := 2: r = 1. En effet, −5 = −3 · 2 + 1. Donc une feuille inutilisée doit être
introduite.
Le code ternaire de Huffman est dans ce cas :
a b c
u6 u4
a z1 z2 z3 z4 z5 z6
b c
u3 u5
aab aac ab c ac b
a
b c
u1 u2
Les probabilités associées à des nœuds intérieurs sont :
v1 = u 1 ⊕ u 2 v2 = v1 ⊕ u 3 ⊕ u 5 v3 = v2 ⊕ u 6 ⊕ u 4
0.15 0.50 1
Enfin, notez que E [L] = 1 + 0.5 + 0.15 = 1.65 (par le lemme de la longueur de chemin), et
H(U ) 2.42
log 3 = 1.59 = 1.52.
Évaluation 31
Considérons un dé pipé ayant la distribution de probabilité suivante :
1 2 3 4 5 6
0.17 0.12 0.10 0.27 0.18 0.16
Le but de cette question est de construire un code de Huffman binaire pour ce dé. Pour ce code,
par convention, nous donnerons l’étiquette 0 à la branche la moins probable et l’étiquette 1 à
la branche la plus probable. En outre, les nouveaux nœuds introduits seront appelés 7, 8, etc...,
dans cet ordre.
1. Quels sont les deux premiers nœuds à être regroupés ? Quelle est la probabilité corres-
pondante ?
2. Quels sont donc les deux nœuds suivants à être regroupés ? Quelle est la probabilité
correspondante ?
3. Continuez à donner les noms des deux nœuds à regrouper et la probabilité correspon-
dante.
4. Donnez le code de Huffman trouvé pour cette source :
ui = 1 2 3 4 5 6
zi =
e-nnexe : Codage de Huffman

e-nnexe : Codage efficace
Optimalité du codage de Huffman
Nous voulons maintenant démontrer que le codage de Huffman est optimal en ce sens qu’aucun
autre code instantané ne peut avoir une espérance de longueur de code strictement inférieure à
celle résultant du codage de Huffman.
Cependant, il est important de ne pas oublier qu’il existe plusieurs codes optimaux : permuter
les symboles-codes ou échanger deux mots de code de la même longueur donnera un autre
code avec la même longueur moyenne. L’algorithme de Huffman ne construit qu’un seul code
optimal.
Avant de prouver l’optimalité des codes de Huffman, nous devons donner quelques propriétés
des codes optimaux en général.
n
X
Un code est optimal si la longueur moyenne pi li est minimale parmi tous les codes ins-
i=1
tantanés possibles de la même source, dénotant li la longueur du mot de code correspondant
au symbole ui .
Lemme 5.2 Pour le code optimal d’une source d’information avec n symboles pos-
sibles, nous avons : ∀i(1 ≤ i ≤ n) ∀j(1 ≤ j ≤ n) pi > pj =⇒ li ≤ lj .
D ÉMONSTRATION Soit Z un code optimal de la source en question. Pour un i donné et un j

donné, considérons le code Y dans lequel les mots de code zi et zj sont échangés, c’est-à-dire
yj = zi , yi = zj et yk = zk pour k 6= i, k 6= j. Alors
E [LY ] − E [LZ ] = pj li + pi lj − (pi li + pj lj )

= (pi − pj ) (lj − li ).
Parce que Z est optimal, E [LY ] ≥ E [LZ ]. Par conséquent, si pi > pj , lj −li doit être positif.
¥
Lemme 5.3 (Lemme de comptage des nœuds) Le nombre de feuilles dans un arbre
D-aire est 1 + M · (D − 1) où M est le nombre de nœuds intérieurs (racine incluse).
D ÉMONSTRATION Chaque nœud intérieur a D fils, donc le nombre total de nœuds de l’arbre
qui sont les fils d’un autre nœud est M · D. Le seul nœud de l’arbre à ne pas être le fils d’un
autre nœud est la racine. Le nombre total de nœuds de l’arbre est donc M · D + 1.
Mais par définition, il y a M nœuds intérieurs, donc le nombre de feuilles (c’est-à-dire le
nombre de nœuds qui ne sont pas des nœuds intérieurs) est
M · D + 1 − M = 1 + M · (D − 1).
Lemme 5.4 Pour une source d’information donnée U , il y a tout au plus D − 2

feuilles inutilisées dans l’arbre de codage d’un code D-aire instantané optimal de U ,
et ces feuilles inutiles sont toutes à une profondeur maximale.
En outre, il existe un code D-aire optimal pour U dans lequel toutes les feuilles
inutilisées sont des fils du même nœud parent.
D ÉMONSTRATION S’il y a au moins une feuille inutilisée qui n’est pas à la longueur maxi-
male, l’espérance de la longueur de code peut être diminuée en transférant à cette feuille
inutilisée l’un des mots de code de profondeur maximale. Le code original ne serait donc pas
optimal.
En outre, s’il y a plus de D feuilles inutilisées à profondeur maximale, au moins D de ces
nœuds inutilisés peuvent être regroupées en tant que fils du même nœud et remplacés par cet
unique nœud inutilisé qui est à une profondeur réduite de 1. Par conséquent, s’il y a plus de
D feuilles inutilisées, le code ne peut pas être optimal.
Enfin, s’il y a exactement D − 1 feuilles inutilisées à profondeur maximale, elles peuvent
être regroupées en tant que fils du même parent. Celui-ci a également une feuille utile qui est
son dernier fils. Mais on peut raccourcir le code en retirant simplement ce dernier symbole
inutile. En effet, ce dernier symbole n’est pas discriminant puisque tous ses nœuds frères sont
des nœuds inutiles. ¥
Lemme 5.5 Le nombre de feuilles inutilisées dans l’arbre d’un code D-aire instan-
tané optimal pour une source d’information discrète U avec n symboles possibles est
le reste (positif) de la division de 1 − n par D − 1.
D ÉMONSTRATION Soit r le nombre de feuilles inutilisées. Étant donné que U a n symboles

différents, nous avons :
£ ¤
r = nombre de feuilles dans l’arbre de codageD-aire − n.
Il résulte du lemme de comptage des nœuds que
r = [1 + M (D − 1)] − n,
ou
1 − n = −M (D − 1) + r.
En outre, d’après le lemme 5.4, nous savons que si le code est optimal, 0 ≤ r < D − 1 . Il
résulte donc du théorème de la division euclidienne que r est le reste de la division de 1 − n
par D − 1 (le quotient étant −M ). ¥
Lemme 5.6 Il existe un code D-aire instantané optimal pour une source d’informa-
tion discrète U avec n symboles différents (n ≥ 2) tels que les D − r mots de code les
moins probables diffèrent uniquement dans leur dernier chiffre, avec r comme reste
de la division de 1 − n par D − 1 (donc D − r ≥ 2).
D ÉMONSTRATION Notez tout d’abord que nous ne prétendons pas que tous les codes opti-
maux satisfont cette propriété, mais qu’en réarrangeant un code optimal existant, nous pou-
vons trouver au moins un code optimal qui satisfasse la propriété.
Considérons un code D-aire instantané optimal pour U (ceci existe puisque le nombre de
codes D-aires instantanés pour U est fini). D’après le lemme 5.5, nous savons qu’il y a r
feuilles inutilisées. D’après le lemme 5.4, elles sont toutes de profondeur maximale. Consi-
dérons les D − r frères de ces feuilles inutilisées. Ils représentent les plus grandes longueurs
de mots de code (puisqu’ils sont de profondeur maximale).
Construisons à présent le code où nous échangeons ces D − r plus longs mots de code contre
les D − r les moins probables. En raison du lemme 5.2, ceci ne change pas la longueur
moyenne (sans quoi le code en question n’aurait pas été optimal). Donc le code obtenu est
également optimal. Mais en ce qui concerne ce dernier code, nous sommes sûrs que les D − r
mots de codes les moins probables diffèrent uniquement dans leur dernier symbole. ¥
En raison du lemme 5.6, il suffit de chercher un code optimal dans la catégorie des codes où
les D − r mots de code les moins probables diffèrent uniquement dans leur dernier symbole.
Établissons à présent l’optimalité du codage de Huffman.
Théorème 5.6 Le codage de Huffman est optimal : si Z est le code de Huffman d’une
source d’information U et X un autre code non-ambigu pour U , alors E [LX ] ≥
E [LZ ].
D ÉMONSTRATION Nous démontrons ce théorème par récurrence sur le nombre de mots de

code (soit le nombre de symboles-source).
Il est simple de vérifier que pour toute source avec moins de D symboles, le code de Huffman
est optimal.
Supposons maintenant que la procédure de codage de Huffman soit optimale pour toute
source avec tout au plus n − 1 symboles, et considérons une source U avec n symboles
(n > D).
Soit r le reste de la division de 1 − n par D − 1: 1 − n = q(D − 1) + r.
Sans perte de généralité, soient un−(D−r)+1 , ..., un les D − r symboles-source les moins
probables.
Par construction, un code de Huffman Z pour U est fait d’un code de Huffman Y pour la
source V dont les n−(D−R)+1 symboles différents sont v1 = u1 , ..., vn−(D−r) = un−(D−r)
et vn−(D−r)+1 , avec les probabilités q1 = p1 , ..., qn−(D−r) = pn−(D−r) et qn−(D−r)+1 =

pn−(D−r)+1 + · · · + pn .
En effet, le nombre de feuilles inutilisées introduites pour Y est le reste de la division entière
de 1−[n−(D−r)+1] par D−1, qui est 0 puisque 1−[n−(D−r)+1] = 1−n−r+D−1 =
q(D − 1) + (D − 1) = (q + 1)(D − 1). Ceci montre que Y correspond effectivement au code
construit à la seconde étape, puis aux stades suivants de la construction de Z.
Z apparaît donc comme une extension de Y dans le mot de code yn−(D−r)+1 : z1 = y1 , ...,
zn−(D−r) = yn−(D−r) et yn−(D−r)+1 est le préfixe de tous les mots de code zn−(D−r)+1 ,...,
zn qui diffèrent tous uniquement dans le dernier symbole.
Alors, en notant li la longueur de zi et par li′ la longueur de yi :
n
X n−D+r
X n
X
E [LZ ] := pi l i = pi l i + pi l i
i=1 i=1 i=n−D+r+1
n−D+r
X n
X
= pi li′ + pi (li′ + 1)
i=1 i=n−D+r+1
n
X Xn
= pi li′ + pi
i=1 i=n−D+r+1
n
X
= E [LY ] + pi
i=n−D+r+1
n
X
Étant donné que pi est indépendant du processus de codage (il ne dépend que
i=n−D+r+1
de la source U ), en raison du lemme 5.6 et du fait que Y , par hypothèse de récurrence, est
optimal pour V (qui a moins de n symboles), nous concluons que Z est optimal pour U
(c’est-à-dire que E [LZ ] est minimal). ¥
R ÉSUMÉ DU CHAPITRE 5
Codes instantanés:
– aucun mot n’est le préfixe d’un autre
– instantané =⇒ non-ambigu =⇒ non-singulier
– sans préfixe ≡ instantané
P −li
Inégalité de Kraft: ∃ code D-aire instantané ⇐⇒ iD ≤1
Limite de l’entropie à la longueur moyenne d’un code instantané :
X H(U )
E [L] = pi l i ≥
log D
i
Code de Shannon-Fano: »¼
log pi
li = −
log D
X H(U )
E [L] = pi l i < +1
log D
i
Code de Huffman:
1. introduit 1 − n mod (D − 1) feuilles inutilisées avec la probabilité 0
2. regroupe récursivement les nœuds les moins probables
3. est optimal (en ce qui concerne l’espérance de la longueur de code) dans la caté-
gorie des codes non-ambigus
Théorème du codage sans bruit de Shannon 1948

Inégalité de Kraft 1949
Codage de Huffman 1952
Ce chapitre n’aborde que le cas de sources sans mémoire. Cependant, dans la plupart des cas
de la vie réelle, comme par exemple la compression de données sur ordinateur, les sources
considérées sont rarement sans mémoire. La question de la compression de sources avec des
dépendances intérnes est abordée dans le chapitre 7.
Pour plus de détails sur le codage de compression, veuillez vous référer à [8].
Chapitre 6
6.1 Coder une variable aléatoire
Exercice 6.1.1:
Considérez une source d’information U dont les symboles sont u1 = 1, u2 = 2, u3 = 3,

u4 = 4, et u5 = 5, avec la distribution de probabilité suivante :
ui 1 2 3 4 5
P (U = ui ) 0.125 0.25 0.025 0.5 0.1
Considérez ensuite le codage ci-dessous (où zi est le mot de code pour ui ) de cette source :
z1 z2 z3 z4 z5
01 111 110 10 00
a- Ce code est-il non-ambigu ?

b- Codez le message 5312241.
c- Décodez la séquence 111110100111011110.
d- Quelle est la longueur moyenne de ce code ?
Exercice 6.1.2:
Pour les codes suivants, déterminez si le code est sans préfixe, et/ou non-ambigu. Si le code
est sans préfixe, dessinez l’arbre de codage correspondant. Si le code est ambigu, donnez une
séquence de symboles qui pourraient être décodés en deux messages-sources différents.
117
a- z1 =01, z2 =10, z3 =110, z4 =001

b- z1 =abc, z2 =bca, z3 =bcb, z4 =cb, z5 =acb, z6 =cba
c- z1 =abc, z2 =bca, z3 =bcb, z4 =ca, z5 =acb, z6 =cba
Exercice 6.1.3:
a- Existe-t-il un code binaire sans préfixe ayant pour longueurs de ses mots code :
l1 l2 l3 l4 l5 l6 l7 l8 l9 l10
2 3 3 2 3 4 2 3 2 2
Justifiez votre réponse.
b- Quelle est la taille minimale de l’alphabet pour un tel code ?
c- Dans le cas minimal, dessinez un arbre de codage possible correspondant à ce code.
6.2 Codage efficace
Exercice 6.2.1:
Considérez la source U suivante :
U u1 u2 u3 u4 u5 u6 u7 u8
pU 1/4 1/8 1/8 1/16 1/16 1/16 5/32 5/32
a- Quelle est son entropie ?

b- Codons cette source à l’aide du code binaire « standard » sur 3 bits, c’est-à-dire le code
dans lequel zi , le mot de code pour ui est simplement i en binaire (sur 3 bits).
1. Le code est-il sans préfixe ? Si oui, dessinez son arbre de codage.
2. Est-il complet ?
3. Quelle est la longueur moyenne de ce code ?
4. Ce résultat est-il compatible avec le théorème du codage sans bruit de Shannon ?
c- Construisez un code de Huffman binaire de U et répondez de nouveau aux quatre questions
ci-dessus.
d- Est-il possible de construire un code de U tel que li , la longueur de mot de code zi soit
égale à ⌈log2 1/pU (ui )⌉ ? Si oui, répondez de nouveau aux quatre questions ci-dessus.
Exercice 6.2.2:
Le code considéré dans l’exercice 6.1.1 est-il un code efficace, c’est-à-dire optimal du point de
vue de la longueur moyenne de code ?
Exercice 6.2.3:
Considérez le dé pipé suivant :
1 2 3 4 5 6
0.17 0.15 0.16 0.22 0.18 0.12
a– Quelle est son entropie ?

b– Proposez un code de Huffman binaire de cette source.
– Quelle est sa longueur moyenne ?
– Quelle longueur de code moyenne minimale peut-on espérer pour tout codage binaire
de cette source ?
– Codez la séquence « 6441 » à l’aide de ce code.
c– Construisez un code de Huffman ternaire de cette source et répondez aux mêmes questions
(en remplaçant ’binaire’ par ’ternaire’).
Exercice 6.2.4:
Voici une distribution de probabilité possible pour les caractères en anglais :
char. (space) E T A O I N S
proba. 0.1859 0.1031 0.0796 0.0642 0.0632 0.0575 0.0574 0.0514
char. R H L D U C F M
proba. 0.0484 0.0467 0.0321 0.0317 0.0228 0.0218 0.0208 0.0198
char. W Y G P B V K X
proba. 0.0175 0.0164 0.0152 0.0152 0.0127 0.0083 0.0049 0.0013
char. J Q Z
proba. 0.0008 0.0008 0.0005
a– Calculez l’entropie de l’anglais, dans le sens d’une source d’information générant des sé-
quences indépendantes à partir de l’alphabet ci-dessus.
b– Construisez un code de Huffman binaire pour la source ci-dessus.
c– Quel est le taux de compression maximal que l’on peut espérer pour la source ci-dessus
(considérée comme une source sans mémoire) en utilisant des codes sans préfixe ?
Exercice 6.2.5:
L’objectif de cet exercice est d’illustrer le fait que les principes de codage efficaces peuvent
être appliqués à divers domaines, y compris à la théorie de la décision.
On vous donne 9 pièces de monnaie et une balance à deux plateaux non biaisée. Parmi ces 9
pièces, une est de poids différent. Le problème est de trouver la pièce différente en effectuant
un nombre minimal de pesées et de dire si elle est plus lourde ou plus légère que les autres.
a– À l’aide du théorème du codage sans bruit de Shannon, déterminez le nombre minimal de

pesées à effectuer.
b– Pour effectivement résoudre le problème en un nombre minimal de pesées, combien une
pesée élémentaire doit-elle contenir, au maximum, de pièces par plateau ?
c– Sachant que le problème pourrait être résolu à l’aide du nombre minimal en réponse à la
question a, essayez de le résoudre.
Exercice 6.2.6:
J’ai lu un jour, dans une revue pseudo-scientifique, le problème suivant :

« Les mathématiciens sont vraiment des gens étranges ! » dit un commissaire à sa
femme. « L’autre jour, nous avions toute cette rangée de verres d’une réception
dont nous savions qu’un (et un seul) était empoisonné. Évidemment, notre labora-
toire aurait pu tester les verres les uns après les autres, mais cela aurait coûté très
cher ! Il nous fallait donc trouver une procédure déterminant le verre empoisonné
en le moins de tests possibles, moyennant des mélanges de petits échantillons
prélevés dans les verres. Vint alors ce mathématicien. J’ignore d’ailleurs d’où il
venait. Il regarda les verres, qu’il était vraisemblablement en train de compter,
puis me dit en souriant : « Mon cher commissaire, choisissez un verre au hasard et
testez-le ». « Mais ce serait un gaspillage d’argent ! » dis-je, « pourquoi effectuer
un test inutile ? ». « Non », me répondit-il, « cela fait partie de la meilleure procé-
dure ! On peut tester en premier un seul verre, peut importe lequel. » »
« Et combien y avait-il de verres ? » demanda sa femme.
« Je ne me souviens pas exactement. Entre 100 et 200 je pense. » répondit le
commissaire.
Combien y avait-il de verres ?
Voilà comment le problème était posé. À présent,
1. répondez au problème comme demandé par la revue ;
2. montrez que l’auteur de ce problème se trompe (et donc le mathématicien de l’histoire
aussi) en :
(a) déterminant la procédure optimale de test ;
(b) calculant le nombre moyen de tests de cette procédure optimale ;
(c) calculant le nombre moyen de tests d’après la procédure suggérée par le mathéma-
ticien de l’histoire.
Chapitre 7
Module I1 : Compléments au codage

efficace de l’Information

Dans ce chapitre, plusieurs différents compléments aux bases du codage efficace,
c.-à-d. de compression de données, sont présentés.
En étudiant ce chapitre, vous devriez apprendre :
1. comment construire un code de longueur fixe optimal (codes de Tunstall) ;
2. comment coder de manière simple et efficace les nombres entiers avec un code
binaire sans préfixe (code d’Elias) ;
3. quelque-unes des techniques utilisées pour le codage de séquences avec des
dépendances internes (codage de source stationnaire), comme par exemple le
fameux code de Lempel-Ziv.
7.1 Codes de longueur fixe : Code de Tunstall

Dans cette section, vous apprendrez :
– ce que l’on entend par « code de longueur fixe » ;
– ce que sont les « ensembles propres de messages » et à quoi ils sont utiles ;
– comment la première partie du théorème de codage sans bruit de Shannon est gé-
néralisée aux ensemble propres de codes de longueur fixe ;
– ce que sont les « ensembles de messages de Tunstall » ;
– et à quoi ils servent : fournir un code de longueur fixe optimal ;
– comment construire de tels ensembles, c.-à-d. des codes de Tunstall.
121
122 CHAPITRE 7. COMPLÉMENTS AU CODAGE EFFICACE DE L’INFORMATION
7.1.1 Introduction
Les mots de code de longueur variable considérés dans le chapitre 5 ne conviennent pas tou-
jours en pratique. Si les mots de code doivent, par exemple, être stockés en mémoire, les mots
de code dont la longueur est égale à la longueur des mots de la mémoire (c.-à-d. 8, 16 ou 32
bits) sont certainement préférables. Toutefois, c’était précisément la variabilité de la longueur
des mots de code qui faisait l’efficacité des codes présentés dans le chapitre 5 ! La question
est alors : est-il possible d’obtenir une efficacité de codage similaire lorsque l’on force tous les
mots de code à avoir la même longueur ? La réponse est oui, à condition que les mots de code
ne soient plus assignés à des blocs de longueur fixe de symboles de la source mais plutôt à des
blocs de longueur variable de symboles de la source, c.-à-d. qu’une segmentation à longueur
variable de la source doit être effectuée. De tels codes sont appelés « codes de longueur fixe » :
les mots de code D-aires ont tous la même longueur n, mais la longueur LV , des messages V
auxquels les mots de code sont assignés, est une variable aléatoire.
Étant donné que n/E [LV ] est le nombre moyen de signes de code D-aires par symbole de la
source, le critère d’optimalité d’un tel code devient E [LV ], la longueur moyenne de message
codé ; qui doit être rendue aussi grande que possible.
7.1.2 Ensembles Propres
Quelles propriétés devraient avoir les codes de longueur fixe ?

Pour être sans préfixe, les mots de code devraient correspondre aux feuilles d’un arbre de
codage (voir propriété 5.4). En outre, pour être capable de coder n’importe quelle séquence de
la source, le code doit être complet (voir définition 5.8). En effet, si le code n’est pas complet,
la séquence de symboles correspondant à des feuilles inutilisées ne pourra pas être codée !
Un code de longueur fixe doit donc être un code propre ; c.-à-d. que des mots de code devraient
former un ensemble propre.
Définition 7.1 (Ensemble Propre) Un ensemble de messages est dit ensemble

propre si et seulement si il correspond à l’ensemble complet des feuilles d’un arbre
de codage. ¨
n o
Exemple 7.1 (Ensemble Propre) L’ensemble a, b, ca, cb, cc est un ensemble propre.
n o n o
Les ensembles a, b, ca, cb et aa, ac, b, cb, cc ne sont pas des ensembles propres.
Voici les arbres de codage correspondants :
a b c a b c a b c
a b c a b c a b c a b c
Évaluation 32
Pour chacun des ensembles suivants, décidez si l’ensemble est un ensemble propre ou pas :
7.1. CODES DE LONGUEUR FIXE : CODE DE TUNSTALL 123
1. 010, 00, 1, 011

2. 000, 010, 001, 01, 1
3. 110, 010, 011, 10, 00
4. 110, 011, 00, 010, 111, 10
Théorème 7.1 L’incertitude H(V ) d’un ensemble propre V pour une source d’in-
formation sans mémoire discrète D-aire, dont l’incertitude est H(U ), satisfait :
H(V ) = E [LV ] · H(U ),
où E [LV ] est la longueur moyenne du message codé.
D ÉMONSTRATION L’arbre de codage correspondant à un ensemble propre est par définition

l’arbre de codage d’un code complet, et donc l’entropie de branchement de chacun de ses
nœuds internes est égale à l’entropie de la source U .
Alors on a, par le théorème de l’entropie des feuilles (théorème 5.2) :
Ã !
X X
H(V ) = Pi H(U ) = Pi · H(U )
i i
et par le lemme de la longueur du chemin (lemme 5.1) :
H(V ) = E [LV ] · H(U )
Nous pouvons maintenant voir comment le théorème de codage sans bruit de Shannon (par-
tie 1) s’applique aux ensembles propres de sources d’information sans mémoire :
Théorème 7.2 Pour tout code instantané D-aire Z de tout ensemble propre de mes-
sages V pour une source d’information discrète sans mémoire U , le rapport de la
longueur moyenne de mot de code E [LZ ] sur la longueur moyenne de message codé
E [LV ], satisfait
H(U ) E [LZ ]
≤
log D E [LV ]
où H(U ) est l’incertitude d’un seul symbole de la source.
D ÉMONSTRATION Du théorème 7.1, on sait que :
H(V ) = E [LV ] H(U )
et du théorème de codage sans bruit de Shannon (théorème 5.4) :
H(V )
≤ E [LZ ] ,
log D
donc :
H(U )
E [LV ] ≤ E [LZ ] .
log D
7.1.3 Ensembles de messages de Tunstall
La section suivante examine la procédure efficace pour construire des codes de longueur fixe
efficaces, mais nous avons tout d’abord besoin d’une autre définition ; ce qui est le sujet de
cette section.
Définition 7.2 (Ensembles de messages de Tunstall) Un ensemble de messages est

un ensemble de messages de Tunstall si et seulement si c’est un ensemble propre tel
que, dans l’arbre de codage correspondant, chaque nœud est au moins aussi probable
que chaque feuille. ¨
Exemple 7.2 (Ensemble de Tunstall)
0.7
0.3
0.7 0.3 0.49
0.21
0.09
0.343
0.49 0.21 0.21 0.147
0.063 0.027 0.240 0.103

Ceci n’est pas un ensemble de Tunstall car Ceci est un arbre de Tunstall car chaque
il existe une feuille et un nœud interne tels nœud est plus probable que chaque
que la probabilité de la feuille (0.49) est feuille.
plus grande que la probabilité du nœud in-
terne (0.3).
Les ensembles de messages de Tunstall sont des codes de longueur fixe optimaux, c.-à-d.
qu’ils fournissent un maximum de longueur de message codé moyenne, comme stipulé par
le théorème suivant :
Théorème 7.3 Un ensemble propre de M messages d’une source U maximise la

longueur moyenne des messages codés (sur tous les ensembles propres possibles de
M messages de la même source U ) si et seulement si il est un ensemble de messages
de Tunstall.
D ÉMONSTRATION Prouvons tout d’abord que si un ensemble propre n’est par un ensemble
de Tunstall, il ne peut dès lors pas maximiser la longueur de message codé moyenne.
Soit W un ensemble propre qui n’est pas un ensemble de Tunstall. Il existe alors dans l’arbre
de codage correspondant une feuille w et un nœud interne n∗ tels que
P (n∗ ) < P (w)
Considérons ensuite l’arbre de codage obtenu par déplacement du sous-arbre situé en-dessous
de n∗ vers la feuille w (n∗ devient ainsi une feuille et w un nœud interne).

Avec les exemples précédents :
n*
0.7 0.3 0.7
0.3
0.49 0.09
0.49 0.09 0.21 0.21
w 0.21 0.21
0.343 0.147 0.063 0.027
0.063 0.027
0.103 0.044
L’arbre obtenu par cette opération définit encore un ensemble propre.

En outre, comme P (n∗ ) < P (w), les probabilités de tous les nœuds du sous-arbre déplacé
sont plus grandes dans le nouvel arbre de codage que dans l’arbre original.
Ainsi, la longueur de message codé moyenne qui, d’après le lemme de la longueur du chemin,
est la somme de toutes les probabilités des nœuds internes, est plus grande pour le nouvel
ensemble de messages que pour l’ancien.
Ainsi l’ancien ensemble de messages ne pouvait pas donner la longueur de message codé
moyenne maximale.
On a donc à ce stage prouvé que tout ensemble propre de message qui maximise la longueur
moyenne est un ensemble de Tunstall.
Réciproquement, considérons un ensemble de Tunstall T et montrons qu’il maximise la lon-
gueur moyenne des messages codés (parmis tous les ensembles propres possibles de M mes-
sages de la même source U ).
En utilisant le lemme de la longueur du chemin, cela revient à prouver qu’il maximise la
somme des probabilités des nœuds internes. En d’autres termes, montrons que pour tout arbre
T ′ , ensemble
P propre de M messages de la source U , la somme des probabilités de ses nœuds
internes n∈N (T ′ ) P (n) est forcément plus petite que celle de T (l’ensemble de Tunstall
considéré).
P
En effet, décomposons la somme n∈N (T ′ ) P (n) en d’une part les nœuds qui sont aussi
des nœuds internes de T et d’autre part ceux qui ne sont pas des nœuds internes de T . Ces
derniers sont soit des feuilles de T , soit dominés par un nœud qui est une feuille dans T (i.e.
sont dans un sous-arbre déplacé vers une feuille de T ).
On a alors :
X X X
p(n) = p(n) + p(w) · (1 + · · · )
| {z }
n∈N (T ′ ) n∈N (T ′ )∩N (T ) w∈N (T ′ )∩F (T ) sous-arbre
(en notant F (T ) l’ensemble des feuilles de T ).

Par ailleurs,
X X X
p(n) = p(n) + p(n)
n∈N (T ) n∈N (T ′ )∩N (T ) «les autres» n∈N (T )
P P
Il faut noter que les deux sommes n∈N (T ′ ) p(n) et n∈N (T ) p(n) ont le même nombre
′
P termes (puisque T et T ont même arité P
de et même nombre de feuilles) et donc
′
w∈N (T )∩F (T ) p(w) · (1 + · · · ) (dévelopée) et «les autres» n∈N (T ) p(n) ont également le
même nombre de termes.

Mais puisque T est un ensemble de Tunstall,
∀n ∈ N (T ) ∀w ∈ F (T ) p(t) ≥ p(w),
et donc : X X
p(n) ≥ p(w) · (1 + · · · )
«les autres» n∈N (T ) w∈N (T ′ )∩F (T )
(ces deux sommes ayant autant de termes, chacun des termes de la première pouvant être
apparié (bijection) à un terme plus petit (ou égal) de la seconde).
D’où : X X
p(n) ≥ p(n)
n∈N (T ) n∈N (T ′ )
Ce qui conclut la démonstration. ¥
7.1.4 Algorithme de construction du code de Tunstall
Soit n la taille désirée des mots de code, et soient DU et DZ respectivement l’arité de la source
U et l’arité du code Z. Le nombre maximal de mots de code est alors DZ n .
Nous voulons construire un ensemble de Tunstall de taille M pour U (M ≤ DZ n ), c.-à-d. que
nous cherchons (entre autres) un code complet, c.-à-d. sans feuilles inutiles (ensemble propre).
Nous devons donc avoir M de la forme (voir lemme 5.3) :
M = 1 + k (DU − 1)
pour un certain entier k.

Pour être optimaux, nous cherchons M maximal (avec M ≤ DZ n ). Nous devons donc choi-
sir : ¹ º
DZ n − 1
k=
DU − 1
Ce qui mène à l’algorithme suivant :

Algorithme de Tunstall pour un codage optimal de longueur fixe
1. Vérifier si DZ n ≥ DU . Si non, arrêter : le code de longueur fixe est impossible à créer.
n
2. Calculer k = ⌊ DDZU −1
−1
⌋
3. Calculer la taille de l’ensemble de messages codé M par M = 1 + k (DU − 1)
4. Construire l’arbre de codage de Tunstall de taille M (c.-à-d. à M feuilles) en répétant k
fois (racine incluse) :
– prolonger (avec DU branches) le nœud le plus probable
Il est aisément vérifiable que l’ensemble obtenu est effectivement un ensemble de Tuns-
tall.
5. Assigner un mot de code DZ -aire distinct de longueur n à chaque feuille, c.-à-d. à chaque
message dans l’ensemble de messages de Tunstall.
Exemple 7.3 DZ = 2, n = 3 (c.-à-d. mot de code = 3 bits)
U est une source ternaire (DU = 3) telle que P (U = −1) = 0.3, P (U = 0) = 0.2 et
P (U = 1) = 0.5.
Nous avons alors :

k = ⌊(8 − 1)/2⌋ = 3
et
M =1+3·2=7
k boucles :
1) prolonger la racine
2) prolonger le nœud le plus probable :
3) prolonger le nœud le plus probable :
Finalement, affecter les mots de code :
V 1,1 1,0 1,-1 0 -1,1 -1,0 -1,-1

Z 000 001 010 011 100 101 110
Évaluation 33
Nous cherchons un code de longueur fixe binaire à 4 bits optimal de la source ternaire, dont
les probabilités des symboles sont P (U = a) = 0.6, P (U = b) = 0.3 et P (U = c) = 0.1.
1. Combien de mots de code possède ce code ?

2. Combien d’étapes sont requises pour construire l’arbre ?
3. Comment est segmenté (c.-à-d. séparé en portions à coder) le message d’entrée acaaabaaaabbaaabbbc ?
4. Comment est codé acaaabaaaabbaaabbbc (le même message), en utilisant la conven-
tion que les feuilles sont numérotées par probabilité décroissante (i.e. 0000 pour la
feuille la plus probable) ?
R ÉSUMÉ DE LA SECTION 7.1
code de longueur fixe : codage de blocs de longueur variable de la source d’information par
des mots de code qui ont tous la même taille.
ensemble propre : un ensemble complet de feuilles d’un arbre de codage (pas de feuilles
inutiles).
ensemble de Tunstall : un ensemble propre tel que chaque nœud de l’arbre de codage cor-
respondant soit au moins aussi probable que n’importe laquelle de ses feuilles.
optimalité des ensembles de Tunstall : un ensemble propre maximise la longueur de mes-
sage codé moyenne si et seulement si c’est un ensemble de Tunstall.
n
algorithme de Tunstall : k = ⌊ DDZU −1
−1
⌋,M = 1 + k (DU − 1), prolonger k fois le nœud le
plus probable.
7.2 Codage des Entiers Positifs

Dans cette section, nous étudions un codage simple et efficace des entiers par un code
binaire instantané (code d’Elias).
Tournons-nous maintenant vers un autre aspect, complètement différent, du codage : comment

représenter efficacement des entiers (équiprobables) par des codes binaires ? Dans cette sec-
tion, nous décrivons un code instantané très intelligent pour les entiers positifs, élaboré par
Elias.
Partons d’un code pour entiers habituel, que le lecteur devrait connaître : la représentation
binaire (du bit le plus significatif). Voici un exemple de ce code, appelé ici Z0 :
n 1 2 3 4 5 6 7 8
Z0 (n) 1 10 11 100 101 110 111 1000
La longueur de ces mots de code est :
|Z0 (n)| = ⌊log2 n⌋ + 1
ce qui est assez proche de l’optimum théorique dans le cas le plus général (log2 n).
Ce code souffre toutefois d’un inconvénient majeur : il est loin d’être instantané. En fait, chaque
mot de code Z0 (n) est le préfixe d’infiniment beaucoup d’autres mots de code !
La première idée émise par Elias fut d’ajouter un code de longueur |Z0 (n)| devant Z0 (n) pour
rendre le code instantané. Le code finalement proposé consiste à ajouter |Z0 (n)| − 1 zéros
devant Z0 (n). Voici un exemple de ce code, que nous appelons Z1 :
n 1 2 3 4 5 6 7 8
Z1 (n) 1 010 011 00100 00101 00110 00111 0001000
Z1 est maintenant un code instantané. Sa longueur est toutefois loin de celle désirée : il est
deux fois plus long :
|Z1 (n)| = 2⌊log2 n⌋ + 1
7.2. CODAGE DES ENTIERS POSITIFS 129
Le « truc » intelligent utilisé par Elias pour se débarrasser de cet inconvénient fut de changer
le codage de la longueur fait par des zéros en le code Z1 de cette longueur. Un mot de code est
ainsi fait de l’enchaînement de Z1 (|Z0 (n)|) et de Z0 (n).
Par exemple, 7 est codé en 111 par Z0 , ayant ainsi une longueur de 3. Ceci donne le préfixe
Z1 (3) =011, et 7 est donc codé en 011111 (=011,111). Voici d’autres exemples :
n 1 2 3 4 5 6 7 8
Z2′ (n) 11 01010 01011 011100 011101 011110 011111 001001000
Notez que Z0 (n) commence toujours avec un 1, qui n’est maintenant plus requis pour éviter
l’ambiguïté. On peut donc se débarrasser de ce 1 inutile. Ceci nous mène au code d’Elias final
pour les entiers, désigné ici par Z2 :
n 1 2 3 4 5 6 7 8
Z2 (n) 1 0100 0101 01100 01101 01110 01111 00100000
Ce code est instantané. Qu’en est-il de sa longueur ?

– pour la partie principale :
|Z0 (n)| = ⌊log2 n⌋ + 1
– et pour le préfixe :
|Z1 (|Z0 (n)|)| = 2⌊log2 (⌊log2 n⌋ + 1)⌋ + 1
Donc :
|Z2 (n)| = 2⌊log2 (⌊log2 n⌋ + 1)⌋ + 1 + ⌊log2 n⌋ + 1 − 1

= ⌊log2 n⌋ + 2⌊log2 (⌊log2 n⌋ + 1)⌋ + 1 (7.1)
Il est assez remarquable qu’Elias ait trouvé un code binaire sans préfixe pour les entiers, dont
la longueur est assez proche de l’optimum log2 n, et qui est de plus facilement implémentable.
Évaluation 34
Quel est le code d’Elias pour 255 ?
Les codes d’Elias sont des codes binaires instantané pour les entiers, dont la longueur est
(asymptotiquement) proche de l’optimum log2 (n).
Ces codes résultent de l’enchaînement d’un préfixe, fait du premier code d’Elias de la lon-
gueur de la représentation binaire habituelle du nombre à coder, et d’un suffixe, fait de
la représentation binaire habituelle sans son bit le plus significatif.
7.3 Codage de Sources à Mémoire

Après avoir étudié cette section, vous devriez :
1. savoir comment la première partie du théorème de codage sans bruit de Shan-
non se généralise aux sources stationnaires ;
2. connaître plusieurs méthodes pour effectuer la compression de messages de
sources stationnaires :
(a) savoir ce qu’est le codage à précédence d’Elias-Willems ;
(b) savoir ce que sont les codes de Lempel-Ziv.
Finissons ce chapitre en évoquant le difficile sujet du codage de sources à mémoire, c.-à-d.

avec des dépendances internes dans les séquences de symboles.
Nous avons vu dans le chapitre 5 que le codage de Huffman était optimal dans le cas d’un
nombre fixe de variables aléatoires distribuées de manière indépendante et identique (p.ex.
plusieurs occurrences indépendantes de la même source). Qu’en est-il du cas où les symboles
sont dépendants ?
Les sources considérées dans cette section sont donc des processus stochastiques stationnaires
(voir définitions 3.1 et 3.2 du chapitre 3) ; plus précisément, des sources qui émettent des sé-
quences U1 , U2 , U3 , . . . de variables aléatoires D-aires telles que pour tout t ≥ 1 et tout n ≥ 1,
les vecteurs aléatoires (U1 , U2 , . . . , Un ) et (Ut+1 , Ut+2 , . . . , Ut+n ) aient la même distribution
de probabilité.
Exemple 7.4 Considérons, comme exemple d’une source avec des dépendances internes,
la « source oscillante » U consistant en une source binaire stationnaire telle que pU (0) =
pU (1) = 0.5 et :
P (Ui = 0|Ui−1 = 0) = 0.01 P (Ui = 1|Ui−1 = 0) = 0.99

P (Ui = 0|Ui−1 = 1) = 0.99 P (Ui = 1|Ui−1 = 1) = 0.01
(et pas d’autres dépendances à plus long terme), c.-à-d. P (Ui |Ui−1 ...U1 ) = P (Ui |Ui−1 ),
sinon au moins une des équations ci-dessus ne serait pas vérifiée).
L’entropie d’un symbole seul de cette source est clairement H(U ) = 1 bit. Qu’en est-il du
taux d’entropie ?
h∞ (U ) = lim H(Ui |Ui−1 Ui−2 ...U1 )

i→∞
= lim H(Ui |Ui−1 )
i→∞
stationnarité
= H(U2 |U1 )
= P (U1 = 0) · e h(0.01) + P (U1 = 1) · e
h(0.99)
= e
2 · 0.5 · h(0.01)
= 0.081 bit
où e
h(p) est l’entropie d’une variable aléatoire binaire de paramètre p :
7.3.2 Schéma de Codage de Source de Elias-Willems
Le schéma d’Elias-Willems pour le codage d’une source à mémoire est le suivant :

1. partager le flux de symboles de la source en blocs de taille k (c.-à-d. U (k) comme dans
la section précédente)
2. coder chaque bloc avec le code d’Elias de son compte de précédence1 .
La seule pièce du schéma qui nous manque encore à ce point est le « compte de précédence ».
Définition 7.3 (Compte de Précédence) Le compte de précédence d’un symbole v

à la position n d’une séquence de symboles V est Rn (v) = n − Ln (v), où Ln (v) est
le dernier index t (avant n) tel que Vt = v :
Ln (v) = max {t < n : Vt = v}
Rn (v) est donc le nombre de symboles reçus au temps n depuis la dernière réception
de v (avant n).
Pour que le compte de précédence soit défini pour chaque n possible (même les
premiers), une convention doit être choisie pour donner une valeur d’index initiale
à tous les symboles possibles. ¨
Définition 7.4 (Suite des (compte de) précédences) La suite des précédences N
associée à un processus aléatoire V est le processus aléatoire défini par Nn =
Rn (Vn ). ¨
Exemple 7.6 (Compte de Précédence) Comme premier exemple, considérons la séquence

01011010 d’une source binaire. Les comptes de précédence correspondants, avec la
convention que 0 a l’index initial par défaut -1 et que le symbole 1 a 0, sont alors :
vn Rn (0) Rn (1) Nn
0 2 1 2
1 1 2 2
0 2 1 2
1 1 2 2
1 2 1 1
0 3 1 3
1 1 2 2
0 2 1 2
Et la suite des précédences correspondante est donc 2,2,2,2,1,3,2,2.

Comme deuxième exemple, considérons la source V dont les symboles sont des mots de 2
bits : 00, 01, ... et la convention que 00 a la valeur index par défaut initiale -3, 01 -2, 10 -1
et 11 0.
Pour la séquence 11,01,00,10,01,11,01,01,00, la suite des précédences sera alors
1,4,6,5,3,5,2,1,6.
1
Elias-Willems utilise en fait le rang dans les comptes de précédence, qui est généralement plus petit que le
compte de précédence mais n’affecte par les résultats généraux présentés ici.
7.3. CODAGE DE SOURCES À MÉMOIRE 133
Évaluation 35
Considérant une source binaire avec des symboles à un bit et la convention que 0 a l’index par
défaut initial -1 et 1 0, quelle est la suite des précédences pour la séquence source correspon-
dante : 0001101000111 ?
Évaluation 36
Considérant une source binaire avec des symboles à un bit et la convention que 0 a l’index par
défaut initial -1 et 1 0, quelle est la séquence source correspondant à la suite des précédences :
1,3,1,3,1,3,2,2 ?
Voici maintenant une propriété qui nous sera utile pour apprécier l’efficacité du schéma d’Elias-
Willems.
Propriété 7.1 Si la source V est stationnaire et ergodique, alors le symbole v appa-

raît en moyenne chaque 1/pV (v) fois :
1
E [Ni |Vi = v] = E [Ri (v)] =
pV (v)
D ÉMONSTRATION Soit kn (v) le nombre d’occurrences de v dans une séquence de longueur

n de la source V . Le nombre d’intervalles entre deux répétitions consécutives de v est alors
kn (v) et la longueur totale de ces intervalles est n. L’intervalle moyen sur une séquence de
longueur n est donc n/kn (v). Quand n tend vers l’infini, pour des raisons d’ergodicité de la
source, kn (v) tend vers l’infini comme (n · pV (v)) et donc
n 1
E [Ri (v)] = lim =
n→∞ kn (v) pV (v)
Prouvons maintenant que le code d’Elias du compte de précédence effectue un code qui est
asymptotiquement efficace, c.-à-d. tendant asymptotiquement vers l’optimum théorique donné
par le théorème 7.4.
Théorème 7.5 La longueur moyenne E [|Z2 (N )|] d’un code d’Elias-Willems avec
des blocs de taille k d’une source stationnaire U vérifie :
E [|Z2 (N )|] c 2 ck (U ) + 1) + 1
h∞ (U ) ≤ ≤ hk (U ) + log2 (k · h
k k k
ck (X) = 1 H(X k ) (cf chapitre 3).

Rappel : h k 1
Corollaire 7.1 La longueur moyenne E [|Z2 (N )|] d’un code d’Elias-Willems avec
des blocs de taille k d’une source stationnaire U vérifie :
E [|Z2 (N )|]
lim = h∞ (U )
k→∞ k
D ÉMONSTRATION Quelle est la longueur moyenne d’un code d’Elias-Willems ?

X X
E [|Z2 (N )|] = pV (v) · E [|Z2 (Ni (Vi ))||Vi = v] = pV (v) · E [|Z2 (Ri (v))|]
v∈VV v∈VV
Mais, par l’équation 7.1 nous avons :
E [|Z2 (Ri (v))|] ≤ log2 (Ri (v)) + 2 log2 (log2 (Ri (v)) + 1) + 1
En utilisant l’inégalité de Jensen nous avons :

X
E [|Z2 (N )|] ≤ [log2 (E [Ri (v)]) + 2 log2 (log2 (E [Ri (v)]) + 1) + 1] · pV (v)
v∈VV
et de la propriété 7.1
X X
E [|Z2 (N )|] ≤ − pV (v) log2 (pV (v)) + 2 pV (v) log2 (1 − log2 (pV (v))) + 1
v∈VV v∈VV
c.-à-d., en utilisant encore une fois l’inégalité de Jensen :
E [|Z2 (N )|] ≤ H(V ) + 2 log2 (H(V ) + 1) + 1
ck (U ), donc :
Notez finalement que H(V ) = H(U (k) ) = H(U1 , ..., Uk ) = k · h
E [|Z2 (N )|] c 2 1
≤ hk (U ) + log2 (k · hk (U ) + 1) +
k k k
L’autre inégalité découle directement du thèorème 7.4. ¥
Évaluation 37
Comment est codée la séquence 100000101100 en utilisant le schéma d’Elias-Willems avec

k = 2 et la convention que 00 a la valeur index par défaut initiale -3, 01 -2, 10 -1 et 11 0 ?
7.3.3 Codages de Lempel-Ziv
L’idée du très populaire codage de Lempel-Ziv est assez similaire à celle du schéma de codage
d’Elias-Willems : en utilisant des idées similaires à celle de compte de précédence, il vise aussi
à être universel, c.-à-d. à bien fonctionner pour différents types de sources stationnaires sans
connaître précisément toutes leurs propriétés statistiques.
Il existe beaucoup de variantes de l’algorithme de Lempel-Ziv de base, utilisant des diction-

naires, le post-traitement et encore beaucoup d’autres améliorations. Parmi les variantes les
plus connues, on peut citer :
Nom Auteurs Méthode

LZ77 Lempel & Ziv 1 caractère et 1 paire de pointeurs de taille fixe
(1977) pas de dictionnaire
LZ78 Lempel & Ziv identique à LZ77 mais avec un dictionnaire
(1978) (pointeurs dans le dictionnaire)
LZSS Storer & Szymanski 1 pointeur de taille fixe ou 1 caractère (+ 1 bit
indicateur)
(1982) pas de dictionaire
LZW Welch seulement des pointeurs de taille fixe
(1984) alphabet inclus dans le dictionnaire
Ces algorithmes sont les algorithmes de compression les plus utilisés en pratique (p.ex. en zip,
compress, gzip, ...). Les raisons principales sont que ces algorithmes donnent de manière
efficace un bon taux de compression. Ces algorithmes sont en effet linéairement complexes et
n’exigent que peu de mémoire.
Dans cette section, nous nous concentrons sur le noyau de ces algorithmes de compression en
présentant le plus simple d’entre-eux : LZ77.
Pour ce code, les mots de code sont des uplets (i, j, u). i et j sont des nombres entiers et u est
un symbole de la source.
Le mot de code (i, j, u) représente une séquence de symboles qui peuvent être obtenus à partir
de la séquence courante
– en copiant j symboles en partant depuis i positions en arrière
– et en ajoutant le symbole u à la fin.
Si i est nul, j est ignoré.
Exemple 7.7 (Mot de code LZ77) Par exemple, si la séquence courante décodée est
10010, le mot de code (3, 2, 1) représente la séquence 011 : en copiant 2 symboles (01) en
partant de 3 positions en arrière (10|010), et en ajoutant 1 à la fin.
Si j est plus grand que i, la copie du caractère continue avec les caractères nouvellement
copiés (c.-à-d. que le tampon débutant à i positions en arrière est cyclique).
Par exemple, si la séquence courante décodée est 10010, le mot de code (3, 5, 1) représente
la séquence 010011 : en partant de trois positions en arrière (10|010) en copiant cinq
symboles : d’abord les trois symboles existant déjà en i = 3 positions en arrière (010), ce qui
donne 10010|010, et en continuant avec les deux caractères suivants, 01 depuis le caractère
nouvellement ajouté, ce qui donne 1001001001. Le décodage se termine finalement par
l’addition du 1 (dernier élément du mot de code) à la fin, ce qui donne 10010010011.
En résumé : 10010 + (3, 5, 1) = 10010010011.
Exemple 7.8 (Décodage LZ77) Voici un exemple montrant comment la séquence

(0,0,0) (0,0,1) (2,1,0) (3,2,1) (5,3,1) (1,6,0)
est décodée :
mot de code tampon cyclique séquence ajoutée séquence décodée complète

(0,0,0) – 0 0
(0,0,1) 0 1 01
(2,1,0) 01 0101... 00 0100
(3,2,1) 0 100 100100... 101 0100101
(5,3,1) 01 00101 00101... 0011 01001010011
(1,6,0) 0100101001 1 1111... 1111110 010010100111111110
Le résultat final est ainsi 010010100111111110.
L’algorithme de codage correspondant, qui utilise un tampon à fenêtre glissante pour se rappe-
ler du contexte passé, est le suivant :
1. chercher dans le contexte courant (c.-à-d. le début de la séquence restant à coder) la
séquence la plus courte qui n’est pas encore dans le tampon ;
2. retirer le dernier caractère u de cette séquence inobservée et chercher dans le tampon la
séquence correspondante la plus proche ;
3. émettre les position en arrière (i) et longueur (j) correspondantes, suivies par le dernier
caractère retiré (u)
4. mettre à jour le tampon (avec la séquence nouvellement codée) et retourner en 1 tant
qu’il reste une entrée.
Voici un exemple ce cet algorithme de codage :
Exemple 7.9 (Codage LZ77) Considérons le message 111111111101111011 à coder.

Au commencement, comme le tampon est vide, la première paire de pointeurs doit être (0,0)
et le caractère correspondant est le premier de la séquence. Le premier mot de code est alors
(0, 0, 1).
Le tampon est maintenant changé en 1. Avec la convention utilisée pour j > i, nous pou-
vons maintenant coder des séquences faites uniquement de 1 de n’importe quelle longueur.
Ainsi, la séquence considérée pour le codage, c.-à-d. la séquence la plus courte commençant
après la dernière séquence codée et ne se trouvant pas encore dans le tampon (cyclique), est
maintenant : 1111111110.
Cette séquence est codée en le mot de code (1, 9, 0) : aller 1 pas en arrière dans le tampon,
copier 9 caractères depuis le tampon (avec répétition comme 9 > 1, et ajouter la dernière
partie du mot de code, ici 0.
La portion du message codé jusqu’ici (et le tampon) est alors 11111111110, et la portion
restant à coder est 1111011.
Retour à l’étape 1 : quelle est la séquence la plus courte à coder qui n’est pas contenue dans
le tampon ?
A cette étape, c’est 1111011. En enlevant le dernier caractère (1), nous nous retrouvons
avec 111101 ce qui correspond dans le tampon courant à i = 5 et j = 6 (en utilisant à
nouveau l’aspect cyclique du tampon : i < j).
Le mot de code correspondant est ainsi (5, 6, 1).
En résumé : 111111111101111011 est codé en (0, 0, 1)(1, 9, 0)(5, 6, 1).
Évaluation 38
Comment la séquence 100000101100 est-elle codée en utilisant l’algorithme LZ77 ?
Évaluation 39
En quoi la séquence (0,0,0) (1,2,1) (2,5,0) est-elle décodée (en faisant l’hypothèse d’un codage
LZ77) ?
théorème de codage sans bruit de Shannon pour des codes sans préfixe d’une source sta-
tionnaire : hlog
∞ (U )
D ≤
E[LZ ]
k .
compte de précédences Rn (v) est le nombre de symboles reçus au temps n jusqu’à la der-
nière réception de v (avant n).
codes d’Elias-Willems codage d’Elias du compte de précédence.
algorithme de Lempel-Ziv LZ77 : utilise un tampon (cyclique) se rappelant la séquence
passée, code des séquences avec des mots de code consistant en une position en arrière
dans le tampon, une longueur et un caractère à ajouter en fin de la séquence actuelle.
code de longueur fixe : codage de segments de longueur variable de la source d’informa-

tions d’entrés avec des mots de code qui ont tous la même taille
ensemble propre : un ensemble complet de feuilles d’un arbre de codage (pas de feuille
inutile).
ensemble de Tunstall : un ensemble propre tel que chaque nœud de l’arbre de codage cor-
respondant soit au moins autant probable que n’importe laquelle de ses feuilles.
optimalité des ensembles de Tunstall : un ensemble propre maximise la longueur de mes-
sage codé moyenne si et seulement si c’est un ensemble de Tunstall.
n
algorithme de Tunstall : k = ⌊ DDZU −1
−1
⌋,M = 1 + k (DU − 1), prolonger k fois le nœud le
plus probable.
les codes d’Elias sont des codes binaires instantanés pour les entiers, dont la longueur est
(asymptotiquement) proche de l’optimum log2 (n).
Ces codes résultent de l’enchaînement d’un préfixe, fait du premier code d’Elias de la
longueur de la représentation binaire habituelle du nombre à coder, et d’un suffixe, fait
de la représentation binaire habituelle sans son bit le plus significatif.
théorème de codage sans bruit de Shannon pour des codes sans préfixe d’une source sta-
tionnaire : hlog
∞ (U )
D ≤
E[LZ ]
k .
compte de précédences Rn (v) est le nombre de symboles reçus au temps n jusqu’à la der-
nière réception de v (avant n).
codes d’Elias-Willems code d’Elias du compte de précédence.
algorithme de Lempel-Ziv LZ77 : utilise un tampon (cyclique) se rappelant la séquence
passée, code des séquences avec des mots de code constitué de : une position (en ar-
rière) dans le tampon, une longueur et un caractère à ajouter en fin de la séquence
actuelle.
En dépit de son importance fondamentale, le travail de Tunstall ne fut jamais publié dans la
littérature. La thèse de doctorat de Tunstall (A. Tunstall, « Synthesis of Noiseless Compression
Codes », Ph.D. thesis, Georgia Institute of Technology, Atlanta, GA, 1968), qui contient ce tra-
vail, resta non remarquée pendant de longues années avant de devenir familière aux théoriciens
de l’information.
Chapitre 8
Exercices du module I1
8.1 Codes de longueur fixe : codes de Tunstall
Exercice 8.1.1:
Soit un dé pipé de distribution de probabilités :
1 2 3 4 5 6
0.12 0.15 0.16 0.17 0.18 0.22
a– Avec un code de Tunstall binaire codant sur 4 bits, combien de séquences de ce dé peut-on
coder ? Lesquelles (c.-à-d, dessinez l’arbre de codage) ?
e– Coder la séquence « 1664 » à l’aide de ce codes.
8.2 Codage de séquences d’entiers positifs
Exercice 8.2.1:
Soit une source binaire U « à mémoire », stationnaire, de probabilité d’émission conditionnelle

vérifiant P (Un |U1 ... Un−1 ) = P (Un |Un−1 ) avec :
P (0|0) = p P (0|1) = 1 − p
(p < 1/3)
P (1|0) = 1 − p P (1|1) = p
et P (U1 = 0) = P (U1 = 1) = 0.5. Il s’agit donc d’une chaîne de Markov stationnaire.
139
140 CHAPITRE 8. EXERCICES DU MODULE I1
a– Calculer l’entropie d’un symbole quelconque la source (cela à un sens puisque la source
est stationnaire).
Calculer la longueur moyenne d’un code binaire par symbole de cette source (ne cher-
chez pas trop loin : ceci est vraiment trivial !).
b– Calculer l’entropie assymptotique de la source, c.-à-d.
H∞ (U ) = lim H(Un |U1 ... Un−1 )
n→∞
c– On envisage à présent un codage par blocs de taille 2. Calculer l’entropie de la source V2

consistant à regrouper par paquets de 2 bits les messages de U . Proposer un codage de
Huffman de V2 . Calculer sa longueur moyenne. Conclure.
d– Recommencer avec V3 , la source qui consiste
√
à regrouper par paquets de 3 bits les messages
3− 6
de U . On supposera ici que p < 3 .
e– On envisage à présent d’utiliser un code par compte de précédence par bloc de taille 2. Il est
pour cela nécessaire de convenir d’un message de référence pour le début des comptes
afin de pouvoir donner un compte de précédence aux premiers blocs du message. Posons
11001001 pour cette référence.
1. Donner la séquences des comptes de précédence pour le message
101010110101010101010101 de la source U
2. En donner son codage à l’aide du code de Elias Z2
3. Coder cette même séquence à l’aide des codes des deux questions (c) et (d).
4. Quel taux de compression peut-on espérer avec un tel code (compte de précédence
+ Elias Z2 ) en utilisant des blocs de taille L, c.-à-d. quelles inégalités vérifie la lon-
gueur moyenne du code divisée par la taille du bloc (L) ? (Autrement dit : trouver
un encadrement de E[lLZ ] en utilisant h(p) et L, où lZ est la longueur d’un mot de
code Z.)
8.3 Codage de sources à mémoire
Exercice 8.3.1:
L’exercice précédent illustre l’apport des techniques de codage par blocs pour des sources
« à mémoire ». Le problème de telles approches reste cependant le choix de la taille du bloc
qui, pour être optimal, reste tributaire de la connaissance de la source (c.-à-d. la connaissance
de P (Un |U1 ... Un−1 )). Il existe cependant de nombreuses techniques de compression, dites
« universelles », dont le taux de compression tant assymptotiquement vers H∞ (U ) sans pour
autant connaître les caractéristiques fines de la source1 . Une telle technique est l’algorithme
de Lempel-Ziv utilisé2 par exemple dans les programmes compress ou gzip. En voici le
principe :
a– La première étape consiste à découper le message à coder en sous-chaînes (en commençant
par la chaîne vide) de sorte à ne jamais répéter deux fois la même sous-chaîne et à
toujours créer la sous-chaîne la plus courte possible. Effectuer ce3 découpage sur le
message 0110100100100101011010.
1
Il faut cependant faire des hypothèses de stationnarité et d’ergodicité de la source.
2
avec divers raffinements. L’algorithme présenté ici est connu sous le nom LZ78.
3
car il est unique
b– En remarquant que chaque sous-chaîne ainsi obtenue est nécessairement la concaténation

d’une sous-chaîne déjà précédemment rencontrée et d’un seul bit (le dernier), on peut
représenter chaque sous-chaîne à l’aide d’un couple (pointeur vers la sous-chaîne pré-
cédente, bit ajouté). Le pointeur est en fait le numéro de la sous-chaîne dans l’ordre
dans lequel on l’a rencontrée (la sous-chaîne vide a pour numéro 0). Ainsi le mes-
sage 100110101101101100 se décompose en 1 0 01 10 101 1011 011 00
et donne donc suite à la numérotation des sous-chaînes suivante :
chaîne 1 0 01 10 101 1011 011 00
numéro 1 2 3 4 5 6 7 8
Donner la représentation sous forme de liste de couples de ce message.
c– La dernière étape consiste à représenter la liste de couples. Pour cela le pointeur est repré-
senté par le code binaire du numéro correspondant... ...sur combien de bits ? Puisqu’une
sous-chaîne en position p réfère toujours à une sous-chaîne précédente, on peut coder son
pointeur sur ⌈log p⌉ bits. Ainsi la séquence de couples (0,0) (1,1) (2,0) (3,1) (0,1) se
représentera (,0) (1,1) (10,0) (11,1) (000,1) et sera alors codée :0111001110001.
Coder les messages 11010010101001011010,
1111111111111111111110 et 1000011011100101110111.
d– Décoder le message 1001010101000100110111111010101000010101
Chapitre 9
Module C4 : Transmission
d’information en présence de bruit

Dans ce chapitre, nous présentons :
1. les bases du codage d’une source d’information discrète permettant de trans-
mettre correctement ses messages, même en présence de bruit ;
2. la façon dont une transmission bruitée peut être formalisée par la notion de
« canal » ;
3. les deux notions fondamentales régissant les transmissions en présence de
bruit : la « capacité de canal » et le « taux de transmission » ;
4. la limite fondamentale, universelle, à l’erreur de transmission dans le cas d’une
transmission bruitée.
Introduction
Lorsqu’on traite d’« information », l’un des objectifs principaux est de la transmettre de fa-
çon fiable. Dans ce contexte, « transmettre » signifie aussi bien « transmettre une information
d’un point à un autre », comme nous l’entendons généralement, que la « transmettre à travers
le temps » ; par exemple, pour la stocker quelque part (la mémoriser) puis la récupérer plus
tard. Dans les deux cas, cependant, la transmission de l’information peut rarement être accom-
plie de façon totalement fiable dans la vie réelle. Il existe toujours un risque de distorsion de
l’information transmise : du bruit sur la ligne, une fuite dans la mémoire ou le disque dur où
l’information est stockée, etc.
Quel effet le bruit a-t-il sur la transmission de messages ? Plusieurs situations sont possibles :
– il n’est jamais possible de transmettre des messages de façon fiable (trop de bruit) ;
– il est possible de transmettre des messages avec une probabilité d’erreur « raisonnable » ;
143
144 CHAPITRE 9. TRANSMISSION D’INFORMATION EN PRÉSENCE DE BRUIT
– il est possible de transmettre des messages avec une probabilité d’erreur aussi faible que l’on
veut (à l’aide de codes correcteurs).
L’objectif du présent chapitre est précisément d’étudier en quoi le codage peut aider à trans-
mettre l’information de façon fiable, même en présence de bruit pendant la transmission. L’idée
de base de tels codages est de tenter d’ajouter de la redondance au message codé. Ainsi, sa
transmission dans des conditions de bruit « raisonnables » conserve suffisamment d’informa-
tion intacte, de façon à ce que le destinataire soit en mesure de reconstituer le message original
sans distorsion.
Bien entendu, il est nécessaire de définir plus précisément les notions de « redondance suffi-
sante » et de « conditions de bruit raisonnables »; elles doivent même être quantifiées et reliées
l’une à l’autre. Cela se fait en formalisant tout d’abord la notion de « transmission bruitée »
par l’introduction de la notion de « canal de communication » (section 9.1).
Comme nous le verrons dans la section 9.3, les deux notions fondamentales régissant les trans-
missions en présence de bruit sont la capacité de canal et le taux de transmission des symboles
des messages. Ces notions sont également introduites dans la section 9.1.
Bruit
Message
Source reçu
Codeur Canal Decodeur
n
Ui z1i ... zni z 1 ... z U
{
{
Zi Z
Mot de code Mot de code
transmis reçu
F IG . 9.1 – Communication avec correction d’erreur à travers un canal bruité.
Le cadre général dans lequel se place ce chapitre est résumé en figure 9.1.
9.1 Canal de communication

Cette section présente la notion de canal de communication et sa principale caracté-
risation : la capacité.
Après l’avoir étudiée, vous devriez être en mesure de formaliser une communication
(c’est-à-dire de donner le canal correspondant) et de calculer sa capacité, du moins
dans les cas les plus simples.
Vous devriez également savoir ce qu’est un canal symétrique, et ce que cela implique
en ce qui concerne sa capacité.
Enfin, nous introduisons également la notion de taux de transmission.
9.1. CANAL DE COMMUNICATION 145
9.1.1 Canaux de communication
Exprimé en termes approximatifs, un canal de communication∗ (ou, plus brièvement, « canal »)

représente tout ce qui peut arriver aux messages transmis1 entre leur émission et leur réception.
La séquence d’entrée X1 , X2 , X3 , . . . (i.e. le message à transmettre) est entièrement et unique-
ment déterminée par la source. Mais la transmission détermine les probabilités conditionnelles
résultant de la séquence de sortie Y1 , Y2 , Y3 , . . . (i.e. le message reçu), connaissant cette sé-
quence d’entrée.
En termes mathématiques, le canal spécifie les probabilités conditionnelles des divers messages
qui peuvent être reçus, conditionnellement aux messages qui ont été émis; c’est-à-dire P (Y1 =
y1 , ..., Yn = yn |X1 = x1 , ..., Xn = xn ) pour tous les n et toutes les valeurs y1 , x1 , ..., yn , xn
possibles.
Définition 9.1 (Canal discret sans mémoire (DMC)) Le canal discret sans mé-
moire (DMC∗ ) est le type de canal de communication le plus simple. Formellement,
un DMC est défini par les trois objets suivants :
1. un alphabet d’entrée discret VX , dont les éléments représentent les symboles
possibles émis pour tous les messages d’entrée (la source X);
2. un alphabet de sortie discret VY , dont les éléments représentent les symboles
possibles reçus (séquence de sortie); et
3. pour chaque x ∈ VX , les distributions de probabilité conditionnelles pY |X=x
qui décrivent le comportement du canal de façon à ce que pour tout n =
1, 2, 3, . . . :
P (Yn = yn |X1 = x1 , . . . , Xn = xn , Y1 = y1 , . . . , Yn−1 = yn−1 )

= P (Y = yn |X = xn ), (9.1)
On appelle ces dernières les probabilités de transmission∗ du canal.
L’équation (9.1) est la formulation mathématique correspondant à la nature « sans mémoire »

du DMC : ce qui arrive au signal envoyé à la n-ième utilisation du canal est indépendant de ce
qui arrive lors des n − 1 utilisations précédentes.
Il faut également noter que (9.1) implique que tout DMC est indépendant du temps en ce sens
que la distribution de probabilité pYn |xn ne dépend pas de n.
Lorsque VX et VY sont finis, un DMC est très souvent spécifié par un diagramme où :
1. les nœuds de gauche indiquent l’alphabet d’entrée VX ;
2. les nœuds de droite indiquent l’alphabet de sortie VY ; et
3. un arc allant de xi à yj est dessiné avec l’étiquette de la probabilité conditionnelle
pY |X=xi (yj ) (sauf si cette probabilité est 0, auquel cas l’arc est simplement omis.)
Exemple 9.1 (Canal binaire symétrique) Le cas le plus simple (et non trivial) de DMC est
le canal binaire symétrique (BSC∗ ), pour lequel VX = VY = {0, 1} (« binaire ») et
pY |X=0 (1) = pY |X=1 (0)
1
La notion de message a été définie dans le chapitre 5.
(« symétrique »). Cette valeur p = pY |X=0 (1) = pY |X=1 (0) est appelée le taux d’erreur et
est le seul paramètre du BSC. En effet, pY |X=0 (0) = pY |X=1 (1) = 1 − p.
Un BSC est alors représenté par le diagramme suivant :
1−p
1 1
p
X p Y
0 1−p 0
Exemple 9.2 (Transmission bruitée via un canal binaire symétrique) Supposons que
nous voulions transmettre les 8 messages suivants : 000, 001, 010, 011, 100, 101, 110
et 111.
Supposons que le canal utilisé pour la transmission soit bruité, et qu’il modifie un symbole
sur dix, indépendamment de tout le reste; c’est-à-dire que chaque symbole a une probabilité
p = 0.1 d’être « changé » (0 en 1, et 1 en 0). Un tel canal est donc un BSC avec un taux
d’erreur égal à p = 0.1,
Quelle est alors la probabilité de transmettre correctement un de nos messages ?
Sans tenir compte de quel message est envoyé, cette probabilité est :
(1 − p)3 = 0.93 = 0.719
(qui correspond à la probabilité de transmettre 3 fois un bit sans erreur.)

Donc la probabilité de recevoir un message erroné est 0.281, soit 28%; ce qui est assez élevé!
Supposons à présent que nous décidions de coder chaque symbole du message par deux fois
lui-même :
message 000 001 010 011 100 ... 111

code 000000 000011 001100 001111 110000 ... 111111
Quelle est maintenant la probabilité d’avoir un message envoyé correctement ? De la même

façon que précédemment, cette probabilité vaut (1 − p)6 = 0.531.
Et la probabilité de recevoir un message erroné est à présent de 0.469... ... ce qui semble pire
qu’auparavant !
Cependant, quelle est la probabilité de recevoir un message erroné qui semble être valide;
c’est-à-dire quelle est la probabilité de recevoir un message erroné sans s’apercevoir qu’il est
faux ?
Ne pas détecter un message erroné signifie que deux symboles correspondants ont été chan-
gés. Par exemple, si nous envoyons 000000, mais que 110000 est reçu, il n’y a aucun
moyen de se rendre compte que des erreurs se sont produites. Cependant, si 010000 est
reçu, il est clair qu’au moins une erreur s’est produite (on peut alors, par exemple, redeman-
der la transmission du message.)
Ne pas détecter une erreur ne peut donc découler que de 2 changements (aux places corres-
pondantes) ou de 4 changements ou carrément, des 6 symboles.
¡¢
Quelle est la probabilité de changer 2 symboles ? Réponse : 62 p2 (1 − p)4 = 15 p2 (1 − p)4
¡3¢
Quelle est la probabilité de changer 2 symboles correspondants ? Seulement 1 p2 (1−p)4 =
3 p2 (1 − p)4 .
De la même façon, la probabilité de changer 4 symboles correspondants est 3 p4 (1 − p)2 , et
la probabilité de changer les six symboles est p6 .
Donc la probabilité de ne pas détecter une erreur est
3 p2 (1 − p)4 + 3 p4 (1 − p)2 + p6 = 0.020.
Ce qui est beaucoup plus petit ! Cela signifie que la probabilité de commettre une erreur à la
réception (c’est-à-dire de faire confiance à un message sans s’apercevoir qu’il est erroné) est
0.02, soit 2% seulement.
Conclusion : certains codages sont meilleurs que d’autres pour la transmission de messages
via un canal bruité .
Clarifions maintenant la situation où un DMC est utilisé sans retour∗ , c’est-à-dire lorsque la
distribution de probabilité des entrées ne dépend pas de la sortie. Plus formellement, on dit
qu’un DMC est « sans retour » lorsque :
pXn |x1 ,...,xn−1 ,y1 ,...,yn−1 = pXn |x1 ,...,xn−1 (9.2)
pour tout n = 1, 2, 3, . . . . Notez que (9.2) n’implique pas que nous choisissions chaque sym-
bole d’entrée indépendamment des symboles d’entrée précédents, mais simplement que nous
n’utilisons absolument pas les symboles de sortie précédents lorsque nous choisissons des sym-
boles d’entrée successifs (comme nous pourrions le faire si un canal d’information en retour
était disponible de la sortie à l’entrée du DMC).
Donnons à présent un résultat fondamental sur le DMC sans retour.
Théorème 9.1 Pour tout DMC sans retour, nous avons pour tout n ∈ N :
n
X
H(Y1 . . . Yn |X1 . . . Xn ) = H(Yi |Xi )
i=1
où X1 ...Xn représente une séquence d’entrée de longueur n et Y1 ...Yn la sortie cor-

respondante.
e-nnexe : Cascade de canaux
9.1.2 Capacité d’un canal
Le rôle d’un canal est de transmettre des messages (« information ») d’un point (l’entrée) à
un autre (la sortie). La capacité d’un canal∗ mesure précisément cette compétence : c’est la
quantité maximale d’information moyenne que la sortie du canal peut fournir sur l’entrée.
Souvenez-vous qu’un DMC est entièrement spécifié par les distributions de probabilité condi-
tionnelle pY |X=x (où X représente l’entrée du canal et Y la sortie). La distribution de probabi-
lité d’entrée pX (x) ne fait pas partie du canal, mais uniquement de la source d’entrée utilisée.
La capacité d’un canal est donc définie comme l’information mutuelle maximale I(X; Y ) qui
peut être obtenue parmi tous les choix possibles de pX (x). Plus formellement :
Définition 9.2 (Capacité d’un canal) La capacité C d’un canal discret sans mé-
moire est définie comme
C = max I(X; Y ), (9.3)
pX
où X représente l’entrée du canal et Y sa sortie. ¨
Nous verrons brièvement que cette définition est effectivement très utile pour l’étude des trans-
missions bruitées. Mais donnons tout d’abord un premier exemple.
Exemple 9.3 (Capacité d’un BSC) Quelle est la capacité C d’un BSC, comme défini dans
l’exemple 9.1?
Notez tout d’abord que par définition de l’information mutuelle,
³ ´
C = max H(Y ) − H(Y |X) .
pX
En outre, étant donné que dans le cas d’un BSC, P (Y 6= X) = p et P (Y = X) = 1 − p,

nous avons H(Y |X) = e h(p) = −p log(p) − (1 − p) log(1 − p), et par conséquent
³ ´
C = max H(Y ) − e h(p).
pX
puisqu’il ne dépend pas de pX . Par ailleurs, puisque Y est une variable aléatoire binaire,
nous avons (par le théorème 1.2) : H(Y ) ≤ log 2, c’est-à-dire H(Y ) ≤ 1 bit. Ce maximum
peut-il être atteint pour certains pX ? Oui, en effet : si X est distribuée uniformément, nous
avons pY (0) = p · pX (1) + (1 − p) · pX (0) = 0.5 p + 0.5 (1 − p) = 0.5; ce qui signifie
que Y est aussi distribuée uniformément, ce qui mène à H(Y ) = 1 bit. Par conséquent :
maxX H(Y ) = 1 bit et donc
C =1−e
h(p) (en bit).
Évaluation 40
Quelle est la capacité du « canal symétrique à perte » défini par le graphe suivant :
1−p
0 0
p
X (perte) Y
p
1 1
1−p
Est-ce (dans le cas le plus général):

1. C = 1 − e h(p) = 1 + p log p + (1 − p) log(1 − p),
2. C = 1 − p,
3. C = 1,
4. C = 1 + e
h(p) = 1 − p log p − (1 − p) log(1 − p),
5. ou C = 1 + p ?
9.1.3 Canal symétrique à l’entrée
Ici, nous considérons uniquement des DMC ayant un alphabet fini, c’est-à-dire un nombre fini
K de symboles d’entrée et un nombre fini J de symboles de sortie.
Définition 9.3 On dit qu’un tel DMC est symétrique à l’entrée si les distributions de
probabilité d’erreur sont© toutes les mêmesaªpour tous les symboles d’entrée; c’est-à-
dire que les ensembles pY |xi (y) : y ∈ VY sont indépendants de xi . ¨
a
à une permutation près
Exemple 9.4 (Canal symétrique à l’entrée)

aa
0 1/2
1/2 a 1/4
0 1/4 ba
1/2
1/2
X (perte) Y X b Y
1/2 1/2
1 1/4 bc
1/2
c 1/4
1 1/2
cc
(a) Un DMC symétrique en entrée (b)Un DMC symétrique en sortie
mais non symétrique en sortie. mais non symétrique en entrée.
Un BSC est symétrique à l’entrée. Celui de la figure (a) ci-dessus est également symétrique
à l’entrée, mais le canal de la figure (b) n’est pas symétrique à l’entrée.
Lemme 9.1 Pour un DMC symétrique à l’entrée, H(Y |X) est indépendant de la
distribution pX , et H(Y |X) = H(Y |xi ) pour tout xi ∈ VX .
D ÉMONSTRATION Il résulte de la définition d’un canal symétrique à l’entrée que

J
X
∀xi ∈ VX H(Y |X = xi ) = H0 = − pj log pj (9.4)
j=1
où {p1 , p2 , . . . , pJ } est l’ensemble des probabilités transition pY |xi (y), qui est indépendant
du symbole d’entrée xi . Par conséquent,
X X
H(Y |X) = pX (x)H(Y |X = x) = pX (x)H0 = H0
x x
Pour un DMC symétrique à l’entrée, trouver la probabilité d’entrée qui réalise la capacité (i.e.
atteint le maximum de )se réduit simplement à trouver la distribution d’entrée qui maximise
l’incertitude de la sortie.
Propriété 9.1 Pour un DMC symétrique à l’entrée, nous avons
C = max [H(Y )] − H0 (9.5)

PX
où H0 = H(Y |X = xi ) pour l’un des xi ∈ VX .
D ÉMONSTRATION Cette propriété découle directement de la définition 9.2 et du lemme 9.1.

¥
9.1.4 Canal symétrique en sortie
Un canal symétrique à l’entrée est un canal dans lequel les probabilités sortant de chaque
symbole d’entrée sont identiques. Nous considérons à présent des canaux ayant la propriété
que les probabilités entrant sur chaque symbole de sortie sont identiques.
Définition 9.4 (Canal symétrique

© en sortie) On ª dit qu’un DMC est symétrique en
P pY |x (yi ) : x ∈ VX sont indépendants de yi . Notez que
sortie lorsque les ensembles
dans ce cas, les sommes x pY |x (yi ) sont également indépendantes de yi .a ¨
a
Certains auteurs ont appelé cette propriété « faible symétrie en sortie ».
Exemple 9.5 (Canal symétrique en sortie) Tout BSC (voir exemple 9.1) est symétrique en
sortie. Le canal de l’exemple 9.4, figure (b), est symétrique en sortie, mais celui de la fi-
gure (a) ne l’est pas.
Lemme 9.2 Pour un DMC symétrique en sortie, une distribution de probabilité d’en-
trée uniforme (c’est-à-dire pX (xi ) est la même pour tout xi ) conduit à une distribu-
tion de probabilité de sortie uniforme (c’est-à-dire que pY (yi ) est la même pour tout
yi ).
D ÉMONSTRATION
X 1 X
pY (yj ) = pY |xi (yj )pX (xi ) = p (yj )
xi
|VX | x Y |xi
i
Mais puisque le DMC est symétrique en sortie, la somme de droite dans cette dernière équa-
tion est indépendante de yj . Donc pY est indépendant de yj ; c’est-à-dire qu’il est la distribu-
tion de probabilité uniforme. ¥
Il résulte directement du lemme 9.2 et du théorème 1.2 que
Propriété 9.2 Pour tout DMC symétrique en sortie (d’entrée X et de sortie Y ), nous
avons :
max H(Y ) = log |VY |. (9.6)
pX
9.1.5 Canal symétrique
Définition 9.5 (Canal symétrique) Un DMC est symétrique lorsqu’il est à la fois
symétrique en entrée et symétrique en sortie. ¨
Théorème 9.2 La capacité d’un canal symétrique (dont l’entrée est X et la sortie
Y ) est donnée par :
C = log |VY | − H0 (9.7)
où H0 = H(Y |X = xi ) pour n’importe lequel des symboles d’entrée xi ∈ VX .
D ÉMONSTRATION Le théorème ci-dessus est une conséquence immédiate des propriétés

(9.5) et (9.6). ¥
Exemple 9.6 Le BSC (voir exemple 9.1) est un canal pour lequel H0 = e
h(p) = −p log p −
(1 − p) log(1 − p). Ainsi,
CBSC = log 2 − e
h(p) = 1 − e
h(p) (en bit)
9.1.6 Taux de transmission
Définition 9.6 (Taux de transmission) Le taux de transmission (en base b) du code

d’une source discrète U de |VU | messages avec des mots de code de longueur fixe n
est défini par:
logb |VU |
Rb =
n
Notez que |VU | représente également le nombre de mots de code possibles (code non-singulier
déterministe).
En pratique, on utilise l’arité du code comme base b pour le logarithme dans le calcul du taux
de transmission.
Exemple 9.7 Le taux de transmission (binaire) du code utilisé dans l’exemple 9.2 est R =
log 8 3 1
6 = 6 = 2 . Cela semble raisonnable puisque ce code répète chaque message deux fois,
c’est-à-dire qu’il utilise deux fois les symboles émis à l’origine.
Évaluation 41
Sur un canal bruité, nous prévoyons d’utiliser un code consistant à tripler chaque symbole des
messages. Par exemple, a sera transmis aaa.
Quel est le taux de transmission R d’un tel code ?
(Si vous êtes perplexes au sujet de la base, choisissez pour cette dernière l’arité de la source,
c’est-à-dire le nombre de symboles différents que la source peut émettre.)
Canal : alphabets d’entrée et de sortie et probabilités de transmission (pY |X=x ).

DMC = Discrete Memoryless Channel (Canal discret sans mémoire).
Capacité de canal : C = maxpX I(X; Y )
logb |VU |
Taux de transmission d’un code : Rb = n
Capacité d’un canal symétrique à l’entrée : C = max [H(Y )] − H(Y |X = xi ) pour
PX
n’importe quel xi ∈ VX .
Capacité d’un canal symétrique : C = log |VY | − H(Y |X = xi ) pour n’importe quel
xi ∈ VX .
9.2 Quelques lemmes

Dans cette section, nous introduisons plusieurs résultats généraux que nous appli-
querons ultérieurement dans notre étude des canaux, mais qui ont aussi beaucoup
d’autres applications.
9.2.1 Lemme de l’utilisation multiple
Nous avons défini la capacité d’un canal comme étant la quantité maximale d’information que
la sortie du canal peut fournir sur l’entrée. Que peut-on dire si nous employons plusieurs fois
le même canal (comme ce devrait être le cas dans la vie réelle !) ?
Lemme 9.3 Si un DMC sans retour, de capacité C est utilisé n fois, nous avons :
I(X1 . . . Xn ; Y1 . . . Yn ) ≤ n C
où X1 ...Xn représente une séquence d’entrée de longueur n et Y1 ...Yn la sortie cor-

respondante.
9.2.2 Lemme du traitement des données
Ici, nous considérons la situation illustrée en figure 9.2, où plusieurs « processeurs » sont em-
ployés successivement. Les « processeurs » considérés ici sont des « boîtes noires » totalement
arbitraires. Ils peuvent être déterministes ou stochastiques. Ils peuvent même ne rien contenir
du tout. Tout ce que la figure 9.2 affirme, c’est qu’il n’y a pas de « chemin caché » par lequel
X peut affecter Z, c’est-à-dire que X ne peut affecter Z qu’indirectement à travers son effet
sur Y . En termes mathématiques, cette contrainte peut être exprimée ainsi :
pZ|x,y (z) = pZ|y (z) (9.8)
pour tout y tel que pY (y) 6= 0, ce qui signifie que lorsque y est donné, z n’est pas influencé
par x.
9.2. QUELQUES LEMMES 153
X Processeur Y Processeur Z
no. 1 no. 2
F IG . 9.2 – Situation conceptuelle pour le lemme de traitement des données.
Le lemme du traitement des données dit essentiellement que l’information ne peut être aug-
mentée d’aucune façon par un quelconque traitement (bien qu’elle puisse éventuellement être
mise sous une forme plus accessible !).
Lemme 9.4 (Lemme de traitement des données) Lorsque (9.8) est valable, nous
avons :
I(X; Z) ≤ I(X; Y ) (9.9)
et
I(X; Z) ≤ I(Y ; Z). (9.10)
9.2.3 Lemme de Fano
À présent, pour la première fois depuis le début de notre étude de la théorie de l’information,
nous introduisons la notion d’« erreurs ». Supposons que nous pensions à la variable aléatoire
b comme étant une estimation de la variable aléatoire U . Afin que cela ait un sens, U
U b doit
prendre les valeurs du même alphabet que U . Une erreur est alors simplement l’événement
b 6= U et la probabilité d’erreur, Pe , est donc
U
b 6= U ).
Pe = P (U (9.11)
Nous sommes maintenant prêts pour l’un des résultats les plus intéressants et les plus impor-
b ).
tants en théorie de l’information, et qui relie Pe à l’incertitude conditionnelle H(U |U
Lemme 9.5 (Lemme de Fano) Soient U et U b deux variables aléatoires D-aires

avec les mêmes valeurs. En dénotant par Pe la probabilité que U soit différent de
b , nous avons :
U
e b)
h(Pe ) + Pe log2 (D − 1) ≥ H(U |U (9.12)
b ) est exprimée en bits.
où l’incertitude H(U |U
Nous pouvons maintenant aborder l’interprétation du lemme de Fano. Tout d’abord, nous ob-
servons que la fonction à gauche de (9.12), esquissée en figure 9.3, est concave en Pe et est
positive pour tout Pe (0 < Pe ≤ 1) .
b ) est donnée, (9.12) spécifie implicitement une
Ainsi, lorsqu’une valeur positive de H(U |U
borne inférieure positive sur Pe .
b soient binaires (i.e., D = 2) et que H(U |U
Exemple 9.8 Supposons que U et U b) = 1
bit.
2
Alors (9.12) donne
e 1
h(Pe ) ≥
2
9.3. LE THÉORÈME DE CODAGE EN PRÉSENCE DE BRUIT 155
9.3 Le théorème de codage en présence de bruit

Cette section est le cœur de ce chapitre. Elle donne l’important « théorème de codage
bruité », qui explique sous quelles conditions une communication fiable est possible
ou non.
Après avoir étudié cette section, vous devriez être en mesure de décider :
1. quelle est la vitesse de transmission maximale que vous pouvez utiliser sur un
canal de communication bruité afin d’être en mesure de construire une com-
munication fiable via ce canal (à l’aide des codes correcteurs d’erreurs);
2. quelle est la quantité minimale d’erreurs que vous êtes sûr de commettre si
vous transmettez l’information plus vite que ce maximum.
9.3.1 Codage par répétition
Le rôle de cette section est de donner un exemple concret de codes correcteurs d’erreurs très
simples (voire naïfs). Des exemples plus réalistes seront présentés et étudiés dans le cha-
pitre 11.
Il y a donc peu de choses à apprendre dans cette section, si ce n’est que le codage naïf par
répétition n’est pas très bon et que d’autres codes plus appropriés devraient être considérés en
pratique.
Les codes binaires à répétition sont des codes Rk pour lesquels chaque symbole d’entrée
(binaire) est répété n = 2 k + 1 fois (k > 1). Par exemple, le code R1 a été employé dans
l’exemple 9.2. Nous ne considérons qu’un nombre impair de répétitions car le décodage de
tels codes se fait par la majorité. Nous évitons donc le non-déterminisme qu’un nombre pair de
répétitions pourrait introduire (dans des cas où le mot de code reçu contient autant de 0s que
de 1s).
Avec de tels codes, la probabilité d’une mauvaise décision concernant le décodage d’un sym-
bole est la probabilité qu’au moins k + 1 erreurs se sont produites sur le bloc correspondant.
Considérons le cas où un tel code est employé sur un BSC. Dans ce cas, le nombre d’erreurs
commises par le canal suit une distribution binomiale de paramètres (n, p). Par conséquent, le
nombre d’erreurs moyen au niveau de la transmission de symboles de mots de code est n p.
Pour p < 0.5, ce nombre moyen est inférieur à k + 0.5, donc la probabilité qu’au moins k + 1
erreurs se soient produites sur un mot de code (soit un bloc de codage), tend à être négligeable
quand k (et donc n) tend vers l’infini. En d’autres termes, la probabilité que l’on prenne une
mauvaise décision en décodant devient négligeable à mesure que le nombre de répétitions
augmente (et donc aussi la longueur des mots de code). Nous pouvons donc compenser, à un
degré aussi fin que l’on veut, la perte due au bruit sur le canal en choisissant un nombre de
répétitions assez grand.
Cependant, dans ce cas, le prix à payer est très élevé en termes d’efficacité. En effet, le taux de
transmission d’un tel code est n1 ... ...qui tend aussi vers 0 lorsque n tend vers l’infini ! Pour n
grand, cela devient assurément un taux de transmission inacceptablement bas.
L’importance du théorème de codage bruité est précisément qu’il garantit pour tout taux de
transmission donné au-dessous de la capacité l’existence de codes corrigeant suffisamment
d’événements. Le taux de transmission peut être fixé a priori et n’a pas besoin d’être ridi-
culement petit comme dans l’exemple des codes par répétition. Il faut seulement qu’il soit
au-dessous de la capacité du canal.
e-nnexe : Codes par répétition sur un BSC
Évaluation 42
Sur un BSC de probabilité d’erreur p, nous envisageons d’utiliser le code par répétition R1
consistant à tripler chaque symbole des messages. Le décodage est fait à la majorité dans le
bloc reçu.
En fonction de p, quelle est la probabilité Pb d’erreur par bit en sortie pour un tel système de
communication ?
1. p2 − p3
2. p2
3. 3p2 − 2p3
4. 2p2 − 3p3
5. p3
9.3.2 La partie réciproque du théorème de codage en présence de bruit pour un

DMC sans retour
Dans cette section, nous montrons qu’il est impossible de transmettre de l’information de façon
fiable via un DMC à un taux de transmission supérieur à la capacité de ce DMC. Sans perte
de généralité, nous supposons que l’« information » à transmettre est la sortie d’une source
binaire symétrique (BSS∗ ), pour « Binary Symmetric Source », qui est une source binaire sans
mémoire telle que P (0) = P (1) = 21 . Ici, nous considérons le cas où le DMC est sans retour
(voir figure 9.1).
Donnons maintenant un résultat important (introduit par C. Shannon) sur les transmissions via
un tel canal.
Théorème 9.3 (Partie réciproque du théorème de codage en présence de bruit)

Si une source binaire symétrique est utilisée à un taux de transmission R sur un
DMC sans retour, de capacité C, et si R > C, alors Pb , la probabilité d’erreur par
bit en sortie, vérifie : µ ¶
e −1 C
Pb ≥ h 1− , (9.13)
R
−1
où e
h (x) = min{p : −p log(p) − (1 − p) log(1 − p) = x}.
−1
Ici, nous avons écrit e
h pour la fonction inverse de l’entropie d’une variable aléatoire binaire.
−1
Elle est définie par e
h (x) = min{p : −p log(p) − (1 − p) log(1 − p) = x}, où le minimum
est sélectionné de sorte à rendre cet inverse unique (voir figure 9.4).
Une conséquence importante de ce théorème est que chaque fois que R > C, (9.13) spécifiera
une borne inférieure positive sur la probabilité Pb d’erreur par bit de sortie qu’aucun code
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
−1
F IG . 9.4 – La fonction e
h , fonction inverse de l’entropie d’une variable binaire, définie par
−1
e
h (x) = min{p : −p log(p) − (1 − p) log(1 − p) = x}.
correcteur, aussi complexe soit-il, ne pourra réduire. En clair : il est impossible de transmettre
des informations de façon fiable à un taux supérieur à la capacité du canal.
Avant d’examiner la démonstration du théorème, donnons un exemple de son utilisation.
Exemple 9.9 (Partie réciproque du théorème de codage en présence de bruit)

Supposons que nous utilisions un DMC de capacité C = 41 bit pour transmettre des
messages provenant d’une source binaire symétrique. Si nous transmettons à un taux R = 12 ,
alors (9.13) nous donne une erreur d’au moins 11%:
µ ¶
e −1 1
Pb ≥ h 1− = .11.
2
Cela signifie qu’au moins 11% des symboles binaires ne seront pas transmis correctement.
(même après décodage)
D ÉMONSTRATION Nous voulons montrer que lorsque R > C, il y a une borne inférieure
positive sur Pb qu’aucune façon de coder ne pourra dépasser.
Soit PB la probabilité d’erreur par mot :
m
X
b=
PB = P (U 6 U) = bi 6= Ui )
P (U
i=1
où m est la longueur du message d’entrée.

A noter que :
1
PB ≤ Pb ≤ PB ≤ mPb (9.14)
m
(on a en effet PB = 1 − (1 − Pb )m et Pb = 1 − (1 − PB )1/m ).
Par l’utilisation du lemme de Fano, nous avons, dans le cas binaire considéré ici :
e
h(PB ) = e b 6= U )) ≥ H(Ui |Ubi )
h(P (U
En outre, puisque e
h(x) est concave en x (pour 0 ≤ x ≤ 1) et que e
h(0) = 0 :
µ ¶
1 e e 1
h(PB ) ≤ h PB . (9.15)
m m
Et comme e
h est croissante sur [0, 0.5] :
1 e
h(PB ) ≤ e
h(Pb )
m
Nous avons donc à ce stade :

e 1 b ).
h(Pb ) ≥ H(U |U
m
Par ailleurs:
b ) = H(U ) − I(U ; U
H(U |U b)
b)
= m − I(U ; U
puisque dans le cas où la source d’entrée U est une BSS, H(U ) = H(U (1) . . . U (m) ) =
log 2m = m .
b) ?
Qu’en est-il de I(U ; U
Si nous prenons pour « processeur 1 » et « processeur 2 » de la figure 9.2 respectivement le
« codeur » et le « canal » de la figure 9.1, en utilisant le lemme du traitement des données,
nous obtenons :
b ) ≤ I(Z; U
I(U ; U b) (9.16)
Prenons ensuite pour « processeur 1 » et « processeur 2 » le « codeur » et le « canal » de la

figure 9.1. En utilisant encore une fois le lemme du traitement des données, nous concluons
que :
I(Z; U b ) ≤ I(Z; Z).
b (9.17)
En combinant (9.16) et (9.17), nous obtenons alors l’inégalité suivante :

b ) ≤ I(Z; Z).
I(U ; U b
qui, combinée au lemme 9.3, donne (utilisation de n symboles : les n caractères de Z) :

b) ≤ n C
I(U ; U (9.18)
Finalement, nous pouvons conclure que

b) ≥ m − n C
H(U |U
et donc
e n
h(Pb ) ≥ 1 − C
m
c’est-à-dire, par définition du taux de transmission R:
e C
h(Pb ) ≥ 1 −
R
Évaluation 43
Sur un DMC sans retour de capacité C, nous voulons transmettre un message avec une proba-
bilité d’erreur par bit Pb inférieure à une valeur donnée Pb max ∈]0, 12 [.
Nous ne savons pas encore quel type de code sera utilisé. Cependant, nous souhaitons déter-
miner le taux de transmission maximal Rmax que nous pouvons utiliser sur ce canal (et qui soit
compatible avec Pb ≤ Pb max ).
Quel est Rmax en termes de C et Pbmax ?
1. C
−1
2. e
h (Pb max )
3. C − e
h(Pb max )
C
4.
(1 − e
h(Pb max ))
1
5.
(C − h−1 (Pb max ))
−1
6. e
h (1 − C/Pb max )
9.3.3 Le théorème de codage en présence de bruit pour un DMC
Jusqu’à présent, nous avons vu qu’il est impossible d’avoir une erreur de transmission au-
dessous d’un certain niveau si le taux de transmission R est plus grand que la capacité du canal.
Nous étudions maintenant ce qui se passe lorsque nous souhaitons transmettre les messages
d’une BSS sur une DMC à un taux inférieur à sa capacité.
Théorème 9.4 (Théorème de codage en présence de bruit pour une DMC)

Considérons la transmission de messages au taux R sur un DMC sans retour de
capacité C. Pour tout R < C et tout ε > 0, il existe un code (correcteur d’erreurs)
dont le taux est R et tel que la probabilité d’erreur par bit en sortie Pb < ε.
D’après ce théorème important, en choisissant un moyen aproprié de coder l’information sur

un canal, on peut atteindre toute probabilité d’erreur aussi faible que l’on puisse espérer.
zi Z
zj
zk
F IG . 9.5 – Exemple d’erreur de décodage dans la structure de codage aléatoire : zi a été envoyé,
zb a été reçu et sera décodé ici en zj .
D ÉMONSTRATION Au niveau de ce cours d’introduction, par souci de simplicité, nous ne

démontrons le théorème que dans le cas d’un BSC. Ici, la démonstration sera constructive en
ce sens que nous élaborons véritablement un code vérifiant le théorème.
La démonstration générale du théorème de Shannon s’étend aux DMC avec alphabets d’en-
trée et de sortie arbitraires, et une capacité de canal arbitraire. L’idée-clé de la démonstration
générale est la même, à savoir de coder des messages par des mots choisis au hasard et de
décoder à l’aide de la décision « mot de code le plus proche ». Les difficultés dans la démons-
tration sont causées principalement par la forme générale de la capacité de canal lorsque ce
n’est pas un BSC. Les étudiants intéressés par cette question trouveront des démonstrations
complètes du cas général dans [1] ou dans [6].
Effectuons maintenant la démonstration du cas d’un BSC. En voici l’esquisse :
1. Étant donnés R et ε, choisir la longueur de mot de code appropriée n et le nombre de
mots de code M = 2R n .
2. Choisir ensuite les M mots de code z1 , ..., zM au hasard (comme vecteurs binaires
de longueur n), sans répétition. Si VU , le nombre de messages binaires possibles à
transmettre est supérieur à M , alors chaque message d’entrée se divisera en fragments
de n symboles au plus, qui seront codés séparément (par l’un des mots de code zi ).
3. Calculer le « seuil de décodage » r. Ceci correspond en fait au nombre maximal d’er-
reurs de transmission que le code peut corriger.
4. Utiliser la procédure de décodage suivante :
z , zi ) ≤ r, décoder zb en zi .
– s’il existe un et un seul mot de code zi tel que d(b
Ici, zb représente le message reçu après la transmission, c’est-à-dire à la sortie du
canal, et d(x, y) est la distance de Hamming entre deux messages binaires, c’est-à-
dire le nombre de symboles différents entre x et y.
– autrement, décodez comme z1 .
Un tel système de codage (appelé « codage aléatoire ») suffit à assurer Pb < ε (à condition
que le bon n ait été choisi).
Soyons maintenant plus précis et entrons dans les détails.
Souvenez-vous tout d’abord que la capacité d’un BSC est C = 1 − e h(p), où p est la
probabilité d’erreur du canal et où e
h(x) est l’entropie d’une variable aléatoire binaire :
e
h(x) = −x log x − (1 − x) log(1 − x).
Puisque 0 < R < C, nous avons 1 > 1 − R > e
h(p), et par conséquent :
∃λ, 0.5 ≥ λ > p, tel que R < 1 − e

h(λ)
comme illustré sur cette figure :
~
h(x)
1
1−R
~
h(p)
0 1111
0000 x
p ~
h−1(1−R) 0.5
Pour un tel λ, nous avons :

· ¸
p (1 − p) n(R+e
h(λ)−1)
lim + 2 =0
n→∞ n (λ − p)2
puisque R + e
h(λ) − 1 < 0.
Donc pour tout ε > 0 donné, il existe n0 tel que
p (1 − p) e
∀n ≥ n0 2
+ 2n (R+h(λ)−1) ≤ ε
n · (λ − p)
Pour des raisons techniques qui seront plus claires par la suite, nous avons également besoin
d’avoir n tel que ⌊λ n⌋ = max {q ∈ N : q ≤ λ n} > n p. C’est le cas à condition que n >
1
n1 = (λ−p) .
En résumé, jusqu’ici, nous sommes parvenus au résultat suivant :
∀p ∈ [0, 0.5[ ∀R, 0 < R < 1 − e

h(p), ∀ε > 0,
³ −1 p (1 − p) e
∃n ∈ N ∃λ ∈ (e h (1 − R), p) tel que + 2n (R+h(λ)−1) ≤ ε
n · (λ − p)2
´
et ⌊λ n⌋ > n p
En fait, ceci est vrai pour tout n > max {n0 , n1 } définis ci-dessus.
Nous avons donc trouvé l’une des « longueurs de mots de code appropriées n ». Procé-
dons alors comme expliqué au début avec M = 2n R mots de code et r = ⌊λ n⌋ =
max {m ∈ N : m ≤ λ n}. Dans ce schéma de codage, pour un mot de code zi , une erreur
se produit lorsque (voir figure 9.5)
1– plus de r erreurs de transmission se sont produites : d(b
z , zi ) > r
ou
2– a) d(bz , zi ) ≤ r
et
b) ∃z ∈ C, z 6= zi : d(b z , z) ≤ r
et
c) i 6= 1
où C = {z1 , ..., zM } représente le code.
Par conséquent, la probabilité Perr (zi ) qu’un mot de code donné zi ne soit pas transmis cor-
rectement (décodage inclus) est borné par
Perr (zi ) = P (cas 1) + P (cas 2) ≤ P (d(b

z , zi ) > r) + P (∃z ∈ C \ {zi } : d(b
z , z) ≤ r)
Trouvons maintenant des limites supérieures à ces deux termes.

d(b
z , zi ) est le nombre d’erreurs de transmission à la sortie du BSC (c’est-à-dire avant le
décodage).
¡n¢ kC’est une variable aléatoire binomiale de distribution de probabilité P (d(b
z , zi ) =
k) = k p (1 − p) n−k . Ainsi, sa moyenne et sa variance sont respectivement :
E[d(b
z , zi )] = n p z , zi )) = n p (1 − p)
var(d(b
Alors, par l’inégalité de Chebyshev, nous avons (puisque r > n p)2 :
n p (1 − p)
z , zi ) − n p| ≥ r − n p) ≤
P (|d(b
(r − n p)2
Par conséquent :
z , zi ) > r) ≤ P (d(b
P (d(b z , zi ) ≥ r) = P (d(b
z , zi ) − n p ≥ r − n p)
≤ P (|d(b
z , zi ) − n p| ≥ r − n p)
n p (1 − p)
≤ (9.19)
(r − n p)2
Pour le second terme (P (∃z ∈ C \ {zi } : d(b

z , z) ≤ r)), nous avons :
P (∃z ∈ C \ {zi } : d(b

z , z) ≤ r)
z , z1 ) ≤ r ou ... ou d(b
= P (d(b z , zi−1 ) ≤ r ou d(b z , zi+1 ) ≤ r ou ... ou d(b
z , zM ) ≤ r)
X
≤ z , z) ≤ r) = (M − 1) · P (d(b
P (d(b z , z) ≤ r)
z∈C\{zi }
puisqu’il y a M − 1 mots de code z tels que z 6= zi .

En outre, pour un z ∈ C donné, le nombre de zb possibles tels que d(b
z , z) = k est égal au
nombre de messages binaires de longueur n qui diffèrent de z dans k positions exactement.
¡ ¢ n!
Ce nombre est donc nk =
k ! (n − k) !
z , z) ≤ r est égal à
Par conséquent, le nombre total de zb possibles tels que d(b
r µ ¶
X n
k
k=0
et donc
r µ ¶
1 X n
z , z) ≤ r) = n
P (d(b
2 k
k=0
Nous obtenons finalement :

r µ ¶
M −1X n
P (∃z ∈ C \ {zi } : d(b
z , z) ≤ r) ≤
2n k
k=0
En outre, comme nous allons le montrer à la toute fin de cette démonstration, nous avons
pour tout 0 ≤ r ≤ n2 :
Xr µ ¶
n e r
≤ 2n h( n ) ,
k
k=0
n
donc (souvenez-vous que M = 2nR et que r ≤ 2 puisque λ < 0.5) nous avons trouvé,
finalement :
2nR − 1 n eh( r )
P (∃z ∈ C \ {zi } : d(b
z , z) ≤ r) ≤ 2 n
2n
e r
≤ 2n(R+h( n )−1) (9.20)
À présent, en regroupant les équations (9.19) et (9.20), nous obtenons :
n p (1 − p) e r
Perr (zi ) ≤ + 2n(R+h( n )−1)
(r − n p)2
ce qui, par les choix initiaux de r et n, est plus petit que ε.

1
Pour conclure la démonstration, nous devons simplement noter que Pb = n Perr (zi ) ≤
Perr (zi ) (pour tout i).
La seule étape manquante dans la démonstration ci-dessus est la démonstration du résultat
technique suivant :
r µ ¶
X
n n e r
∀n ∈ N ∀r ∈ N, 0 ≤ r ≤ , ≤ 2n h( n )
2 k
k=0
ce que nous faisons maintenant.
r µ ¶
X X n µ ¶
n n
= δ(k − r)
k k
k=0 k=0
½
1 si t ≤ 0
où δ(t) =
0 autrement
Ainsi, pour tout 0 < x ≤ 1 : δ(t) ≤ xt , et par conséquent :

r µ ¶
X n µ ¶
X
n n
≤ xk−r
k k
k=0 k=0
r µ ¶
X n (1 + x)n
i.e. ≤
k xr
k=0
r
ce qui est vrai en particulier pour x = n−r , avec r ≤ n/2:
r µ ¶
X r n
n (1 + n−r )
≤ r r
k ( n−r )
k=0
r µ ¶
X n r r
i.e. ≤ 2n·log(1+ n−r )−r·log( n−r )
k
k=0
r r
Mais : n · log(1 + ) − r · log( )
µ n − r n ¶− r
r
1 r n
= n · log( ) − log( )
1 − nr n 1 − nr
³ r r r r ´
= n · − log − (1 − ) log(1 − )
n n n n
e )r
= n · h(
n
ce qui conclut la démonstration. ¥
Évaluation 44
Considérons ici l’utilisation d’un BSC de probabilité d’erreur p (dont la capacité est donc
C = 1−e h(p)). Dans les cas suivants, dites si un code remplissant les conditions demandées
R et Pb pourrait être construit :
canal p 3% 6%
C 0.807 0.673
code R 2/3 3/4 9/10 2/3 3/4 9/10
Pb (en %) 1 2.2 1 2.2 1 2.2 1 2.2 1 2.2 1 2.2
existe ?
Théorème de Shannon en présence de bruit : Pour tout ε > 0 et tout R < C, C étant la
capacité d’un canal discret sans mémoire, il existe un code dont le taux de transmission
est R et dont la probabilité d’erreur par bit en sortie Pb est au-dessous de ε.
Inversement, tous les codes pour lesquels le taux de transmission est au-dessus de la
−1 ¡ ¢
capacité du canal ont une probabilité Pb supérieure à e h 1− CR .
Canal : alphabets d’entrée et de sortie, probabilités de transmission (pY |X=x ).

DMC = Discrete Memoryless Channel (Canal discret sans mémoire).
Capacité du canal : C = maxpX I(X; Y )
logb |VU |
Code/Taux de transmission : Rb = n
Capacité de canaux symétriques à l’entrée : C = max [H(Y )] − H(Y |X = xi ) pour
PX
n’importe quel xi ∈ VX .
Capacité de canaux symétriques : C = log |VY | − H(Y |X = xi ) pour n’importe quel
xi ∈ VX .
Lemme du traitement des données : pZ|x,y (z) = pZ|y (z) =⇒ I(X; Z) ≤
I(X; Y ) et I(X; Z) ≤ I(Y ; Z)
Lemme de Fano : e b)
h(Pe ) + Pe log2 (|VU | − 1) ≥ H(U |U
Théorème de Shannon en présence de bruit : Pour tout ε > 0 et tout R < C, C étant la
capacité d’un DMC, il existe un code dont le taux de transmission est R et dont la
probabilité d’erreur par bit en sortie Pb est au-dessous de ε.
Inversement, tous les codes dont le taux de transmission est au-dessus de la capacité
−1 ¡ ¢
de canal ont une probabilité d’erreur par bit en sortie Pb supérieure à e
h 1− C
R .
Ce théorème fut une véritable « bombe » lors de sa publication dans l’article de C. Shannon
en 1948 [9]. Avant cela, on pensait généralement que pour établir des communications plus
fiables, il était nécessaire de réduire le taux de transmission (ou, ce qui est équivalent, d’aug-
menter le « rapport signal/bruit », comme les ingénieurs l’auraient dit en 1947). Shannon a
dissipé ces mythes en montrant qu’à condition que le taux de transmission soit au-dessous de
la capacité de canal, on pouvait augmenter la fiabilité en augmentant la complexité du système
de codage, sans changer le rapport signal/bruit.
La première démonstration rigoureuse du théorème de Shannon en présence de bruit est due à
Feinstein, en 1954 [4]. Une démonstration plus simple employant le codage aléatoire tel que
présenté ici fut publiée par Gallager en 1965 [5]. La partie réciproque du théorème fut prouvée
par Fano en 1952, et publiée dans ses notes de cours.
Le théorème de codage en présence de bruit manque de considérations pratiques car il ne

fournit pas de moyens concrets de construire de bons codes efficaces. Par exemple, aucune
indication de la taille que les mots de code doivent atteindre pour un ε donné ; c’est-à-dire à
quel point le codeur et le décodeur doivent être complexes pour garantir une certaine fiabilité.
C’est la raison pour laquelle la « théorie du codage » est devenue un domaine si important : en
effet, c’est un véritable défi que de trouver de bons codes correcteurs d’erreurs, « bons » dans
le sens où la probabilité d’erreur est basse mais le taux de transmission est haut. Certains de
ces codes seront présentés dans le chapitre 11.
Chapitre 10
10.1 Canaux de communication
Exercice 10.1.1:
Considérons le canal défini par le graphe suivant (où λ représente le message vide, où p est la
probabilité d’erreur et q la probabilité de perte):
1−p−q
0 0
q
p
p λ
q
1 1−p−q 1
a– Démontrez que ce canal est symétrique à l’entrée et non symétrique en sortie.

b– Calculez sa capacité C en fonction de p et q?.
c– Quelle est la valeur de C lorsque p est 0? Et lorsque q est 0?
Exercice 10.1.2:
a– Démontrez que la mise en cascade (les uns après les autres) d’un nombre quelconque de
BSC, même différents, mène finalement à un BSC.
b– Dans le cas spécial où le même BSC (ayant une probabilité d’erreur p) est cascaded N fois,
quelle relation de récurrence la probabilité d’erreur obtenue PN vérifie-t-elle ?
167
c– Supposons que QN soit QN = 1 − 2 PN . Exprimez QN en tant que fonction de p. Dérivez-

en la valeur de PN en fonction de p et N .
d– Quelle est la capacité de canal obtenue ? Montrez que cette capacité tend vers 0 (pour
p < 1) comme N tend vers l’infini.
Exercice 10.1.3:
Quelle est la capacité d’un canal ternaire (c’est-à-dire dont les alphabets d’entrée et de sortie
ont 3 symboles différents), the transmission probability matrix is:
 
1 0 0
M =  0 2/3 1/3 
0 1/3 2/3
(c’est-à-dire Mi j = pY |X=i (j))
Exercice 10.1.4:
Considérons deux DMC de capacités respectives C1 et C2 et avec des probabilités de trans-

mission P (y1 |x1 ) et P (y2 |x2 ) respectivement. Ces deux canaux sont employés en parallèle
d’après le schéma suivant :
 
 x1 C1 y1 
X Y

x2 C2 y2 
a– En supposant que les deux sources X1 et X2 soient indépendantes et que le canal résultant
vérifie P (Y |X) = P (y1 |x1 ) · P (y2 |x2 ) (forte supposition d’indépendance1 ), calculez la
capacité de canal résultante.
b– Et si nous considérions une seule source sans mémoire U et utilisions le canal en envoyant
un symbole sur un canal, puis le suivant sur le second canal, etc..; c’est-à-dire si nous
prenions X1 = U2 n et X2 = U2 n+1 ?
Exercice 10.1.5:
Considérons un canal binaire (c’est-à-dire que les alphabets d’entrée et de sortie sont binaires)
mais non symétrique (par exemple avec une “fuite de masse”, c’est-à-dire une plus grande
probabilité de produire 0 que 1).
1
Notez que ce n’est pas le cas en général : deux variables aléatoires indépendantes ne sont pas toujours indé-
pendantes d’après une troisième !
10.1. CANAUX DE COMMUNICATION 169
Soit p la probabilité d’erreur dans le cas de la transmission d’un 1 et q la probabilité d’erreur

dans le cas de la transmission d’un 0 :
p = P (Y = 0|X = 1) et q = P (Y = 1|X = 0)
où X dénote l’entrée du canal et Y sa sortie.

Let further s be s = P (X = 0).
a– Calculez H(Y |X). Il serait sans doute utile d’introduire α = e h(q) − eh(p), où e
h(x) =
−x log x − (1 − x) log(1 − x).
b– Calculez H(Y ). Il serait utile d’introduire β = 1 − p − q et r = β · s + p.
c– Calculez la capacité d’un tel canal en fonction de γ = α/β et p. Notez que
de
h(r) 1−r
= β log2
ds r
où r = β · s + p.
d– La capacité d’un canal binaire symétrique (avec la probabilité d’erreur p) est 1 − e
h(p).
Trouvez ce résultat d’après votre calcul précédent.
Exercice 10.1.6:
Considérons un BSC dont la probabilité d’erreur varie dans le temps :
1 − pi
0 0
pi
pi
1 1
1 − pi
Supposons en outre que la probabilité d’erreur soit indépendante des messages transmis et donc
que les sorties Yi du canal soient indépendantes conditionnellement à la séquence d’entrée
X1 , ..., Xn :
n
Y
P (Y = (y1 , ..., yn )|X = (x1 , ..., xn )) = P (Yi = yi |Xi = xi )
i=1
Enfin, supposons que X soit une source sans mémoire, c’est-à-dire que les entrées Xi soient
indépendantes.
a– Quelle est la capacité de canal Cn pour des messages de taille n?

b– Quelle est la capacité (time) average, c’est-à-dire Cn /n?
10.2 Théorème de codage en présence de bruit
Exercice 10.2.1:
Cet exercice résume une partie des control questions du module C4.
Considérons un DMC ayant des alphabets d’entrée et de sortie binaires, et ayant une distri-
bution de probabilité conditionnelle définie par P (Y = y|X = x) = p si x 6= y (et donc
P (Y = y|X = x) = 1 − p si x = y).
a– Quelle est la capacité de ce canal (en fonction de p)?
Sur ce canal, nous prévoyons d’employer le code R3 qui consiste à tripler chaque symbole
d’entrée. Par exemple, 0 est codé 000. Le décodage se fait à la majorité : par exemple, 010
est décodé 0, et 110 1.
b– Quel est le taux de transmission R du code R3 ?
c– Sur ce canal, quelle est the symbol error probability Pb du code R3 , en fonction de p?
d– Supposons que p = 0.173. Quelle est la symbol error probability correspondante Pb ?
Quelle est la capacité de canal C ? Est-elle supérieure ou inférieure au taux de transmis-
sion R ?
Ces résultats sont-ils compatibles avec le théorème de codage en présence de bruit ?
possible.
Exercice 10.2.2:
Un ingénieur a découvert un code à utiliser sur un BSC à la probabilité d’erreur p qui aboutit
à une probabilité output bit error probability de Pb = 8p2 .
a– Est-ce compatible avec le théorème de Shannon de codage en présence de bruit ?

b– Pensez-vous qu’il pourrait exister un code avec le même taux de transmission mais avec
une meilleure probabilité output bit error ?
Souvenez-vous que la capacité de canal est dans ce cas C = 1 − e

h(p) = 1 + p log p + (1 −
p) log(1 − p) et supposons que p < 18 .
Chapitre 11
Module I2 : Codes correcteurs

d’erreurs

Après avoir étudié ce chapitre, vous devriez en savoir plus sur les codes correcteurs
d’erreurs, et plus précisément :
1. ce qu’est la distance minimale d’un code et combien d’erreurs un code avec
une distance minimale donnée peut corriger ;
2. les notions de base concernant les codes linéaires : comment construire de tels
codes, comment coder et décoder avec un code linéaire, ... ;
3. ce que sont les « codes de Hamming » et comment les utiliser ;
4. les notions de base concernant les codes cycliques ;
5. et les notions de base concernant les codes convolutionnels : circuit de codage,
représentation par un treillis, algorithme de Viterbi pour le décodage.
Introduction
Le théorème fondamental de Shannon de « codage en présence de bruit » présenté dans le

chapitre 9 donne des limites théoriques au codage de messages pour la transmission sur un
canal bruité. Malheureusement, ce théorème important ne donne aucun conseil (et sa démons-
tration non plus) sur la façon effective de construire de « bons » codes correcteurs d’erreurs en
pratique.
C’est la raison pour laquelle une théorie des codes correcteurs d’erreurs s’est développée pen-
dant plusieurs années. Cette théorie s’appuye principalement sur la structure algébrique des
codes. L’idée de base est de donner une structure à l’ensemble des mots de code de façon à
utiliser cette structure pour donner des indices sur le décodage du message en cas d’erreur de
transmission.
171
172 CHAPITRE 11. CODES CORRECTEURS D’ERREURS
Grâce à ses bases fortement mathématiques, la « théorie du codage algébrique » est maintenant
bien établie en tant que domaine scientifique à part entière, avec des applications à beaucoup
de problèmes qui ne se limitent pas au codage de canal.
Le but de ce chapitre n’est certainement pas de fournir une vue exhaustive des codes correcteurs
d’erreurs algébriques (un livre entier y parviendrait à peine), mais plutôt de présenter les idées-
clés du domaine. Le lecteur qui est intéressé par ce sujet peut se référer à la littérature plutôt
vaste dans le domaîne.
L’étude de ce chapitre requiert quelques connaissances mathématiques, particulièrement dans
de domaine des structures algébriques.
11.1 Notions de base

Dans cette section, les points-clés concernant les codes correcteurs d’erreurs suivants
sont présentés :
1. ce qu’est un code par bloc ;
2. comment la distance entre les mots de code est mesurée ;
3. ce qu’est le poids d’un mot de code ;
4. ce que sont la distance minimale et le poids minimal d’un code ;
5. et leur utilité pour déterminer combien d’erreurs un code peut détecter et/ou
corriger.
11.1.1 Introduction
Le contexte du présent chapitre est la transmission en présence de bruit telle que présentée
dans l’introduction du chapitre 9.
Lorsqu’un mot de code zi est transmis sur un canal bruité et que zb est finalement reçu, l’erreur
de transmission correspond à la différence entre zb et zi : e = zb − zi .
L’idée-clé derrière le codage algébrique est d’ajouter une structure algébrique à l’ensemble des
mots de code de sorte que l’erreur de transmission puisse aisément être exprimée en termes des
opérations définissant cette structure algébrique (à commencer par l’opération « différence »
ci-dessus).
Par exemple, si nous traitons des codes binaires (p.ex.10011) la différence « naturelle » sur
les mots binaires est la différence bit par bit (connue aussi sous le nom de « ou exclusif » pour
les lecteurs familiers avec l’informatique), c.-à-d. la différence à chaque position telle qu’il y
a un 0 si les deux bits correspondants sont les mêmes et un 1 dans le cas contraire : 0 - 1 = 1
et, comme d’habitude, 0 - 0 = 0, 1 - 1 = 0, 1 - 0 = 1.
Exemple 11.1 (Différence Binaire) Voici un exemple de différence entre deux mots (bi-
naires) :
11011 − 01101 = 10110
Techniquement parlant, l’opération définie ci-dessus correspond en fait à l’arithmétique « mo-

dulo 2 », c.-à-d. que nous considérons le corps de Galois GF(2) et que les mots de code sont
11.1. NOTIONS DE BASE 173
des éléments de l’espace vectoriel GF(2)n (où n est la longueur des mots de code). Cette base
s’étend aisément à n’importe quel code D-aire utilisant une arithmétique « modulo D ».
Définition 11.1 (Code par Bloc) Un code par bloc∗ D-aire de longueur n est un
sous-ensemble non vide de l’espace vectoriel des n-uplets GF(D)n (c.-à-d. des mots
D-aires de même longueur n, considérés comme des « vecteurs ligne »). ¨
Exemple 11.2 (Codes par Bloc) L’ensemble {1101, 0110, 1110} est un exemple de code
par bloc binaire.
Un autre exemple de code par bloc, considérant les codes ternaires utilisant les symboles
0 1 et 2, tels que 1 + 2 = 0 (c.-à-d. arithmétique GF(3)), est donné par l’ensemble
{120, 201, 222, 010}.
L’ensemble {011, 110, 10} n’est pas un code par bloc, ces mots n’étant pas tous de même
longueur.
Deux notions importantes dans le domaine des codes d’erreur algébriques sont maintenant
présentées : la distance de Hamming entre des mots et le poids d’un mot. La relation entre ces
notions et le problème de la correction d’erreurs est donnée dans la section suivante.
11.1.2 Distance de Hamming et poids d’un mot de code
Définition 11.2 (Distance de Hamming) La distance de Hamming∗ , d(z, z ′ ), entre

deux mots de même longueur z et z ′ (c.-à-d. deux n-uplets dans le cas le plus général)
est le nombre de symboles (c.-à-d. de positions) pour lesquels z et z ′ diffèrent. ¨
Exemple 11.3 (Distance de Hamming) La distance de Hamming entre 101010 et

111010 est 1 car ces deux mots diffèrent seulement par la deuxième position.
La distance de Hamming entre 1010 et 0101 est 4 car ces deux mots diffèrent par toutes les
positions.
La distance de Hamming entre 1010 et 111010 n’est pas définie (et ne sera pas considérée).
Définition 11.3 (Poids d’un mot de code) Le poids∗ d’un mot est le nombre de
symboles non nuls qu’il contient. ¨
Exemple 11.4 (Poids d’un mot de code) Le poids de 10110 est 3, tandis que le poids de
00000000 est 0 et que le poids de 001000 est 1.
Propriété 11.1 La distance de Hamming entre deux mots de code est le poids de leur
différence :
d(zi , zj ) = w(zi − zj )
en désignant la distance de Hamming par d(·) et le poids par w(·).
D ÉMONSTRATION zi et zj diffèrent à une position si et seulement si zi − zj est non nul à

cette position. ¥
Exemple 11.5 Voici un exemple de l’équivalence entre la distance de Hamming de deux

mots binaires et le poids de leur différence :
d(10110, 11010) = 2
w(10110 − 11010) = w(01100) = 2
Voici maintenant quelques propriétés utiles des poids des mots de code.
Propriété 11.2 Le poids d’un mot de code est toujours positif ou nul.
Trivial : par définition.
Définition 11.4 (mot de code nul) Le mot de code nul∗ est le mot de code constitué
uniquement de zéros.
Il sera désigné par 0. ¨
Propriété 11.3 Le poids d’un mot de code est 0 si et seulement si ce mot de code est
la mot de code nul 0.
Propriété 11.4 Le poids est symétrique : pour chaque mot de code zi , w(zi ) =
w(−zi ) (où −zi est le mot dans lequel chaque symbole est l’opposé du symbole
correspondant dans zi ).
Exemple 11.6 (Symétrie du poids) En considérant les codes ternaires utilisant les symboles
0 1 et 2, tels que 1 + 2 = 0 (c.-à-d. une arithmétique GF(3)), nous avons :
w(−1202102) = w(2101201) = 5 = w(1202102)
Notez que dans le cas binaire, la dernière propriété est triviale car dans ce cas −zi = zi pour
chaque zi .1
Propriété 11.5 Pour tous mots de code zi et zj , on a :
w(zi ) + w(zj ) ≥ w(zi + zj )
Exemple 11.7 Dans le cas binaire, on a par exemple :
w(110101) + w(010101) = 4 + 3 = 7 ≥ 1 = w(100000) = w(110101 + 010101)
1
Rappel : dans le cas binaire, −1 = 1.
En considérant les codes ternaires utilisant les symboles 0 1 et 2 comme ci-dessus, on a par
exemple :
w(01221021)+w(21002010) = 6+4 = 10 ≥ 5 = w(22220001) = w(01221021+21002010)
(Rappel : on travaille ici dans GF(3), i.e. 1 + 2 = 0 et l’addition de mots de codes s’effectue
sans retenue, symbole par symbole).
Évaluation 45
1. Quel est le poids de 11101101 ?
6. Quelle est la distance de Hamming entre 11 et 00 ?
Pourquoi la distance de Hamming et le poids sont-ils d’une importance fondamentale pour la

correction algébrique d’erreurs ?
Dans la base définie dans la section précédente, où l’erreur e qui est apparue dans la transmis-
sion où zi était émis et zb reçu est définie comme e = zb − zi , le nombre d’erreurs qui se sont
produites pendant la transmission se trouve maintenant simplement être le poids de e, c.-à-d.
w(bz − zi ). A cause de la propriété 11.1, ceci est la distance de Hamming d(b z , zi ) entre le
signal émis et le signal reçu.
Dans ce cadre, la détection d’une erreur revient simplement à détecter les poids non nuls.
Toutefois, la correction d’une erreur implique en outre la capacité de calculer la différence
effective (évidemment sans connaître zi ! Seul zb est connu à la réception).
11.1.3 Décodage à distance minimale et à vraisemblance maximale
Comment un décodeur de code par bloc pourrait-il prendre la décision de décoder un mot
reçu ? Une réponse intuitive naturelle est de supposer le plus petit nombre d’erreurs (c.-à-d.
w(e) minimal), ce qui, d’après ce qui vient d’être dit, amène à prendre le mot de code le plus
proche (c.-à-d. d(b
z , zi ) minimal).
Par exemple, si les deux seuls mot de code possibles sont 000 et 111, et que 010 est reçu,
nous voudrions certainement 2 le voir décodé en 000.
2
ne connaissant rien d’autre
Définition 11.5 (Décodage à Distance Minimale) On dit qu’un code C utilise un

décodage à distance minimale∗ chaque fois que la décision de décodage D consiste,
pour un mot zb reçu, à choisir le (un des) mot(s) de code le(s) plus proche(s) :
D(b
z ) = Argmin d(z, zb)
z∈C
Quelle est le statut mathématique du décodage à distance minimale ?

Dans le cas du Canal Symétrique Binaire (voir exemple 9.1), cette procédure intuitivement ju-
dicieuse de décodage à distance minimale découle du « décodage à vraisemblance maximale ».
Considérons la procédure de décodage d’un point de vue probabiliste (Bayésien). Lorsqu’un
mot zb est reçu, le mot de code le plus vraisemblablement émis (sachant que ce mot est reçu)
est le mot de code z qui maximise la probabilité P (X = z|Y = zb) (où X est l’entrés du canal
et Y sa sortie).
En pratique, il n’est pas facile de faire face à cette probabilité3 si la distribution P (X = zi )
des mots de code à l’émission (appelée « probabilités a priori ») n’est pas connue. Dans ce
contexte, aucune autre hypothèse n’est faite que la moins biaisée selon laquelle tous les mots
de code sont également probables (hypothèse d’entropie maximale). Alors :
P (Y = zb|X = z) · P (X = z)
Argmax P (X = z|Y = zb) = Argmax
z∈C z∈C P (Y = zb)
= Argmax P (Y = zb|X = z) · P (X = z)
z∈C
= Argmax P (Y = zb|X = z)
z∈C
La dernière égalité vient de l’hypothèse des mots de code également probables.

Le terme restant P (Y = zb|X = z) est appelé vraisemblance, et il apparaît finalement que le
décodeur devrait décoder zb en le mot de code le plus vraisemblable, c.-à-d. le mot de code z
qui maximise P (Y = zb|X = z).
Et alors ?
Eh bien, le dernier terme P (Y = zb|X = z) se trouve être plus facile à manipuler que le
premier P (X = z|Y = zb). Par exemple, dans le cas d’un canal discret sans mémoire (DMC,
voir 9.1), ceci devient le produit des probabilités de transmission pour chaque symbole.
Dans le cas d’un BSC, où tous les symboles ont la même probabilité d’erreur p, cette probabi-
lité devient simplement :
P (Y = zb|X = z) = pd(z,bz ) (1 − p)n−d(z,bz )
puisqu’il y a exactement d(z, zb) symboles qui ont été corrompus par la transmission et n −
d(z, zb) qui ont été transmis correctement.
Il est alors aisé de voir que le mot de code z qui maximise P (Y = zb|X = z) est celui qui
minimise la distance d(z, zb).
Ceci prouve que, pour un BSC, le décodage à distance minimale et le décodage à vraisemblance
maximale sont équivalents.
3
ou même de l’estimer, bien que cela soit possible.
11.1.4 Détection et correction d’erreurs
Existe-t-il un moyen de savoir à priori combien d’erreurs un code donné peut corriger ? ou
détecter ?4 La réponse est oui et repose principalement sur une caractéristique importante d’un
code par bloc : sa distance minimale.
Définition 11.6 (Distance Minimale d’un Code) La Distance Minimale∗ dmin (C)
d’un code C = {z1 , ..., zi , ..., zM } est la distance de Hamming minimale (non nulle)
entre toute paire de ses mots de code :
dmin (C) = min d(zi , zj ).

i6=j
Les résultats suivants à propos de la correction et de la détection d’erreurs montrent pourquoi

la distance minimale d’un code est d’une importance centrale dans la théorie du codage à
correction d’erreurs.
Théorème 11.1 (Correction d’Erreur et Capacité de Détection) Un code par

bloc de longueur n utilisant le décodage à distance minimale peut, pour toute paire
d’entiers t et s tels que 0 ≤ t ≤ n et 0 ≤ s ≤ n − t, corriger tous les schémas à t
erreurs ou moins et détecter tous les schémas à t + 1, ..., t + s erreurs si et seulement
si sa distance minimale est strictement supérieure à 2t + s.
Ce que l’on résume par la formule :
dmin (C) > 2t + s
D ÉMONSTRATION L’implication est démontrée par l’absurde :

C ne peut corriger tous les schémas à t ou ne peut détecter tous les schémas à t + 1, ..., t + s
erreurs si et seulement si dmin (C) ≤ 2t + s
Si le code C ne peut pas corriger tous les schémas de moins que t erreurs (inclues), cela
signifie qu’il existe au moins un mot de code zi et un schéma d’erreur e de poids inférieur à
t tels que le décodage D(zi + e) ne soit pas zi . Appelons zj le mot de code décodé au lieu de
zi dans ce cas : zj = D(zi + e).
En utilisant l’inégalité du triangle pour le d métrique, nous avons :
d(zi , zj ) ≤ d(zi , zi + e) + d(zi + e, zj )
Mais d(zi , zi + e) = w(e) ≤ t et d(zi + e, zj ) ≤ d(zi + e, zi ) car le code utilise le décodage

à distance minimale. Ainsi
d(zi , zj ) ≤ t + t ≤ 2t + s
et donc dmin (C), qui est inférieur ou égal à d(zi , zj ), est aussi inférieur ou égal à 2t + s.
Par ailleurs, si le code peur corriger tous les schémas de moins que t erreurs (inclues) mais
ne peut pas détecter tous les schémas à t + 1, ..., t + s, il existe au moins un mot de code zi
4
Par « détecter une erreur » on entend en fait « détecter une erreur mais sans la corriger », car bien sûr la
correction d’une erreur implique de l’avoir détectée !
et un schéma d’erreur e de poids entre t + 1 et t + s qui n’est pas détectée mais décodé en un
autre mot de code zj : D(zi + e) = zj . En introduisant l’erreur e′ = zj − (zi + e), nous avons
aussi D(zj + e′ ) = zj , c.-à-d. que e′ est une erreur qui est corrigée lorsqu’elle est appliquée
à zj . Comme w(e′ ) = d(zj + e′ , zj ) = d(zi + e, zj ) ≤ d(zi + e, zi ) (à cause du décodage
à distance minimale), nous avons w(e′ ) ≤ t + s et D(zj + e′ ) = zj . Donc w(e′ ) doit être
inférieur (ou égal) à t. Ceci nous permet de conclure de manière similaire à ci-dessus :
d(zi , zj ) ≤ d(zi , zi + e) + d(zi + e, zj ) ≤ (t + s) + t = 2t + s
et donc dmin (C) ≤ 2t + s.

Donc si C ne peut corriger tous les schémas à t erreurs ou ne peut détecter tous les schémas
à t + 1, ..., t + s erreurs, alors dmin (C) ≤ 2t + s.
Réciproquement, si dmin (C) ≤ 2t + s, il existe deux mots de code distincts zi et zj , tels que
d(zi , zj ) ≤ 2t + s. Ceci signifie que le poids du vecteur z = zi − zj est aussi inférieur à
2t + s.
Mais tout vecteur z de poids inférieur (ou égal) à 2t + s peut être écrit comme la somme de
deux vecteurs e et f tels que w(e) ≤ t et w(f ) ≤ t + s : prendre les premières composantes
jusqu’à t non nul comme composantes de e [pour toutes les composantes si w(z) < t] et
les composantes restantes (zéro le cas échéant) pour f . Par exemple 011010, peut être écrit
comme 010000 + 001010 (t = 1 et s = 1).
Il existe ainsi deux vecteurs e et e′ (prenons e′ = −f ) tels que w(e) ≤ t, w(e′ ) ≤ t + s et
que zi − zj = e − e′ ; c.-à-d. zi + e′ = zj + e.
Ceci veut dire que deux mots de code distincts et deux schémas d’erreur seront décodés de la
même façon (comme zi + e′ = zj + e, D(zi + e′ ) = D(zj + e)).
Ceci implique que (au moins) zi + e′ n’est pas corrigé (D(zi + e′ ) 6= zi ) ou zj + e n’est pas
détecté (D(zj + e) = zi ).
Ainsi, tous les schémas de moins que t (inclus) erreurs ne peuvent être corrigés, ou tous les
schémas à t + 1, ... t + s ne peuvent être détectés. ¥
Propriété 11.6 (Capacité maximale de détection d’erreurs) Un code par bloc C

utilisant le décodage à distance minimale peut être utilisé pour détecter tous les sché-
mas d’erreur de dmin (C) − 1 erreurs, ou moins.
D ÉMONSTRATION Utiliser t = 0 et s = dmin (C) − 1 dans le théorème ci-dessus. ¥
Propriété 11.7 (Capacité maximale de correction d’erreurs) Un code par bloc C

utilisant le décodage à distance minimale peut être utilisé pour corriger tous les
schémas d’erreur de (dmin (C) − 1)/2 (division Euclidienne, appelée aussi « division
entière ») ou moins d’erreurs, mais ne peut pas être utilisé pour corriger tous les
schémas d’erreur de 1 + (dmin (C) − 1)/2 erreurs.
Ce que l’on résume par la formule :

¹ º
dmin (C) − 1
tmax =
2
D ÉMONSTRATION Utiliser t = (dmin (C) − 1)/2 et s = 0 dans le théorème ci-dessus.

(dmin (C) − 1)/2 est en outre le t maximal qui peut être utilisé dans le théorème ci-dessus,
comme dmin (C) ≤ 2 · (1 + (dmin (C) − 1)/2)
[Rappel : / désigne ici la division Euclidienne]. ¥
Exemple 11.8 Un code par bloc ayant une distance minimale de 8 peut être utilisé pour l’un
ou l’autre des points suivants :
– corriger tous les schémas d’erreur de moins que 3 (inclus) erreurs et détecter tous les
schémas à 4 erreurs (t = 3, s = 1) ;
– corriger tous les schémas d’erreur de moins que 2 erreurs et détecter tous les schémas de 3
à 5 erreurs (t = 2, s = 3) ;
– corriger tous les schémas d’erreur de 1 erreur et détecter tous les schémas de 2 à 6 erreurs
(t = 1, s = 5) ;
– détecter tous les schémas de moins que 7 (inclus) erreurs (t = 0, s = 7).
Un code par bloc ayant une distance minimale de 7 peut (l’un ou l’autre)
– corriger tous les schémas d’erreur de moins que 3 (inclus) erreurs (t = 3, s = 0) ;
– corriger tous les schémas d’erreur de moins que 2 erreurs et détecter tous les schémas de 3
à 4 erreurs (t = 2, s = 2) ;
– corriger tous les schémas d’erreur de 1 erreur et détecter tous les schémas de 2 à 5 erreurs
(t = 1, s = 4) ;
– détecter tous les schémas de moins que 6 (inclus) erreurs (t = 0, s = 6).
Exemple 11.9 Pour être capable de corriger tous les schémas à 1 erreur (et c’est ce qu’on
recherche), un code par bloc doit avoir une distance minimale égale à 3 au moins.
Évaluation 46
1. Un ingénieur en télécommunications veut disposer d’un canal où tous les schémas à

3 erreurs ou moins sont corrigés. Peut-il utiliser un code par bloc qui a une distance
minimale de 5 ?
2. Combien d’erreurs au plus peuvent être corrigées avec un code par bloc qui a une dis-
tance minimale de 6 ?
3. Un tel code peut-il en outre détecter des erreurs ? Si oui, combien ?
code par bloc : un ensemble non vide de mots de même longueur, considérés comme des
« vecteurs ligne ».
poids : (d’un mot) le nombre de symboles non nuls.
distance de Hamming : le nombre de coordonnées par lesquelles deux vecteurs diffèrent.
La distance de Hamming entre deux mots est le poids de leur différence.
décodage à distance minimale : structure de correction d’erreurs dans laquelle chaque mot
reçu est décodé en le mot de code le plus proche (d’après la distance de Hamming).
décodage à vraisemblance maximale : structure de correction d’erreurs dans laquelle

chaque mot reçu zb est décodé en le (un des) mot(s) le(s) plus vraisemblable(s) z, c.-à-d.
un mot de code tel que P (Y = zb|X = z) soit maximale (avec X l’entrée du canal
bruité et Y sa sortie).
distance minimale d’un code : la distance de Hamming minimale (non nulle) entre toute
paire de mots de code (différents).
capacité de correction et de détection d’erreurs : Un code par bloc C de longueur n uti-
lisant le décodage à distance minimale peut, pour toute paire d’entiers t et s tels que
0 ≤ t ≤ n et 0 ≤ s ≤ n − t, corriger tous les schémas à t ou moins erreurs et détec-
ter tous les schémas de t + 1, ..., t + s erreurs si et seulement si sa distance minimale
dmin (C) est strictement supérieure à 2t + s :
dmin (C) > 2t + s ⇐⇒ C corrige t et détecte t + s erreurs.
11.2 Codes linéaires
A cause de leurs propriétés et de leur simplicité, les codes linéaires, dont il est question dans
cette section, sont d’un intérêt majeur pour le codage d’erreurs. Un de leurs avantages princi-
paux dans la pratique est qu’ils sont aisément implémentables.

Dans cette section, les notions de base concernant les codes linéaires sont présentées.
Voici ce que vous devriez savoir sur ce sujet :
1. ce qu’est un code (n, m) D-aire ;
2. que pour de tels codes la distance minimale et le poids minimal sont équiva-
lents ;
3. comment coder en utilisant une matrice génératrice ;
4. quelle est la forme systématique d’une matrice génératrice d’un code linéaire ;
5. comment décoder en utilisant une matrice de vérification et un tableau de syn-
dromes ;
6. comment calculer la distance minimale d’un code linéaire ;
7. ce que sont les codes de Hamming binaires et comment les utiliser.
11.2.1 Définitions
Les codes linéaires sont des codes par bloc sur lesquels une structure algébrique a été ajoutée
pour aider au décodage : la structure d’espace vectoriel.
Définition 11.7 (Code Linéaire) Un (n, m) code linéaire∗ (1 ≤ m ≤ n) D-aire

est un sous-espace m-dimensionnel de l’espace vectoriel GF(D)n de n-uplets sur
GF(D). ¨
11.2. CODES LINÉAIRES 181
En regardant la définition des codes par bloc, la définition ci-dessus peut être reformulée : un
code linéaire est un code par bloc qui est un espace vectoriel.
Exemple 11.10 (Code Linéaire) Le code {1101, 0110, 1110} donné dans l’exemple 11.2
n’est pas un code linéaire car 0000 n’en fait pas partie (il ne pourrait donc pas être un espace
vectoriel).
Le code (binaire) {0000, 1101, 0110, 1011} est un code linéaire comme toute combinaison
linéaire (binaire) de mots de code est aussi un mot de code. Il est de plus un code linéaire
binaire (4, 2) car sa dimension (c.-à-d. la dimension du sous-espace vectoriel) est de 2 et sa
longueur de 4.
Notez en outre que la distance minimale de ce code est 2 (aisément vérifiable) et que ce code
ne peut donc être utilisé que pour la détection d’erreurs uniques (voir théorème 11.1).
Évaluation 47
Pour chacun des codes binaires suivants, spécifiez si le code est un code linéaire ou non. Si
oui, donnez les deux nombres n et m de la définition :
1. C = {0000, 1000, 0001, 1001}
2. C = {1000, 0001, 1001}
3. C = {00, 01, 11}
4. C = {0000, 1000, 1100, 0100, 1101, 0001, 0101, 1001}
5. C = {0, 1, 10, 11}
6. C = {00, 11, 10, 01}
7. C = {0000, 0001, 0010, 0100}
11.2.2 Quelques propriétés des codes linéaires
Propriété 11.8 Tout code linéaire contient le mot de code nul 0.
Ceci vient directement du fait qu’un code linéaire est un (sous-) espace vectoriel.
Étudions maintenant de manière plus approfondie ces codes linéaires. Premièrement, combien
de mots de code un code linéaire (n, m) D-aire contient-il ?
Propriété 11.9 Un code linéaire (n, m) D-aire contient Dm mots de code différents
(le mot de code nul inclus).
Notez que cette propriété peut être utilisée pour déterminer rapidement que les codes avec un
mauvais nombre de mots de code (qui n’est pas une puissance de D) ne sont pas linéaires. Pour
les codes linéaires, ceci peut aussi être utilisé pour une rapide détermination de m (p.ex. pour
« deviner » la taille d’une base).
D ÉMONSTRATION Comme un code linéaire est un espace vectoriel de dimension m, chaque

mot de code est la combinaison linéaire de m mots de code de base (une base de cet espace
vectoriel).
Pour un code (n, m) D-aire, il y a donc exactement Dm mots de code différents : toutes les
Dm combinaisons linéaires. ¥
Quel est alors le taux de transmission d’un tel code ?
Propriété 11.10 Le taux de transmission d’un code linéaire (n, m) est

m
R=
n
D ÉMONSTRATION Rappel : le taux de transmission d’un code D-aire qui code une source
de M messages différents par des mots de code de longueur n est R = logD
n
M
.
Combien de messages différents peuvent être codés en utilisant un code linéaire (n, m) ?
Autant que de mots de code, c.-à-d. Dm .
Ainsi,
logD Dm m
R= =
n n
Voici maintenant une autre propriété utile des codes linéaires.
Théorème 11.2 (Equivalence du Poids Minimal et de la Distance Minimale)

Pour tout code linéaire C
dmin (C) = wmin (C)
où wmin (C)est le poids minimal du code, c.-à-d. le plus petit poids d’un mot de code
non nul :
wmin (C) = min w(z)
z∈C
z6=0
Ce résultat est très important en pratique, car wmin (C)est beaucoup plus facile à calculer que
dmin (C).
D ÉMONSTRATION Pour un code C = {z1 , ..., zi , ...}, on a par la définition 11.6 dmin (C) =
mini6=j d(zi , zj ).
Donc, en utilisant la propriété 11.1, dmin (C) = mini6=j w(zi − zj ).
Mais si C est un code linéaire, pour toute paire de mots de code zi et zj , zi − zj est aussi un
mot de code. C’est en outre le mot de code nul si et seulement si zi = zj (c.-à-d. i = j).
Ainsi dmin (C) ≥ wmin (C).
Réciproquement, pour tout mot de code zi , w(zi ) = d(zi , 0). Comme 0 fait partie de tout
code linéaire, on obtient : wmin (C) ≥ dmin (C), ce qui conclut la démonstration. ¥
Exemple 11.11 Le code (11, 3) binaire {00000000000, 10011110000,

01000111100, 00111001111, 11011001100, 10100111111, 01111110011,
11100000011} a un poids minimal de 5 et donc une distance minimale de 5.
Ce code peut donc corriger tous les schémas d’erreur avec 1 ou 2 erreurs (voir propriété 11.7).
[La vérification de la linéarité effective de ce code est laissée comme exercice.]
Évaluation 48
Quelle est la distance minimale des codes suivants ?
1. C = {0000, 1000, 0001, 1001}

2. C = {0000, 1000, 1100, 0100, 1101, 0001, 0101, 1001}
3. C = {00000000, 00001011, 00110000, 00111011, 11000000, 11001011, 11110000, 11111011}
4. C = {1000, 0001, 0010, 0100}
Évaluation 49
Combien d’erreurs peuvent (au plus) corriger les codes linéaires suivants :
1. C = {0000, 1000, 1100, 0100, 1101, 0001, 0101, 1001}
2. C = {000000000, 000000111, 000111000, 000111111, 111000000, 111000111, 111111000, 111111111}
11.2.3 Codage avec des codes linéaires
L’accent doit maintenant être mis sur la relation liant les messages à coder aux mots de code
correspondants : il est temps de voir comment utiliser efficacement les codes linéaires pour
coder des messages.
Si les m mots de code choisis pour former une base d’un code linéaire (n, m) (espace vecto-
riel)5 sont désignés par z1 , ..., zm , alors tout mot de code zi peut être écrit comme
m
X
zi = ui,k zk
k=1
où ui,k est la composante de zi sur le vecteur de base zk .

De manière plus compacte, en utilisant l’algèbre linéaire, on a :
zi = (ui,1 , ..., ui,m ) · G = ui · G
où ui est le vecteur ligne (ui,1 , ..., ui,m ) et G la matrice dont les lignes sont z1 , ..., zm .
Il est alors tout naturel de choisir de coder le message à m symboles par le mot de code zi qui
résulte de la multiplication par G ci-dessus.
Pour cette raison, la matrice G est appelée matrice génératrice∗ du code.6
5
Rappel : dans la plupart des cas, le choix n’est pas unique
6
Notez que, pour un code donné, cette matrice génératrice n’est pas unique : elle dépend de la base choisie pour
représenter le code.
Définition 11.8 (Matrice Génératrice) Une matrice m × n G est dite matrice géné-
ratrice d’un code linéaire (n, m) C si et seulement si ses m vecteurs ligne sont une
base de l’espace vectoriel C.
Le codage d’un message u (de taille m) est alors effectué par z = u · G. ¨
Exemple 11.12 (Matrice Génératrice) Soit le code linéaire (4, 2) binaire de

l’exemple 11.10 : {0000, 1101, 0110, 1011}.
Ce code, ayant quatre mots de code, peut coder quatre messages : les quatre mots binaires de
deux bits : u0 =00, u1 =10, u2 =01, u3 =11. Faisons ce codage en utilisant une matrice
génératrice.
Une base pour ce code linéaire pourrait être z1 = 1101, z2 = 0110, ce qui donne
· ¸
1 1 0 1
G=
0 1 1 0
u1 est alors codé en

· ¸
1 1 0 1
u1 · G = (10) · = (1101) = z1
0 1 1 0
et de manière similaire u2 en z2 , u3 en 1011 et u0 en 0000.

Notez qu’un code linéaire peut toujours coder le message nul avec le mot de code nul 0. Ceci
est précisément dû à l’aspect linéaire (c.-à-d. d’espace vectoriel) du code.
L’utilisation d’une matrice génératrice rend le codage très facile à implémenter en pratique.
Dans le cas binaire par exemple, seuls quelques7 portes « ou »-exclusif (XOR) peuvent réaliser
le codage.
11.2.4 Forme systématique d’un code linéaire
Parmi toutes les matrices génératrices possibles, une d’entre elles est particulièrement intéres-
sante (si elle existe) : celle sous forme systématique.
Définition 11.9 (Forme Systématique) Une matrice génératrice G d’un code li-
néaire (n, m) est dite sous forme systématique si elle est de la forme
 
1 0 · · · 0 p1,1 · · · p1,n−m
 0 1 · · · 0 p2,1 · · · p2,n−m 
 
G = [Im P ] =  . . . 
 .. .. . . ... ..
.
..
.
..
. 
0 0 ··· 1 pm,1 · · · pm,n−m
où Im est la matrice-identité de taille m et P une matrice m × (n − m), souvent

appelée « matrice de parité ». ¨
7
au plus n · (m − 1), en fait
Notez que, lorsqu’elle existe pour un code donné, la matrice génératrice systématique est
unique.
Définition 11.10 (Code Linéaire Systématique) Un code linéaire utilisant une ma-
trice génératrice sous forme systématique est appelé code (linéaire) systématique. ¨
Lorsqu’un code linéaire (n, m) utilise une matrice génératrice de forme systématique, les m
premiers symboles des n symboles d’un mot de code sont exactement les symboles du message
codé :
zi = (ui,1 ui,2 ... ui,m zi,m+1 , ... zi,n )
En d’autres termes, les codes systématiques envoient d’abord le message non codé puis (n−m)
symboles de codage utilisés pour la détection/correction d’erreurs.
Exemple 11.13 Si on se rappelle l’exemple 11.12, un autre choix pour les vecteurs de la base
aurait pu être z1 = 1011, z2 = 0110, ce qui donne
· ¸
1 0 1 1
G=
0 1 1 0
qui est la matrice génératrice sous forme systématique pour ce code.
Exemple 11.14 (Bit de vérification de parité) Pour les messages binaires, le bit de vérifi-
cation de parité est le bit qui correspond à la parité du message, c.-à-d. à la somme (binaire)
de ses bits.
Par exemple, le bit de vérification de parité pour 01101 est 1 + 1 + 1 = 1 et le bit de
vérification de parité pour 00101 est 1 + 1 = 0.
Le code par bit de parité consiste simplement à envoyer d’abord le message tel quel, suivi de
son bit de parité. En termes de codes, ceci correspond au code binaire linéaire (m + 1, m),
dont la matrice génératrice est  
1
 
G = Im ... 
1
qui est sous forme systématique.
Notez que la distance minimale de ce code est 2 (en utilisant le théorème 11.2), ce code n’est
donc capable de faire que de la détection d’erreurs uniques (voir théorème 11.1).
Évaluation 50
Pour chacune des matrices suivantes

1. dites si celle-ci peut être une matrice génératrice.
2. si oui, dites si elle est sous forme systématique.
3. si la matrice n’est pas sous forme systématique, donnez la matrice sous forme systéma-
tique du code correspondant.
4. (pour les matrices génératrices) comment sera codé le message 1011 en utilisant la
forme systématique ?
 
1 1 0 0 1 1 0
 0 1 0 1 1 1 0 
1. G = 
 0

0 1 1 1 0 1 
1 0 1 0 1 0 1
 
1 0 0 0 1 1 0
 0 1 0 0 0 1 0 
2. G = 
 0

0 1 0 1 0 0 
0 0 0 1 0 1 1
 
1 1 0 0 1 0 0
 0 1 0 1 0 0 1 
3. G = 
 1

0 1 1 0 0 0 
1 0 1 0 1 1 1
11.2.5 Décodage : Matrice de vérification
À ce niveau, nous savons comment coder avec des codes linéaires. Mais qu’en est-il du dé-
codage ? Comment les erreurs peuvent-elles être corrigées ? Après tout, c’est bien là toute
l’histoire !
C’est précisément maintenant que la linéarité des codes est importante.
Supposons avoir trouvé une matrice F telle que, pour tout mot de code z, z · F = 08 . Alors, si
une erreur e survient durant la transmission de z et zb = z + e est reçu, nous avons
zb · F = (z + e) · F = z · F + e · F = 0 + e · F = e · F
Ce denier résultat est très utile comme zb · F est indépendant du mot de code z émis mais
ne dépend que de l’erreur e. Le résultat de cette erreur de transmission apparaît comme une
combinaison linéaire des lignes de F . Pour corriger/détecter l’erreur, les vecteurs de l’espace
vectoriel généré par les lignes de F doivent « simplement » correspondre au message de cor-
rection (ou de détection) correspondant.
Ceci est l’idée-clé qui va maintenant être formalisée et étudiée un peu plus profondément.
Pour de bonnes raisons mathématiques9 , l’équation ci-dessus z · F = 0 est toujours donnée
sous la forme suivante :
z · HT = 0
où T est l’opérateur de transposition et H = F T .
Définition 11.11 (Matrice de Vérification) Une matrice (n − m) × n H est une

matrice de vérification∗ pour un code linéaire (n, m) D-aire C si et seulement si
∀z ∈ GF(D)n z · H T = 0 ⇐⇒ z ∈ C
En d’autres termes, une matrice de vérification pour un code C est une matrice dont
le noyau est C. ¨
8
Comme vous le verrez dans un moment, ce n’est pas si difficile.
9
orthogonalité : G · H T = 0
Notez qu’un code linéaire donné pourrait avoir plusieurs matrices de vérification différentes :
toute matrice dont les lignes sont une base de l’espace vectoriel orthogonal au code linéaire10
est une matrice de vérification pour ce code.
Comment trouver des matrices de vérification ?
Dans le cas où le code est systématique, il est facile de trouver une matrice de vérification,
comme le montre le théorème suivant :
Théorème 11.3 Pour un code linéaire (n, m) systématique dont la matrice généra-
trice sous forme systématique est
G = [Im P ] ,
la matrice £ ¤
H = −P T In−m
est une matrice de vérification.
D ÉMONSTRATION Pour tout message ui , le mot de code correspondant est
zi = u i · G
= ui · [Im P ]
c.-à-d. ½
(zi,1 , ..., zi,m ) = ui
(zi,m+1 , ..., zi,n ) = ui · P
Donc
(zi,m+1 , ..., zi,n ) = (zi,1 , ..., zi,m ) · P
c.-à-d.
−(zi,1 , ..., zi,m ) · P + (zi,m+1 , ..., zi,n ) = 0
ou, sous forme matricielle :
· ¸
−P
zi · =0
In−m
£ ¤T
Nous avons donc trouvé une matrice ( −P T In−m ) telle que son produit avec chaque mot
de code donne le vecteur nul.
Il est aisé de voir que la construction inverse a pour résultat que chaque mot x tel que x ·
£ ¤T
−P T In−m = 0 vérifie
x = (x1 , ..., xm ) · G
et se trouve donc être un mot de code. ¥
Notez que dans le cas binaire (GF(2)), −P = P .
10
rappel : un code linéaire est un sous-espace vectoriel
Exemple 11.15 Considérons le code systématique C, dont la matrice génératrice est

· ¸ · ¸
1 0 1 0 1 1 0 1
G= = I2
0 1 1 1 1 1 1 1
Alors (n = 5 et m = 2)
"· #  
¸T 1 1 1 0 0
1 0 1
H= I3 = 0 1 0 1 0 
1 1 1
1 1 0 0 1
est une matrice de vérification possible pour C.
Évaluation 51
Donnez une matrice de vérification pour le code linéaire dont la matrice de codage sous forme
systématique est
 
1 0 0 0 0 1 0 1 0
 0 1 0 0 0 1 1 0 0 
 
G=  0 0 1 0 0 0 1 0 1 

 0 0 0 1 0 1 1 1 1 
0 0 0 0 1 0 0 1 1
Évaluation 52
Le mot z =1001101 est-il un mot de code du code dont une matrice de vérification est
 
1 1 1 0 1 0 0
H =  0 1 1 0 0 1 0 ?
0 0 1 1 0 0 1
11.2.6 Syndromes
Répétons maintenant l’idée-clé importante des codes linéaires.

Si z est le mot de code transmis et une erreur e survient, le mot reçu est alors zb = z + e. Si H
est une matrice de vérification pour le code utilisé, alors
zb · H T = (z + e) · H T = z · H T + e · H T = 0 + e · H T = e · H T
Ceci illustre le fait important que zb · H T ne dépend que du schéma d’erreur effectif e et absolu-
ment pas du mot de code transmis zb. Pour cette raison, ce résultat zb · H T est d’une importance
particulière pour le décodage. Ceci est appelé syndrome (de zb relatif à H).
Définition 11.12 (Syndrome) Le syndrome∗ d’un mot zb relatif à une matrice de vé-
rification H est le produit zb · H T . ¨
Propriété 11.11 Le syndrome s = zb · H T d’un mot reçu zb relatif à la matrice de

vérification H d’un code C dépend uniquement de l’erreur de transmission e = zb−zi
et non du mot de code zi (zi ∈ C) transmis.
En outre, le schéma d’erreur e est décomposé en erreurs élémentaires ek (c.-à-d. faites d’une
seule erreur sur un seul symbole) : e = (e1 , ..., en ), alors
X
z ) = zb · H T = e · H T =
s(b ek hk
k
où hk est la k-ème colonne de H : H = [h1 , ..., hn ].

Pour trouver le correcteur (c.-à-d. l’opposé de l’erreur), seuls les correcteurs correspondant aux
erreurs simples doivent être connus puis additionnés.
La correction peut alors être effectuée simplement en faisant correspondre les colonnes de H
aux correcteurs (stockés dans une mémoire) et en additionnant ceux qui correspondent aux
positions non nulles du syndrome.
Exemple 11.16 (Tableau de correction basée sur les syndromes) Supposons que
 
1 1 1 0 0
H= 0 1 0 1 0 
1 1 0 0 1
soit une matrice de vérification pour le code binaire utilisé.

Les correcteurs suivants peuvent alors être dérivés des colonnes de H :
Syndrome Correcteur
101 10000
111 01000
100 00100
010 00010
001 00001
Ce qui est simplement obtenu en listant les colonnes de H.

En réarrangeant par syndrome le tableau ci-dessus de façon à pouvoir l’utiliser en pratique
(où seul le syndrome est connu), on obtient :
Syndrome Correcteur
000 00000
001 00001
010 00010
011 ?
100 00100
101 10000
110 ?
111 01000
Notez que :
1. Le syndrome nul pointe toujours vers aucune correction, à cause de la définition 11.11 ;
2. Pour 011 et 110, le correcteur n’est dans cet exemple pas unique : par exemple 011 =
010 + 001 donne 00011 (00001 + 00010), mais 011 = 111 + 100 donne une autre
correction, 01100.
Ceci est dû au fait que la distance minimale de ce code est 3 (voir section suivante), et
que ce code ne peut donc corriger que tous les schémas à 1 erreur, mais pas tous les
schémas à 2 erreurs !
Ces deux syndromes correspondent en fait à deux erreurs de transmission.
En pratique, le tableau de correspondance entre les syndromes et les erreurs est stocké dans une
mémoire, et le mécanisme général pour décoder (et corriger) un message reçu zb est le suivant :
z ) = zb · H T ;
1. Calculer le syndrome s(b
2. Obtenir la correction c = −e (c.-à-d. l’opposé de l’erreur) par la combinaison linéaire
des correcteurs stockés en mémoire ;
3. Décoder z = zb + c.
Exemple 11.17 (Décodage avec un Code Linéaire) Continuons avec le dernier exemple
(exemple 11.16), dont la génératrice est
· ¸
1 0 1 0 1
G=
0 1 1 1 1
Supposons devoir transmettre u = 10. Ce message est codé par z = 10101 avec le code
linéaire binaire (5, 2) ci-dessus.
Supposons que zb = 00101, c.-à-d. que le premier bit ait été corrompu.
Le calcul du syndrome donne s = zb · H T = 101, ce qui nous donne le correcteur e = 10000
(voir tableau des correcteurs donné dans l’exemple 11.16).
Le mot de code décodé est ainsi zb+e = 00101+10000 = 10101, ce qui nous donne le mes-
sage décodé (les deux premiers bits correspondant au message originel, un code systématique
ayant été utilisé) : 10, ce qui correspond au message originel.
Évaluation 53
Quel était le message originel si vous recevez 101011001 et si la matrice de vérification du

code est  
1 1 0 1 0 1 0 0 0
 0 1 1 1 0 0 1 0 0 
H=  1 0 0 1 1 0 0 1 0 ?

0 0 1 1 1 0 0 0 1
11.2.7 Distance minimale et matrice de vérification
La présentation générale des codes linéaires se termine maintenant par un résultat utile, qui
permet le calcul de la distance minimale d’un code 11 directement depuis sa matrice de vérifi-
cation.
11
et donc le nombre maximal d’erreur pouvant être corrigées
Théorème 11.4 (Matrice de Vérification et Distance Minimale) Si H est une ma-

trice de vérification pour un code linéaire (n, m) D-aire C (avec 1 ≤ m < n), alors
la distance minimale dmin (C) de ce code est égale au plus petit nombre de colonnes
linéairement dépendantes de H.
D ÉMONSTRATION Pour tout vecteur z, z·H T est une combinaison linéaire de w(z) colonnes
de H. Et, par la définition 11.11 : z ∈ C si et seulement si z · H T = 0.
Ainsi, si z ∈ C, il existe alors w(z) colonnes de H qui sont linéairement dépendantes ; et
réciproquement, si q colonnes de H sont linéairement dépendantes, il existe un mot de code
de poids q.
Donc wmin (C) est le nombre minimal de colonnes de H qui sont linéairement dépendantes,
et on conclut en utilisant le théorème 11.2. ¥
Pour un code linéaire binaire C avec un matrice de vérification H, ce résultat implique que
– Si H n’a pas de colonne nulle, dmin (C) > 1.
– Si H n’a en outre pas deux fois la même colonne, dmin (C) > 2.
Exemple
 11.18 Un code linéaire binaire dont une matrice de vérification est H =
1 1 1 0 0
 0 1 0 1 0  a une distance minimale de 3.
1 1 0 0 1
En effet, H n’a pas de colonne nulle, ni deux fois la même colonne, donc dmin (C) > 2. En
outre, il y a un ensemble de 3 colonnes de H qui sont linéairement dépendantes. Par exemple,
h1 , h3 et h5 .
Propriété 11.12 (Limite de Singleton) Pour un code linéaire (n, m) C,
dmin (C) ≤ n − m + 1.
D ÉMONSTRATION Les colonnes de H sont des vecteurs de GF(D)(n−m) , donc tout en-
semble de n − m + 1 de ces colonnes est linéairement dépendant. Donc, en utilisant le
théorème 11.4, dmin (C) ≤ n − m + 1. ¥
Évaluation 54
Quelle est la distance minimale d’un code dont la matrice de vérification est
 
1 1 0 1 0 1 0 0 0
 0 1 1 1 0 0 1 0 0 
H=  1 0 0 1 1 0 0 1 0 ?

0 0 1 1 1 0 0 0 1
Combien d’erreurs ce code peut-il corriger ?
e-nnexe : Code Linéaire

11.2.8 Codes de Hamming binaires
Étudions maintenant plus en profondeur quels sont les « bons » codes, qui peuvent corriger
une erreur (dans le cas binaire).
Comme nous ne cherchons qu’une seule erreur, le syndrome n’a besoin d’indiquer que la
position où se trouve l’erreur. L’idée est de disposer d’un code dont le syndrome indique di-
rectement la position de l’erreur ; par exemple sous forme de son code binaire (0...001 pour la
première position, 0...010 pour la seconde, 0...011 pour la troisième, etc.).
Rappel : une erreur simple en position k donne un syndrome qui est la k-ème colonne de H.
L’idée ci-dessus est donc de construire une matrice de vérification dont les colonnes sont les
représentations binaires de leur position (voir exemple ci-dessous).
Ce qui n’est pas encore clair est
1. quelles dimensions cette matrice de vérification devrait avoir ?
2. cette construction mène-t-elle effectivement à une matrice de vérification d’un code ?
3. un tel code peut-il effectivement corriger tous les schémas à 1 erreur ?
A propos du premier point, rappelez-vous que la taille d’un syndrome d’un code linéaire (n, m)
est n − m. Si le syndrome code directement la position de l’erreur, il pourrait alors représenter
2n−m − 1 positions. Aucune place n’est donc perdue si le nombre total de positions à repré-
senter (c.-à-d. la longueur n du mot de code) est n = 2n−m − 1.
En dépit du cas trivial n = 3, m = 1, voici quelques tailles possibles pour de tels codes :
n m r =n−m
7 4 3
15 11 4
31 26 5
63 57 6
.. .. ..
. . .
et voici deux exemples de matrices de vérification (pour n = 7 et 15) :

 
0 0 0 1 1 1 1
H3 =  0 1 1 0 0 1 1 
1 0 1 0 1 0 1
 
0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
H4 = 
 0

1 1 0 0 1 1 0 0 1 1 0 0 1 1 
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
Il est facile de répondre à la deuxième question ci-dessus : oui, cette construction donne un
code linéaire comme les matrices construites de cette façon sont de rang plein (c.-à-d. que
rank(H) = n − m), puisqu’il est aisé de construire la matrice identité In−m à partir de leurs
colonnes (prendre la première, deuxième, quatrième, huitième colonne, etc.). La dimension de
leur noyau est donc m, ce qui donne un code linéaire (n, m).
Finalement, pour répondre à la dernière question (un tel code peut-il effectivement corriger
tous les schémas à 1 erreur ?), nous devons calculer sa distance minimale. Les matrices de
vérification résultant de la construction ci-dessus n’ont jamais de colonne nulle ni deux fois
la même colonne, et donc au minimum dmin (C) ≥ 3. En outre, les trois premières colonnes
(représentations binaires de 1, 2 et 3) sont toujours linéairement indépendantes. La distance
minimale de tels codes est donc toujours 3. De tels codes peuvent donc corriger tous les sché-
mas à 1 erreur.
De tels codes sont appelés « codes de Hamming (binaires) ».
Définition 11.13 (Code de Hamming) Un code de Hamming est un code linéaire

binaire (2r − 1, 2r − r − 1) (r ≥ 2), dont la matrice de vérification est
 
0 0 0 ··· 1
£ ¤  . . .
 . . . . . . .. 
. 
Hr = br (1)T br (2)T · · · br (n)t =  . . . 
 0 1 1 ··· 1 
1 0 1 ··· 1
où bn (i) est la représentation binaire de i en n bits (p.ex. b4 (5) = (0101)). ¨
Propriété 11.13 Tout code de Hamming binaire peut corriger tous les schémas à une
erreur.
Exemple 11.19 (Code de Hamming) Prenons r = 3 et construisons le code de Hamming

binaire (7, 4).
Nous avons :  
0 0 0 1 1 1 1
H3 =  0 1 1 0 0 1 1 
1 0 1 0 1 0 1
Pour trouver la matrice génératrice, nous cherchons 4 vecteurs z tels que z · H T = 0, par
exemple (facile à vérifier, et il y en a beaucoup d’autres) :
z1 = 1110000
z2 = 1101001
z3 = 1000011
z4 = 1111111
ce qui donne  
1 1 1 0 0 0 0
 1 1 0 1 0 0 1 
G=
 1

0 0 0 0 1 1 
1 1 1 1 1 1 1
Supposons maintenant devoir envoyer le message u = 1001. Il est codé en z = u · G =

0001111. Faisons en l’hypothèse supplémentaire qu’une erreur soit survenue sur le troisième
bit, et donc que zb = 0011111 soit reçu. Comment ceci sera-t-il décodé ?
Le syndrome est s(0011111) = zb · H T = 011, c.-à-d. 3 en binaire, ce qui indique que
l’erreur est apparue sur le troisième bit. Le résultat du décodage est alors zb − 0010000 (erreur
en troisième position) qui est 0001111, ce qui est effectivement le mot de code émis.
code linéaire : un code par bloc qui est un espace vectoriel (c.-à-d. que toute combinaison
de mots de code est aussi un mot de code).
Un code linéaire (n, m) D-aire est un sous-espace vectoriel de dimension m de l’es-
pace vectoriel de dimension n de mots de code D-aires.
distance minimale : pour les codes linéaires, la distance minimale est égale au poids mini-
mal.
matrice génératrice : (d’un code linéaire (n, m)) une matrice m × n dont les lignes sont
une base du code (elle sont donc linéairement indépendantes).
forme systématique : une matrice génératrice m × n d’un code linéaire (n, m) est dite sous
forme systématique seulement si sa sous-matrice m × m la plus à gauche est la matrice
identité (de taille m).
codage : le codage avec des codes linéaires est effectué par multiplication matricielle : le
mot u à coder est multiplié par une matrice génératrice du code choisie G, produisant
le mot de code z = u · G.
Si la matrice génératrice est sous forme systématique, les m premiers symboles du mot
de code sont exactement les symboles du message. Ainsi, seuls les n − m derniers
symboles doivent être calculés.
matrice de vérification : une matrice (n − m) × n H est une matrice de vérification pour
un code linéaire (n, m) C si et seulement si
∀z ∈ GF(D)n z · H T = 0 ⇐⇒ z ∈ C
La matrice de vérification est très utile pour le décodage.

syndrome : le résultat du produit d’un mot par la matrice de vérification : s = z · H T .
Le syndrome est utilisé pour déterminer l’erreur à corriger. Il correspond en effet à
la combinaison linéaire de colonnes de H qui est précisément le produit du schéma
d’erreur par H T .
codes de Hamming binaires : – des codes linéaires (2r −1, 2r −r−1) qui peuvent corriger
tous les schémas à 1 erreur ;
– la matrice de vérification est donnée sous la forme de l’énumération binaire des
colonnes.
11.3. CODES CYCLIQUES 195
11.3 Codes cycliques

1. ce qu’est en fait un code cyclique ;
2. comment (et pourquoi !) représenter des mots de code en utilisant des poly-
nômes ;
3. comment coder et décoder des codes cycliques en utilisant le polynôme géné-
rateur.
11.3.1 Introduction
Bien que les codes cycliques soient la catégorie de codes correcteurs d’erreurs dont l’utilisation
est la plus répandue, seule une introduction très courte de ce sujet est présentée ici. En effet, une
présentation approfondie des codes cycliques constituerait à elle seule un cours à part entière,
et est donc hors de propos ici. Le lecteur intéressé à approfondir le sujet pourra se référer à la
littérature plutôt vaste dans de ce domaine.
Définition 11.14 Un code cyclique∗ est un code linéaire tel que, pour tout mot de
code zi à n symboles zi = zi,1 ...zi,n , le mot zi,2 ...zi,n zi,1 résultant d’une permutation
cyclique (vers la gauche) (aussi appelée « décalage ») des symboles de zi soit aussi
un mot de code. ¨
Notez que cette définition implique alors que toute permutation cyclique d’un mot de code soit
aussi un mot de code.
Exemple 11.20 (Code cyclique) Le code linéaire (binaire) suivant est un code cyclique :
z1 = 000, z2 = 101, z3 = 011, z4 = 110
Réciproquement, le code suivant
z1 = 000, z2 = 001, z3 = 010, z4 = 011
(qui est linéaire) n’est pas cyclique car, par exemple, la permutation cyclique 100 de z3 n’est
pas un mot de code.
Les codes cycliques sont une sous-catégorie importante des codes linéaires car ils possèdent
beaucoup de propriétés algébriques qui simplifient les implémentations du codage et du déco-
dage.
Évaluation 55
Pour chacun des codes binaires suivants, spécifiez s’il s’agit ou non d’un code cyclique.
1. C = {0000, 1000, 0001, 1001}
2. C = {1000, 0001, 0100, 0010}
3. C = {000, 100, 010, 001, 110, 011, 111, 101}

4. C = {0000, 0001, 0010, 0011}
5. C = {00, 11, 10, 01}
11.3.2 Codes cycliques et polynômes
De manière à prendre en compte algébriquement cette nouvelle contrainte (les permutations

cycliques de mots de code sont aussi des mots de code), une structure algébrique plus com-
plète que celle d’espace vectoriel (qui rend compte de la linéarité) est requise. L’algèbre des
polynômes est justement une bonne manière de représenter cette nouvelle contrainte.
En effet, supposons qu’un mot de code zi à n symboles zi = zi,1 ...zi,n soit représenté par
le polynôme zi (X) = zi,1 · X n−1 + zi,2 · X n−2 + ... + zi,n−1 · X + zi,n , c.-à-d. que le j-
ème symbole zi,j d’un mot de code zi de taille n soit le coefficient de X n−j dans le polynôme
correspondant zi (X). Qu’est alors X ·zi (X) modulo (X n −1) ? Un peu d’algèbre polynômiale
montre directement que ceci correspond à la permutation cyclique vers la gauche de zi .
D ÉMONSTRATION Prouvons que la multiplication par le monôme correspond à une permu-

tation cyclique vers la gauche.
 
n
X
X · zi (X) = X ·  zi,j · X n−j 
j=1
n
X
= zi,j · X n−j+1
j=1
n−1
X
= zi,k+1 · X n−k
k=0
n−1
X
= zi,1 · X n + zi,k+1 · X n−k
k=1
Travailler en « modulo (X n − 1) » signifie simplement que X n correspond à 1,12 X n+1

correspond à X, etc. Ainsi zi,1 · X n mod (X n − 1) est égal à zi,1 , et l’équation ci-dessus,
modulo (X n − 1), donne
n−1
X
X · zi (X) = zi,1 + zi,k+1 · X n−k
k=1
n−1
X
= zi,k+1 · X n−k + zi,1 · X n−n
k=1
ce qui correspond effectivement au mot de code zi,2 ...zi,n zi,1 , le résultat du décalage vers la
gauche de zi . ¥
Comme les codes cycliques traitent justement de la permutation cyclique de leurs mots de
code, les polynômes semblent être un moyen tout à fait approprié pour les représenter. Cet
aspect sera approfondi après un court exemple.
Exemple 11.21 (Arithmétique modulo (X n − 1)) Voici un court exemple d’un calcul
modulo (X n − 1) :
(X 2 + 1) · (X + 1) = X 3 + X 2 + X + 1
= 1 + X 2 + X + 1 mod (X 3 − 1)
= X 2 + X + (1 + 1) mod (X 3 − 1)
= X2 + X mod (X 3 − 1)
car en binaire 1 + 1 = 0.
Exemple 11.22 (Représentation polynômiale d’un code cyclique) Revenons sur le code
cyclique binaire de l’exemple précédent :
z1 = 000 z2 = 101 z3 = 011 z4 = 110
La représentation polynômiale de ce code est :
z1 (X) = 0
z2 (X) = 1 · X 2 + 0 · X + 1 = X 2 + 1
z3 (X) = 0 · X 2 + 1 · X + 1 = X + 1
z4 (X) = 1 · X 2 + 1 · X + 0 = X 2 + X
Notez en outre que X · z2 (X) = z3 (X) mod (X 3 − 1), ce qui est l’expression du fait que
z3 est le décalage vers la gauche de z2 .
Évaluation 56
Quelle est la représentation polynômiale des mots de code suivants :

1. 00000000
2. 10001
3. 0000001
4. 1111
Évaluation 57
Considérant les deux mots de code z1 et z2 d’un code cyclique, que vaut z1 · z2 dans les cas
suivants :
1. z1 = 010110, z2 = 000100
2. z1 = 1010, z2 = 0101
3. z1 = 11001, z2 = 01010
La condition définissant les codes cycliques peut maintenant être utilisée pour caractériser plus
avant les codes cycliques en utilisant les propriétés des polynômes :
Propriété 11.14 Si z(X) est le polynôme correspondant à un mot de code z d’un

code cyclique de taille n, alors, pour tout polynôme p(X), p(X) · z(X) mod (X n −
1) est aussi un polynôme correspondant à un mot de code de ce code (décalages vers
la gauche et combinaisons linéaires).
D ÉMONSTRATION – pour tout k, X k · z(X) mod (X n − 1) est aussi un polynôme corres-

pondant à un mot de code de ce code (décalages vers la gauche)
– un code cyclique est un code linéaire, donc toute combinaison linéaire de mots de code est
aussi un mot de code.
Théorème 11.5 Pour tout code cyclique (n, m) C, il existe un polynôme gC (X) de
degré n − m tel que
C = {gC (X) · p : p ∈ GF(X), deg(p) < m}
c.-à-d. que tout polynôme d’un mot de code est un multiple de gC (X), et réciproque-
ment.
En d’autres termes, le code C est généré par gC (X). gC (X) est en fait appelé le
générateur de C.
Le codage d’un mot u en utilisant un code cyclique C pourrait alors simplement consister
à envoyer z(X) = u(X) · gC (X). Toutefois, le codage sous forme systématique, c.-à-d. le
codage de manière à ce que les premiers symboles correspondent au message lui-même, est
souvent préféré.
Pour un code cyclique (n, m), la procédure est alors la suivante :
1. multiplier le polynôme du message u(X) par X n−m (ce qui revient en pratique à effec-
tuer n − m décalages vers la gauche sur le message) Notez que n − m est le degré du
générateur.
2. diviser X n−m u(X) par le générateur g(X) et obtenir le reste r(X)
3. le codage de u(X) est alors z(X) = X n−m u(X) − r(X) (qui est un multiple de g(X),
dont les m symboles les plus élevés correspondent aux m symboles de u).
Exemple 11.23 (Codage systématique avec un code cyclique) Considérons par exemple
le code cyclique binaire (7, 4)
z1 = 0000000, z2 = 0001011, z3 = 0010110, z4 = 0101100,
z5 = 1011000, z6 = 0110001, z7 = 1100010, z8 = 1000101,

z9 = 1010011, z10 = 0100111, z11 = 1001110, z12 = 0011101,
z13 = 0111010, z14 = 1110100, z15 = 1101001, z16 = 1111111
Ce code a pour générateur g(X) = z2 (X) = X 3 + X + 1.

[Il est laissé comme exercice de vérifier que z2 (X) est effectivement un générateur de ce
code.]
En utilisant ce code, nous voulons transmettre le message u = 1101, c.-à-d. u(X) = X 3 +
X 2 + 1.
Divisons tout d’abord X 3 u(X) = X 6 + X 5 + X 3 par g(X) :
X 6 +X 5 + X3 X3 + X + 1
6
X + X +X 3
4 X3 + X2 + X + 1
X 5+ X 3 +X 2
4
X + X 2 +X
X 3+ X+1
1
c.-à-d. X 3 u(X) = (X 3 + X 2 + X + 1)g(X) + 1.

Le mot de code est donc z(X) = X 3 u(X)+1 = X 6 +X 5 +X 3 +1, qui représente 1101001.
En résumé : le message 1101 est codé 1101001 à l’aide du code cyclique ci-dessus. Notez
que, comme attendu, les 4 premiers bits sont les bits du message originel u.
Évaluation 58
Comment les messages suivants sont-ils codés sous forme systématique avec un code, dont le
générateur est g(X) = X 6 + X 3 + 1 :
1. 000
2. 111
3. 101
11.3.3 Décodage
Nous savons maintenant comment coder des messages avec des codes cycliques. Qu’en est-il
alors du décodage ?
Le processus de décodage est similaire au cadre utilisé pour les codes linéaires en général :
1. d’abord calculer un syndrome à partir du mot reçu (qui ne dépend que de l’erreur, pas
du mot émis, et qui est nul lorsque le mot reçu est un mot de code)
2. en déduire le correcteur (l’opposé de l’erreur)
3. finalement, appliquer le correcteur au mot de code reçu.
La construction du syndrome d’un mot zb(X) est simple : c’est le reste de la division de zb(X)
par le générateur g(X) de ce code.
En effet, nous savons que chaque mot de code z(X) est un multiple de g(X). Le reste de
z(X) + e(X) (par rapport à g(X)) est le même que celui de e(X) :
¾
z(X) = α(X)g(X)
=⇒ z(X) + e(X) = [α(X) + β(X)]g(X) + s(X)
e(X) = β(X)g(X) + s(X)
avec deg(s(X)) < deg(g(X)).

Il ressort en outre clairement de la construction ci-dessus que le syndrome s(X) est nul si et
seulement si zb(X) est un mot de code (c.-à-d. multiple de g(X)).
Les correcteurs, qui correspondent à tous les syndromes non nuls, peuvent être obtenus par
division par g(X). Notez que
– pour une erreur seule X i de degré i inférieur à n − m (le degré de g(X)), le syndrome est
simplement X i ;
– pour l’erreur seule X (n−m) , le syndrome est X (n−m) − g(X).
Exemple 11.24 (Décodage avec un code cyclique) Continuons l’exemple précédent : le
message 1101 a été codé en 1101001 et est maintenant transmis à travers un canal bruité.
Supposons que le second symbole ait été changé, c.-à-d. que nous recevions 1001001. Quel
est le mot décodé correspondant ?
1001001 correspond à zb(X) = X 6 + X 3 + 1, dont la division par g(X) donne :
X 6+ X 3+ 1 X3 + X + 1
X +X +X 3
6 4 X3 + X
X 4+ X 2 +X
X 2 +X+1
Le syndrome est donc ici X 2 + X + 1.

Le tableau correcteur/syndrome pour g(X) = X 3 + X + 1 est le suivant :
syndrome correcteur
1 1
X X
X2 X2
X +1 X3
X2 + X X4
X2 + X + 1 X5
X2 + 1 X6
[Les quatre premières lignes ont été obtenues en utilisant les remarques ci-dessus. Les trois
dernières par division de l’erreur par g(X)]
Nous avons donc trouvé que le correcteur doit être X 5 et que le mot décodé est finalement
z(X) = zb(X) + X 5 = X 6 + X 5 + X 3 + 1, c.-à-d. 1101001.
Comme un code systématique a été utilisé, les 4 premiers symboles de ce mot de code sont
les 4 bits du message originel : 1101.
Évaluation 59
Considérons le code linéaire (7, 4) dont le générateur est g(X) = X 3 + X 2 + 1. Comment les
messages reçus suivants seront-ils décodés ?
1. 1001011
2. 1011001
3. 0000001
(en supposant un codage sous forme systématique).
11.4. CODES CONVOLUTIONNELS 201
Code cyclique : un code linéaire tel que tout décalage (des symboles) de tout mot de code
est aussi un mot de code.
représentation polynômiale : z = z1 ...zn est représenté par le polynôme z(X) = z1 ·
X n−1 + z2 · X n−2 + ... + zn−1 · X + zn , c.-à-d. que le j-ème symbole zj d’un mot de
code z de taille n est le coefficient de X n−j dans le polynôme correspondant z(X).
La multiplication polynômiale par X (monôme du premier degré) correspond au déca-
lage (d’une position) vers la gauche.
Toutes les opérations sont faites modulo X n − 1.
générateur : Pour tout code cyclique, il existe un polynôme tel que tout polynôme représen-
tant un mot de code en soit multiple, et réciproquement.
codage sous forme systématique : La méthode de codage telle que les m premiers sym-
boles d’un mot de code sont exactement les m symboles du message codé.
Pour les codes cycliques, le codage sous forme systématique est accompli par les étapes
suivantes :
1. multiplier le polynôme du message u(X) par X n−m
3. coder u(X) par z(X) = X n−m u(X) − r(X).
décodage : Le processus de décodage est similaire au cadre utilisé pour les codes linéaires
en général :
1. calculer le syndrome du mot reçu : c’est le reste de la division de ce mot par le
générateur du code ;
2. en déduire le correcteur à partir d’un calcul préalable de la correspondance syn-
dromes/correcteurs (la multiplication du générateur par le correcteur donne le
syndrome)
3. finalement, appliquer le correcteur au mot de code reçu et décoder les mots ori-
ginels comme les m premiers symboles du mot de code décodé (à condition que
le codage systématique ait été utilisé).
11.4 Codes convolutionnels

Après l’étude de cette section, vous devriez savoir :
1. ce que sont les codes convolutionnels ;
2. comment le codage de tels codes est réalisé ;
3. ce que sont un état et un diagramme d’état ;
4. ce qu’est la représentation par treillis associée à un code convolutionnel ;
5. comment utiliser l’algorithme de Viterbi sur les treillis pour effectuer du déco-
dage à distance minimale ;
6. comment calculer la distance minimale d’un code convolutionnel.
z 2i−1
+
mise en série
z 2i−1z 2i
ui u i−1 u i−2
+
z 2i
F IG . 11.1 – Un premier exemple d’un code convolutionnel. Chaque symbole du message ui

est codé en deux symboles du mot de code z2i−1 et z2i .
11.4.1 Introduction
Dans cette section, un schéma de codage qui n’est pas par bloc est considéré : les codes convo-
lutionnels. Les codes convolutionnels diffèrent des codes par bloc par le fait que le mécanisme
de codage garde en mémoire les symboles codés.
En un sens, les codes convolutionnels peuvent être considérés comme des codes par bloc sans
limites, c.-à-d. des codes par bloc avec des blocs de taille « infinie ». Toutefois, il y a une
différence significative dans la conception de ces techniques de codage/décodage. En outre,
les codes convolutionnels se sont montrés bien supérieurs aux codes par bloc dans beaucoup
d’applications.
11.4.2 Codage
Le point de départ d’un code convolutionnel est le codeur. Plutôt que de commencer avec
des définitions précises et une analyse générale des codes convolutionnels, nous préférerons
commencer avec un exemple simple qui contient toutefois les caractéristiques principales du
codage convolutionnel.
Le codeur de l’exemple choisi pour cette section est représenté dans la figure 11.1.
A chaque pas de temps i, un symbole ui du message entre dans le codeur et deux sym-
boles de mot de code z2i−1 z2i sont émis ; c.-à-d. que u = (u1 , ..., ui , ...) est codé en z =
(z1 , z2 , ..., z2i−1 , z2i , ...). Le taux de ce code est donc 1/2.
Les symboles ui du message et les symboles zj du mot de code considérés ici sont tous des
chiffres binaires. Les additions montrées dans la figure 11.1 sont des additions binaires (c.-à-d.
des « ou exclusifs »).
De manière plus formelle, le codeur représenté dans la figure 11.1 peut être écrit comme
z2i−1 = ui + ui−2 (11.1)

z2i = ui + ui−1 + ui−2 (11.2)
c.-à-d.
ui 7→ (ui−2 + ui , ui−2 + ui−1 + ui )
Ces équations peuvent être vues comme une « convolution discrète » de la séquence d’entrée
avec les séquences 1, 0, 1, 0, 0, . . . et 1, 1, 1, 0, 0, . . . respectivement. Ceci explique le terme de
« code convolutionnel ».
Toutefois, ni les équations ci-dessus, ni la figure 11.1 ne déterminent complètement les mots de
code, comme les valeurs de ui−2 et de ui−1 sont requises. Quelles sont-elles au temps i = 1,
c.-à-d. quel est l’état initial du système ?
La convention est qu’ils sont toujours nuls, c.-à-d. u−1 = u0 = 0.
Pour être sûr que ce soit toujours le cas, c.-à-d. que chaque fois qu’un nouveau message doit
être codé l’état initial du codeur soit toujours 0 dans toutes les mémoires, le codage d’un
message précédent doit laisser le codeur dans cet état nul. Tout codage d’un message doit
donc contenir assez de zéros à la fin pour être sûr que toutes les mémoires du système soient
revenues à 0. Dans le cas de le codeur présenté dans la figure 11.1, ceci revient à dire que le
codage de chaque message se terminera par le codage de deux zéros ou plus.
Exemple 11.25 (Codage avec un code convolutionnel) Supposons vouloir envoyer le mes-
sage u = 101 en utilisant le codeur représenté dans la figure 11.1. Comment cela marche-t-
il ?
Traçons tous les composants du codage :
i ui État z2i−1 z2i

(ui−1 ui−2 )
1 1 00 11
2 0 10 01
3 1 01 00
4 (0) 10 01
5 (0) 01 11
Le mot de code correspondant est alors z = 1101000111.

Les deux dernières lignes correspondent aux deux bits zéro qui doivent être introduits dans
le codeur à la fin de chaque message pour le remettre dans son état initial.
Évaluation 60
Considérons le code convolutionnel, dont le codeur est décrit par le diagramme suivant :
z 4i−3
+
z 4i−2
mise en série
+ z 4i−3 z 4i−2 z 4i−1 z 4i

ui u i−1 u i−2 u i−3 z 4i−1
+
z 4i
+
1. Combien de zéros doivent être ajoutés après chaque mot à coder ?

(a) 1
(b) 2
(c) 3
(d) 4
(e) 5
2. Comment le texte 10110 est-il codé ?

(a) 0011110010101000100111100111
(b) 10110
(c) 00111100101010000101111001110000
(d) 0010010110011010110001001001
(e) 11110000111111110000000000000000
(f) 11000011010100011010011111100000
Demandons-nous maintenant quel est en général le code généré par le codeur représenté dans
la figure 11.1 ?
Considérons par exemple un message de 3 bits u = (u1 , u2 , u3 ). Comme nous l’avons vu, ce
qui doit être effectivement codé est (u1 , u2 , u3 , 0, 0), c.-à-d. que deux bits zéro sont ajoutés à
la fin du message originel de façon à remettre la mémoire du codeur dans son état initial. La
taille du mot de code correspondant est ainsi 2 · 5 = 10.
Les bits de ces mots de code sont donnés par les équations (11.1) et (11.2), c.-à-d. sous forme
matricielle :  
1 1
(z2i−1 , z2i ) = (ui−2 , ui−1 , ui ) ·  0 1  (11.3)
1 1
Le mot de code entier z est ainsi obtenu en multipliant (u1 , u2 , u3 , 0, 0) par la matrice
 
1 1 0 1 1 1 0 0 0 0
 0 0 1 1 0 1 1 1 0 0 
 
G3 = 
 0 0 0 0 1 1 0 1 1 1 ,

 0 0 0 0 0 0 1 1 0 1 
0 0 0 0 0 0 0 0 1 1
ou, plus simplement, en multipliant u = (u1 , u2 , u3 ) par

 
1 1 0 1 1 1 0 0 0 0
G3 =  0 0 1 1 0 1 1 1 0 0  .
0 0 0 0 1 1 0 1 1 1
Le mot de code est donc z = u · G3 .

Pour un message de longueur m, ceci se généralise à z = u · Gm où Gm est la matrice m ×
(2 m + 4) faite de décalages d’une ligne et de deux colonnes de la matrice-bloc de l’équation
(11.3).
Ce résultat est vrai en général, indépendamment de la longueur du message codé. Ceci illustre
pourquoi les codes convolutionnels sont présentés comme des codes par bloc linéaires « infi-
nis » (i.e. non bornés).
11.4.3 Définition générale
Donnons maintenant une définition générale des codes convolutionnels.

Définition 11.15 Un code convolutionnel (n, k, r) D-aire est un code linéaire non
borné, dont la matrice génératrice est de la forme suivante (infinie) :
 
F0 F1 F2 · · · Fr [0] [0] [0] · · ·
 [0] F0 F1 · · · Fr−1 Fr [0] [0] · · · 
 
G =  [0] [0] F · · · F 
 0 r−2 Fr−1 Fr [0] · · · 
.. .. . . .. .. ..
. . . . . .
avec Fi une matrice k × n, et [0] la matrice nulle k × n ; c.-à-d. que chaque ensemble
de k lignes de G est le même que l’ensemble de k lignes précédent mais décalé de n
places vers la droite.
Un message u de longueur finie m, u = (u1 , §..., ¨um ) est codé en z = u · Gm′ où u
est le vecteur de longueur m′ = qk, avec q = m k , tel que u = (u1 , ..., um , 0, ..., 0),
et où Gm′ est la sous-matrice supérieure gauche de G de taille qk × n(r + q).
Notez que u = u, c.-à-d. que m′ = m si m est un multiple de k (en particulier lorsque
k = 1 !). ¨
Dans la définition ci-dessus, k correspond en fait au nombre de symboles du message qui vont
dans le codeur (k lignes d’entrée), n est le nombre de symboles de mot de code sortants par
entrée (n lignes de sortie) et r le nombre maximal de mémoires (aussi appelées « registres »)
sur une ligne d’entrée.
Exemple 11.26 Le codeur montré en exemple dans la figure 11.1 construit un code convo-
lutionnel (2, 1, 2) : k = 1 ligne d’entrée avec r = 2 mémoires, produisant n = 2 bits de mot
de code pour chaque bit d’entrée.
Comme nous l’avons vu dans la section 11.4.2, pour un message d’entrée de longueur 3, sa
matrice génératrice est la matrice 3 × 10
 
1 1 0 1 1 1 0 0 0 0
 
G3 =  0 0 1 1 0 1 1 1 0 0 
0 0 0 0 1 1 0 1 1 1
où chaque ligne (« ensemble de k = 1 ligne(s) ») est en fait un décalage de 2 pas vers la

gauche de la ligne supérieure.
Par rapport à la définition, nous avons pour la matrice G3 ci-dessus :
– F0 = [ 1 1 ], qui correspond aux deux coefficients de ui dans les équations (11.1) et (11.2),
– F1 = [ 0 1 ], qui correspond aux deux coefficients de ui−1 ,
– et F2 = [ 1 1 ], qui correspond aux deux coefficients de ui−2 .
Notez que les codes convolutionnels sont linéaires : toute combinaison de mots de code est
aussi un mot de code (avec la convention que les mots de code plus courts sont rallongés avec
des zéros à la fin pour que la combinaison linéaire ait un sens, c.-à-d. que tous les mots ajoutés
aient la même longueur).
Évaluation 61
1. Que vaut (n, k, r) du code convolutionnel donné dans la dernière question ?

(a) (1, 3, 4)
(b) (7, 4, 1)
(c) (3, 1, 4)
(d) (4, 1, 3)
(e) (7, 1, 4)
(f) (1, 3, 7)
2. Quelle est la matrice génératrice de ce code ?
(a) Combien de blocs F y a-t-il ?
(b) Quelle est la taille de chaque bloc F : ?×? ?
(c) Donnez tous les blocs F .
11.4.4 Représentation sous forme de treillis
L’ « état » d’un système est l’ensemble des paramètres internes (mémoires, aussi appelées
« registres ») requis pour calculer la sortie correspondant à un bloc d’entrée donné. Pour le
codeur de la figure 11.1 par exemple, l’état au temps i est le contenu actuel des deux mémoires,
c.-à-d. Si = (ui−1 , ui−2 ).
Le comportement du codeur ne dépend que de son état et de l’entrée : un codeur à code
convolutionnel est une machine à état. L’ensemble de son fonctionnement est décrit par un
diagramme d’état.
Définition 11.16 (Diagramme d’État) Le diagramme d’état d’un codeur est un

graphe dont les nœuds sont tous les états internes possibles du codeur. Un arc entre
un nœud Si et un nœud Sj dans ce graphe représente le fait qu’il existe une entrée
qui, lorsqu’elle est reçue dans l’état Si met le codeur dans l’état Sj .
Ces arcs sont habituellement étiquetés avec le(s) symbole(s) d’entrée et les symboles
de sortie correspondants. ¨
Exemple 11.27 (Diagramme d’État) Par exemple, pour le codeur de la figure 11.1, nous
avons :
1 / 01
u i / z 2i-1 z 2i
11
1 / 10 0 / 10
0 / 01
10 01
1 / 00
1 / 11 0 / 11
00
0 / 00
où chaque nœud représente l’état du codeur c.-à-d. l’état des deux mémoires internes, le
label bleu est l’entrée qui provoque le changement d’état , et le rouge les symboles de sortie
correspondants.
Si par exemple, dans l’état 01, un 1 est reçu comme symbole d’entrée, l’état devient alors
10 et les deux symboles de sortie sont 00.
L’ensemble des mots de code d’un code convolutionnel (n, k, r), correspondant à tous les
messages
§m¨ de m bits possibles, est donc l’ensemble de toutes les séquences (de taille n(r +
k )) correspondant à tous les chemins de longueur m dans le diagramme d’état partant de
l’état nul (zéro partout) et reviennent à cet état nul.
Le déploiement dans le temps de tous les chemins de même longueur dans le diagramme d’état
est appelé treillis∗ de taille m du code convolutionnel (n, k, r).
Exemple 11.28 (Treillis) Pour le code (2, 1, 2) considéré dans les exemples précédents, le
treillis de longueur m = 3, représentant les codages de tous les messages d’entrée de 3 bits
est :
01
11 11
10 10
10
10
01 01 01
01 01
01 00
11
10 10 10 11
11
11 11
11
00 00 00 00 00
00 00 00 00 00 00
dans lequel l’arc le plus (dirigé vers le) haut sortant d’un nœud correspond au bit d’entrée 1
et le plus bas à 0.
Les trois premières colonnes d’arcs correspondent donc au codage de messages de 3 bits, et
les deux dernières colonnes d’arcs correspondent aux zéros terminaux13 , ces dernières n’ont
donc que des arcs pointant au plus bas.
Exemple 11.29 (Codage dans le Treillis) Par exemple, le codage du message u = 101 cor-
respond au chemin suivant :
01
11 11
10 10
10
10
01 01 01
01 01
01 00
11
11
10 10 10
11
11 11
11
00 00 00 00 00
00 00 00 00 00 00
c.-à-d. au mot de code z = 1101000111.
Évaluation 62
Considérons le treillis correspondant au codage d’un message de longueur 4 avec le codeur de

la question de contrôle précédente.
Combien de colonnes d’états a-t-il ?

Pour chaque colonne, combien d’états y a-t-il ?
Donnez, pour les paires d’états suivantes, quel est le label de l’arc. Si aucun arc n’est présent,
répondez « pas d’arc » :
100 et 010 :
101 et 110 :
001 et 111 :
111 et 011 :
11.4.5 Décodage
Comme nous venons de le voir, un mot de code correspond à un chemin du nœud de départ au
nœud de fin du treillis.
Le décodage consiste alors à trouver le chemin le plus approprié correspondant au message
reçu à décoder. Dans le cadre du décodage à distance minimale, c.-à-d. le décodage du mot
de code avec un nombre minimal d’erreurs, « le chemin le plus approprié » signifie le chemin
avec la distance de Hamming minimale par rapport au message à décoder.
La recherche de ce chemin « le plus proche » peut être effectuée en utilisant la programmation
dynamique, c.-à-d. l’algorithme de Viterbi.
Cet algorithme décode un bloc de mot de code après l’autre (c.-à-d. des paquets de n bits du
message les uns après les autres), en ne gardant à chaque étape que les solutions localement op-
timales, c.-à-d. gardant, pour chaque nœud dans la colonne correspondant au bloc couramment
décodé, le meilleur chemin menant à ce nœud.
A la fin, le meilleur chemin trouvé pour le dernier nœud est le message décodé.
Ce qui est important et utile à propos de cet algorithme est que le nombre de meilleurs chemins
possibles qui sont gardés à chaque étape de temps est toujours inférieur ou égal au nombre
d’états de le codeur.
Donnons maintenant plus de précisions sur l’algorithme.
Introduisons tout d’abord un peu de notation. Pour chaque état s du codeur, soit γi (s) le
meilleur (c.-à-d. le plus proche, c.-à-d. avec un nombre d’erreurs minimal) décodage de lon-
gueur i finissant dans l’état s
γi (s) = min
z1 ,...,z2i
d(z1 ...z2i , zb1 ...b
z2i )
finissant en s
¡ n
¢
Le décodage complet correspond donc à γ|bz | (00) |b
z| = m + 2 = 2 ici où |b
z | est la longueur
du message à décoder.
Il est facile de voir que pour toute paire d’états de codage (s, s′ ), nous avons :
³ ´
γi (s) = z minz d(z2i−1 z2i , zb2i−1 zb2i ) + γi−1 (s′ ) .
2i−1 2i
de s′ à s
Ceci donne l’algorithme suivant (algorithme de Viterbi) :

γ0 (00) = 0
Pouri de 1 à |b
z|
Pour touts
γi (s) = min
′
(d(z2i−1 z2i , zb2i−1 zb2i ) + γi−1 (s′ ))
s →s
Marquer le/un arc de s′ à s qui réalise le minimum
Reconstruire le chemin optimal en sens inverse, de l’état final à l’état nul initial.
Exemple 11.30 Supposons que le mot de code z = 1101000111 soit envoyé à travers un
canal bruité et que zb = 0101010111 soit reçu, c.-à-d. que deux erreurs soient survenues.
L’algorithme ci-dessus passera donc par les étapes suivantes, où le nombre minimal d’erreurs
γi (s) à ce point i est écrit en rouge au-dessus de chaque état s dans le treillis :
11 11
01 01 01
1
10 10 10
0 1
00 00 00 00 00
s
Donc dmin (C) = 5.
Évaluation 64
Quelle est la distance minimale du codeur donné dans les questions de contrôle précédentes ?
e-nnexe : Convolution Code
code convolutionnel : Un code convolutionnel (n, k, r) D-aire est un code linéaire illimité,
dont la matrice génératrice (infinie) est telle que chaque ensemble de k lignes est le
même que l’ensemble de k lignes précédent, mais décalé de n positions vers la droite.
Ceci correspond à la description matricielle de l’algorithme de codage, qui est souvent
donné sous forme de dessin d’un circuit avec k lignes d’entrée, n lignes de sortie et au
plus r mémoires sur un chemin d’entrée vers sortie.
codage : Un ¨ ′ u de longueur finie m, u = (u1 , ...,′ um ) est codé en z = u · Gm′ où
§ mmessage
q = k , m = qk, u est le vecteur de longueur m tel que u = (u1 , ..., um , 0, ..., 0),
et Gm′ la matrice supérieure gauche de taille qk × n(r + q) de la matrice génératrice.
état (interne) du codeur : l’ensemble des états des mémoires (ou registres) du codeur.
diagramme d’état : Le diagramme d’état d’un codeur est un graphe, dont les nœuds sont
tous les états internes possibles du codeur. Un arc entre un nœud Si et un nœud Sj
dans ce graphe représente le fait qu’il existe une entrée qui, lorsqu’elle est reçue dans
l’état Si amène le codeur dans l’état Sj .
Ces arcs sont étiquetés avec le(s) symbole(s) d’entrée et les symboles de sortie corres-
pondants.
représentation par treillis : La représentation du déploiement dans le temps de tous les
chemins possibles du diagramme d’état.
algorithme de décodage de Viterbi : L’algorithme de programmation dynamique qui, pour
un message à décoder donné, trouve le chemin « le plus court » (en termes d’erreurs)
dans le treillis.
code par bloc : un ensemble non vide de mots de même longueur, considérés comme des
« vecteurs ligne ».
poids : (d’un mot) le nombre de symboles non nuls.
distance de Hamming : le nombre de coordonnées par lesquelles deux vecteurs diffèrent.
La distance de Hamming entre deux mots est le poids de leur différence.
décodage à distance minimale : structure de correction d’erreurs dans laquelle chaque mot
reçu est décodé en le mot de code le plus proche (d’après la distance de Hamming).
décodage à vraisemblance maximale : structure de correction d’erreurs dans laquelle
chaque mot reçu zb est décodé en le (un des) mot(s) le(s) plus vraisemblable(s) z, c.-à-d.
un mot de code tel que P (Y = zb|X = z) soit maximale (avec X l’entrée du canal
bruité et Y sa sortie).
distance minimale d’un code : la distance de Hamming minimale (non nulle) entre toute
paire de mots de code (différents).
capacité de correction et de détection d’erreurs : Un code par bloc C de longueur n uti-
lisant le décodage à distance minimale peut, pour toute paire d’entiers t et s tels que
0 ≤ t ≤ n et 0 ≤ s ≤ n − t, corriger tous les schémas à t ou moins erreurs et détecter
tous les schémas à t+1, ..., t+s erreurs si et seulement si sa distance minimale dmin (C)
est strictement supérieure à 2t + s :
dmin (C) > 2t + s ⇐⇒ C corrige t et détecte t + s erreurs.
code linéaire : un code par bloc qui est un espace vectoriel (c.-à-d. que toute combinaison
de mots de code est aussi un mot de code).
Un code linéaire (n, m) D-aire est un sous-espace vectoriel de dimension m de l’es-
pace vectoriel de dimension n de mots de code D-aires.
distance minimale d’un code linéaire : pour les codes linéaires, la distance minimale est
égale au poids minimal.
matrice génératrice d’un code linéaire : (d’un code linéaire (n, m)) une matrice m × n
dont les lignes sont une base du code (elle sont donc linéairement indépendantes).
forme systématique de la matrice génératrice d’un code linéaire : une matrice généra-
trice m × n d’un code linéaire (n, m) est dite sous forme systématique seulement
si sa sous-matrice m × m la plus à gauche est la matrice identité (de taille m).
codage avec un code linéaire : le codage avec des codes linéaires est effectué par multipli-
cation avec une matrice : le mot u à coder est multiplié par une matrice génératrice du
code choisie G, produisant le mot de code z = u · G.
Si la matrice génératrice est sous forme systématique, les m premiers symboles du mot
de code sont exactement les symboles du message. Ainsi, seuls les n − m derniers
symboles doivent être calculés.
matrice de vérification d’un code linéaire : une matrice (n − m) × n H est une matrice de
vérification pour un code linéaire (n, m) C si et seulement si
∀z ∈ GF(D)n z · H T = 0 ⇐⇒ z ∈ C
La matrice de vérification est très utile pour le décodage.

syndrome d’un mot par rapport à un code linéaire : le résultat du produit d’un mot par la
matrice de vérification : s = z · H T .
Le syndrome est utilisé pour déterminer l’erreur à corriger. Il correspond en effet à
la combinaison linéaire de colonnes de H qui est précisément le produit du schéma
d’erreur par H T .
codes de Hamming binaires : – des codes linéaires (2r −1, 2r −r−1) qui peuvent corriger
tous les schémas à 1 erreur ;
– la matrice de vérification est donnée sous la forme de l’énumération binaire des
colonnes.
code cyclique : un code linéaire tel que tout décalage (des symboles) de tout mot de code
est aussi un mot de code.
représentation polynômiale de codes cycliques : z = z1 ...zn est représenté par le poly-
nôme z(X) = z1 · X n−1 + z2 · X n−2 + ... + zn−1 · X + zn , c.-à-d. que le j-ème
symbole zj d’un mot de code z de taille n est le coefficient de X n−j dans le polynôme
correspondant z(X).
La multiplication polynômiale par X (monôme du premier degré) correspond au déca-
lage (d’une position) vers la gauche.
Toutes les opérations sont faites modulo X n − 1.
générateur d’un code cyclique : Pour tout code cyclique, il existe un polynôme tel que tout
polynôme représentant un mot de code en soit multiple, et réciproquement.
codage sous forme systématique d’un code cyclique : La méthode de codage telle que les
m premiers symboles d’un mot de code sont exactement les m symboles du message
codé.
Pour les codes cycliques, le codage sous forme systématique est accompli par les étapes
suivantes :
1. multiplier le polynôme du message u(X) par X n−m
3. coder u(X) par z(X) = X n−m u(X) − r(X).
décodage avec les codes cycliques : Le processus de décodage est similaire au cadre utilisé
pour les codes linéaires en général :
1. calculer le syndrome du mot reçu : c’est le reste de la division de ce mot par le
générateur du code ;
2. en déduire le correcteur à partir d’un calcul préalable de la correspondance syn-
dromes/correcteurs (la multiplication du générateur par le correcteur donne le
syndrome)
3. finalement, appliquer le correcteur au mot de code reçu et décoder les mots ori-
ginels comme les m premiers symboles du mot de code décodé (à condition que
le codage systématique ait été utilisé).
code convolutionnel : Un code convolutionnel (n, k, r) D-aire est un code linéaire non li-
mité, dont la matrice génératrice (infinie) est telle que chaque ensemble de k lignes est
le même que l’ensemble de k lignes précédent, mais décalé de n places vers la droite.
Ceci correspond à la description matricielle de l’algorithme codeur, qui est souvent
donné sous forme de dessin d’un circuit avec k lignes d’entrée, n lignes de sortie et au
plus r mémoires sur un chemin d’entrée vers sortie.
codage avec un code convolutionnel §: Un ¨ message u de longueur finie m, u = (u1 , ..., um )
est codé en z = u · Gm′ où q = m k , m′ = qk, u est le vecteur de longueur m′ tel que
u = (u1 , ..., um , 0, ..., 0), et Gm′ la matrice supérieure gauche de taille qk × n(r + q)
de la matrice génératrice.
état (interne) du codeur d’un code convolutionnel : l’ensemble des états des mémoires
(ou registres) du codeur.
diagramme d’état : Le diagramme d’état d’un codeur est un graphe, dont les nœuds sont
tous les états internes possibles du codeur. Un arc entre un nœud Si et un nœud Sj
dans ce graphe représente le fait qu’il existe une entrée qui, lorsqu’elle est reçue dans
l’état Si amène le codeur dans l’état Sj .
Ces arcs sont étiquetés avec le(s) symbole(s) d’entrée et les symboles de sortie corres-
pondants.
représentation par treillis : La représentation du déploiement dans le temps de tous les
chemins possibles du diagramme d’état.
algorithme de décodage de Viterbi : L’algorithme de programmation dynamique qui, pour

un message à décoder donné, trouve le chemin « le plus court » (en termes d’erreurs)
dans le treillis.
Le travail sur les codes correcteurs d’erreurs est bien sûr parti du travail de pionnier de Shannon
en 1948. La conception de bons codes efficaces a commencé dans les années cinquante avec les
travaux de Hamming, Slepian et beaucoup d’autres. Pendant les années cinquante, la plupart
des travaux dans ce domaines étaient destinés au développement d’une vraie théorie du codage
(codes linéaires, codes par bloc et codes convolutionnels).
Les codes convolutionnels ont été présentés pour la première fois en 1955 par Elias [3] comme
une alternative aux codes par bloc. Wozencraft proposa plus tard une méthode de décodage
séquentiel efficace pour de tels codes [13]. Puis, en 1967, Viterbi proposa un algorithme de
décodage à vraisemblance maximale [12] assez facile à implémenter qui mène à plusieurs
applications des codes convolutionnels, en particulier aux communications avec les satellites
dans l’espace lointain.
Un déplacement de la théorie vers la pratique fut effectué dans les années soixante-dix, avec
une accroissement rapide des applications militaires et de communications spatiales.
Voir aussi [2], [6], [11] et [7].

Chapitre 12
12.1 Codes linéaires
Exercice 12.1.1:
Soit un code linéaire binaire de matrice génératrice1
 
1 0 0 1 1
G= 0 1 0 1 1 
0 0 1 0 0
a– Quelle est la matrice de vérification (sous forme systématique) ?
b– Quelle est alors la distance minimale de ce code ? Combien d’erreurs peut-il au plus corri-
ger ?
c– Combien ce code possède-t-il de mots (i.e. de vecteurs différents) ?
1
Lorsque la matrice génératrice n’est pas donnée sous forme systématique, pour obtenir la forme systématique
équivalente on transforme la matrice à l’aide de permutations sur les lignes et/ou sur les colonnes, multiplications
de ligne ou colonne par un scalaire non nul ou encore par addition de lignes (mais l’addition de colonnes est
interdite !).
215
Exercice 12.1.2:
Considérons le code linéaire binaire dont la partie parité est engendrée par les équations :
z5 = s2 + s3 + s4
z6 = s1 + s2 + s3
z7 = s1 + s2 + s4
z8 = s1 + s3 + s4
le mot de source étant composé des bits (u1 , u2 , u3 , u4 ) et le message codé : (z1 , z2 , z3 , z4 , z5 , z6 , z7 , z8 ).
a–
a– Quelle est la matrice génératrice de ce code (sous forme systématique) ?
b– Coder la séquence 010110010111.
c– Quelle est la matrice de vérification de ce code ?
d– Montrer que la distance minimale de ce code est 4.
e– Combien d’erreurs sur le mot transmis ce code peut-il corriger au maximum ? Combien
peut-il corriger de schémas d’erreur différents (c.-à-d. combien a-t-il de syndromes dif-
férents) ?
f– On envisage l’utilisation de ce code sur un canal symétrique binaire. Pour cela les 15 sché-
mas d’erreur à corriger choisis sont les 15 schémas d’erreur les plus probables. Écrire
la table de correction (c.-à-d. la table donnant pour chaque syndrome la correction à
appliquer).
g– À l’aide de la table précédente, décoder 1111110000001100.
Exercice 12.1.3:
On considère la matrice H de vérification du code de Hamming (7,4) vu en cours :

 
0 0 0 1 1 1 1
H= 0 1 1 0 0 1 1 
1 0 1 0 1 0 1
a– Un mot z = (z1 , ..., z7 ) fait partie du code de Hamming correspondant si et seulement

si : H ⊗ z T = 03 (où 03 est le vecteur colonne nul de dimension 3). Résoudre cette
équation en exprimant z5 , z6 et z7 en fonction de z1 , z2 , z3 et z4 . En déduire la forme
systématique de la matrice de codage G du code de Hamming dont H est la matrice de
vérification.
b– À partir de G, écrire la forme systématique H ′ de la matrice de vérification du code de
Hamming. Quel avantage présente la forme de l’énoncé ?
c– Coder 010110010111.
d– Décoder 0100110110011011011101100111.
e– Si l’on utilise ce code de Hamming sur un canal symétrique binaire de probabilité de chan-
gement p, quel taux d’erreur par bloc PB aura-t-on ? Que vaut le taux de transmission
R?
f– Que vaut, en première approximation, le taux d’erreur par bit ?
12.2 Codes cycliques
Exercice 12.2.1:
Tous les codes cycliques de longueur n possibles2 sont obtenus en utilisant comme polynôme
générateur un diviseur de X n − 1.
Montrer qu’il existe uniquement 3 codes cycliques binaires non triviaux de longueur 3. Donner
le polynôme générateur dans chaque cas.
Remarque : en binaire, c.-à-d. sur le corps GF(2), X n − 1 et X n + 1 sont les même polynômes.
12.3 Codes de convolution
Exercice 12.3.1:
Considérons le système de codage convolutif suivant, émettant 3 bits pour tout bit du message
à coder :
+ 1
Séquenceur
ui ui−1 ui−2 + 2 X
+ 3
1. Comment est codée la séquence 1011 ? et la séquence 11111 ?

2. Donner la forme matricielle équivalente au codage d’une séquence de 3 bits, c.-à-d. la
matrice G telle que X = uG.
3. Dessiner le treillis pour des messages d’entrée de 4 bits.
4. Décoder 111111101010100011 et 000101100010110011.
5. Quelle est la distance minimale de ce code ? Combien peut-il corriger d’erreurs au maxi-
mum ?
2
et non triviaux, c.-à-d. différent du code nul composé d’un seul mot de code, le vecteur nul
Exercice 12.3.2:
Considérons le système de codage convolutif suivant, traitant le message d’entrée à coder par
blocs de 2 bits et émettant 3 bits pour chaque ensemble de 2 bits du message d’entrée :
b u2 i u2 i−2 + 1
Séquenceur
u2 i u2 i+1 + 2
b u2 i+1 u2 i−1 + 3
1. Comment est codée la séquence 1011 ? et la séquence 1111 ?

2. Donner la forme matricielle équivalente au codage d’une séquence de 4 bits. Vérifier
avec les codes de la question précédente.
3. Dessiner le treillis pour des messages d’entrée de 4 bits.
4. Décoder 101001001.
5. Quelle est la distance minimale de ce code ? Combien peut il corriger d’erreurs au maxi-
mum ?
Chapitre 13
Module I3 : Cryptographie

Dans ce chapitre sont présentées les notions de base concernant la cryptographie.
Après les avoir étudiées, vous devriez savoir
1. ce que sont la sécurité parfaite et la sécurité en pratique,
2. le niveau de sécurisation des systèmes modernes de chiffrement,
3. pourquoi la sécurité et l’authentification sont théoriquement incompatibles,
4. ce que sont RSA et DES, et comment ils fonctionnent,
5. ce qu’est la distance d’unicité et comment la calculer.
Introduction
La cryptographie, comme le suggère sa racine grecque (« écriture cachée »), traite de la confi-
dentialité de l’information. Mais, dans son sens moderne, ce domaine scientifique couvre aussi
l’authenticité de l’information.
Dans cette « Ère de l’Information » dans laquelle nous vivons, la cryptographie ne peut plus
être ignorée. Elle est en effet devenue un outil standard, en particulier dans le domaine des
télécommunications. Comme l’information peut de nos jours être extrêmement précieuse et
avoir une valeur économique énorme, sa transmission par des canaux accessibles à tous, p.ex.
Internet, nécessite parfois une garantie de confidentialité et d’authenticité. Le but de la crypto-
graphie est de fournir de telles garanties.
Ce chapitre vous présente les notions de base de ce domaine plutôt moderne, et étudie de
manière plus formelle ses deux buts : la confidentialité et l’authenticité. En gros, le but de la
confidentialité est de s’assurer que le message est bien reçu par des personnes autorisées ; alors
que le but de l’authenticité est de s’assurer que le message a bien été envoyé par une personne
autorisée.
219
220 CHAPITRE 13. CRYPTOGRAPHIE
Fraudeur
DESTINATAIRE
cryptage décryptage
EXPÉDITEUR
C=e(M,K) D=d(C,K)
Message M canal public
Clé K
canal sécurisé
F IG . 13.1 – La structure générale sur laquelle se concentre la cryptographie.
13.1 Cadre Général

1. savoir de quoi traite la cryptographie ;
2. savoir comment décrire formellement le cadre général sur lequel se concentre
la cryptographie ;
3. et connaître plusieurs exemples historiques (pas sûrs) de chiffrement.
13.1.1 Buts de la Cryptographie
Le cadre général de la cryptographie est de coder des messages de manière à assurer leur
confidentialité ou leur authenticité.
Comme décrit dans le chapitre 5, un message M est une séquence de symboles d’un alphabet
Σ. En cryptographie, le codage du message est appelé cryptage ou chiffrement. Dans le cadre de
travail considéré dans ce chapitre, le cryptage sera effectué par l’utilisation d’une fonction e et
d’une clé K, qui est elle-même une séquence finie de symboles d’un alphabet, habituellement
mais pas nécessairement le même que l’alphabet du message Σ.
Le message crypté, ou cryptogramme, est alors C = e(M, K). La fonction de cryptage est
supposée ici déterministe. C est donc parfaitement déterminé une fois M et K donnés, c.-à-d.
H(C|M, K) = 0.
Le décryptage (ou déchiffrement) est effectué par une fonction d et la clé K, telle que (sans
surprise !) d(e(M, K), K) = M . Nous faisons l’hypothèse que le décryptage aussi est déter-
ministe, c.-à-d. H(M |C, K) = 0.
Notez que H(C|M, K) = 0 et H(M |C, K) = 0 n’impliquent pas que H(K|M, C) = 0 ;
plusieurs clés pourraient effectivement être possibles pour une paire (M, C) donnée. C’est
toutefois rarement le cas (et une mauvaise idée) en pratique, et donc H(K|M, C) vaut aussi
presque toujours 0.
La structure générale sur laquelle se concentre la cryptographie peut être résumée par le dessin
de la figure 13.1.
Le but de la cryptographie est de protéger le message contre
– une mauvaise réception (« confidentialité ») : il devrait être impossible d’obtenir le message
13.1. CADRE GÉNÉRAL 221
M à partir du message C = e(M, K) sans connaître K ;

– une mauvaise émission (« authentification ») : il devrait être impossible de substituer un
autre message C ′ sans connaître K.
La cryptanalyse se préoccupe du « craquage » de la sécurité/de l’authentification sur un canal
de communication. « Craquer » un système sécurisé revient à trouver M ou K connaissant
C = e(M, K). Les hypothèses habituellement faites sont :
– que les algorithmes de cryptage et de décryptage sont connus de tout le monde (hypothèse de
Kerckhoff) et que même des statistiques sur les messages (mais pas le message lui-même !)
pourraient être collectées ;
– que les personnes non autorisées ne connaissent pas la clé K ;
– que tout le monde peut obtenir C = e(M, K) (mais pas M ni K).
Ainsi, toute la confidentialité est due uniquement au fait que les « ennemis » ne connaissent
pas la valeur effective de la clé secrète. Il est en effet risqué d’espérer que le design de l’al-
gorithme de chiffrement puisse être gardé hors de portée des ennemis. Néanmoins, dans de
nombreuses applications de la cryptographie, notamment militaires et diplomatiques, les cryp-
tographes essaient de garder l’algorithme de chiffrement aussi secret que possible. L’hypothèse
de Kerckhoff n’interdit pas ceci, mais conseille seulement de ne pas trop compter sur le succès
de cette bonne garde. D’un autre côté, Kerckhoff aurait certainement admiré les designers du
standard de cryptage de données (DES) (voir section 13.3.3) qui ont publié une description
complète de leur système de cryptage, et qui est néanmoins probablement le plus largement
utilisé dans les années 1980 à 2000.
13.1.2 Exemples Historiques
Avant d’étudier plus avant les notions fondamentales de la cryptographie avec des outils mo-
dernes de la théorie de l’information, donnons d’abord trois exemples historiques (mais pas
sûrs) de cryptogrammes : les chiffrements par substitution, par transposition, et le code de
Vigenère.
Substitution
Le chiffrement par substitution consiste simplement à remplacer chaque symbole de l’alphabet

du message par un autre symbole de cet alphabet, connu d’avance. La clé d’un tel système est
une permutation de l’alphabet Σ, qui définit la substitution pour tous les symboles.
Exemple 13.1 (Chiffrement par substitution) Considérons des messages faits de l’alpha-
bet habituel, fait de 27 lettres (l’espace blanc inclus !) : Σ = {A, ..., Z,′ ′ }. Une clé k , c.-à-d.
une permutation de Σ, possible pourrait être :
A → R
B → I
.. ..
. .
Y → B
Z → E
’ ’ → L
Dans ce cas e(« A BAY », k) = « RLIRB ».

Transposition
Dans le chiffrement par transposition, la clé consiste en une permutation des d > 1 premiers
entiers (d fait aussi partie de la définition de la clé).
L’algorithme de cryptage est alors le suivant :
1. allonger le message avec des espaces blancs (moins de d − 1), de manière à ce que la
longueur du message soit un multiple de d ;
2. découper le message en blocs de longueur d ;
3. permuter les symboles de chaque bloc selon la permutation K.
Exemple 13.2 (Chiffrement par transposition) Prenons la permutation (2 4 3 1 5) comme

clé (donc d = 5).
[ Note sur la notation des permutations : (2 4 3 1 5) signifie que la deuxième lettre du
message originel devient la première du message crypté, la quatrième du message originel
devient la deuxième, etc. ]
Supposons maintenant vouloir coder le message ’TRANSPOSITION CIPHER IS
SIMPLE’.
La longueur du message est de 29, ce qui n’est pas un multiple de d = 5. Un espace blanc
doit donc être ajouté à la fin.
Nous découpons alors le message en six blocs de taille 5 (les espaces blancs sont marqués
par un point pour apparaître plus clairement) :
TRANS POSIT ION.C IPHER IS.SI MPLE.
Et nous appliquons finalement la transposition à chaque bloc :
RNATS OISPT O.NIC PEHIR SS.II PELM.
Le message transmis est donc ’RNATSOISPTO NICPEHIRSS IIPELM’ (par convention

les espaces finaux ont pu être retirés).
Le décodage est fait exactement de la même façon, mais en utilisant la permutation inverse
(qui est dans ce cas (4 1 3 2 5)).
Chiffrement de Vigenère
Le dernier exemple historique que nous voulons présenter est le chiffrement de Vigenère. Dans
ce système de cryptage, la clé est une séquence de symboles du même alphabet Σ que les
messages. En pratique, c’est très souvent un mot courant ou une phrase de quelques mots.
L’utilisation d’un ordre sur Σ (p.ex. l’ordre alphabétique) permet de transformer la clé en une
séquence d’entiers, p.ex. ’A’ = 1, ’B’ = 2, ..., ’Z’ = 26 et ’ ’ = 27.
De manière plus formelle, si
– n est la taille de Σ,
– i(a) est la position du symbole a dans Σ (d’après l’ordre choisi sur Σ), 1 ≤ i(a) ≤ n,
– σ(i) le i-ème symbole de Σ (1 ≤ i ≤ n, sinon considérer i mod n),
13.2. CONFIDENTIALITÉ PARFAITE 223
– la clé K est faite de p symboles K = k1 ...kp ,

– et M de q symboles M = m1 ...mq ,
alors
C = σ(i(m1 ) + i(k1 )) σ(i(m2 ) + i(k2 )) ... σ(i(mp ) + i(kp )) σ(i(mp+1 ) + i(k1 ))
... σ(i(mq ) + i(kq mod p ))
Exemple 13.3 (Chiffrement de Vigenère) Considérons encore une fois des messages faits
des 27 lettres de l’anglais (espace blanc inclus). La clé est alors une séquence de carac-
tères, par exemple k =’INFORMATION’. Comment le message ’VIGENERE CIPHER IS
ALSO QUITE SIMPLE’ est-il codé ?
Si nous décidons que la lettre ’A’ correspond à ’1’ et l’espace à 27, la lettre ’I’ corres-
pond alors à 9, et donc la première lettre du message , ’V’, est donc codée en ’V’+9=’D’, la
deuxième lettre du message ’I’ est codée en ’I’+’N’=’I’+14=’W’, la troisième lettre ’G’ en
’G’+’F’=’G’+6=’M’, etc.
Voici le codage complet :
VIGENERE CIPHER IS ALSO QUITE SIMPLE
INFORMATIONINFORMATIONINFORMATIONINF
DWMTERSYIRWYVKFRVTTJ FXNWI FFTAX YZK
c.-à-d. que le message codé est ’DWMTERSYIRWYVKFRVTTJ FXNWI FFTAX YZK’.
– La cryptographie vise à transmettre des messages de manière sécurisée (seules les per-
sonnes autorisées peuvent le lire) ou à authentifier des messages (aucune personne non-
autorisée n’aurait pu l’envoyer).
– Pour ce faire, les messages en clair M sont codés en utilisant une clé K et une fonction
déterministe : C = e(M, K).
– Les messages cryptés peuvent être décodés de manière déterministe en utilisant la fonction
de décodage d et la même clé K, de façon à ce que d(e(M, K), K) = M .
– H(C|M, K) = 0.
– H(M |C, K) = 0.
13.2 Confidentialité Parfaite

1. savoir ce qu’est un système de cryptage parfaitement confidentiel ;
2. connaître un exemple d’un tel système de cryptage ;
3. et pour les systèmes imparfaitement sécurisés, savoir comment estimer la taille
maximale de message pouvant être transmis de manière sécurisée.
Après les exemples historiques divertissants de la dernière section, venons-en maintenant à la

science moderne de la cryptographie. Celle-ci commence avec la définition théorique de ce
qu’est un bon (« parfait » est le mot utilisé par Shannon) système cryptographique.
13.2.1 Définition et Conséquences
Dans la structure dépeinte dans la figure 13.1, où seuls les messages chiffré peuvent être captés
par des personnes non autorisées1 , le système sera sûr si le message chiffré n’amène aucune
information sur le message originel, c.-à-d. si
I(C; M ) = 0,
ce qui veut aussi dire que M et C sont des variables aléatoires indépendantes.
Définition 13.1 (Confidentialité Parfaite) Un système de cryptage est dit parfait,

c.-à-d. permet une confidentialité parfaite, si et seulement si l’information mutuelle
du message en clair M avec le message crypté C est nulle : I(C; M ) = 0. ¨
Théorème 13.1 Dans un système de chiffrement parfait, il doit exister au moins au-
tant de clés possibles que de messages possibles.
D ÉMONSTRATION
I(C; M ) = 0
implique que pout tout message m, P (C|M = m) = P (C).
Considérons maintenant un cryptogramme possible, c.-à-d. un message crypté c tel que
P (C = c) 6= 0.
Ainsi, pour chaque message originel possible m, on a P (C = c|M = m) 6= 0, ce qui veut
dire que pour chaque m il existe une clé, notée k(m), telle que c = e(k(m), m).
En outre, m 6= m′ =⇒ k(m) 6= k(m′ ) sinon le déchiffrement ne serais plus déter-
ministe : nous aurions deux messages différents qui, avec la même clé, donnent le même
cryptogramme c !
Il y a donc au moins autant de clés que de messages m possibles. ¥
Théorème 13.2 Dans un système de cryptage parfait, l’incertitude sur les clés
H(K) est au moins aussi grande que l’incertitude sur les messages H(M ) :
H(K) ≥ H(M ).
D ÉMONSTRATION Dans un système de cryptage parfait H(M ) = H(M |C) (puisque

I(C, M ) = 0).
Or H(M |C) ≤ H(M, K|C), donc H(M ) ≤ H(M, K|C). De plus :
H(M, K|C) = H(K|C) + H(M |K, C)

= H(K|C) + 0
≤ H(K)
Donc H(M ) ≤ H(K). ¥
1
Ce type d’attaque est appelé attaque sur le texte chiffré seulement.
La conséquence de ces deux théorèmes est que dans un système parfait, les clés doivent être
suffisamment complexes, au moins plus complexes que les messages eux-mêmes.
13.2.2 Un Exemple : le One-Time Pad
Présentons maintenant un exemple bien connu de système de cryptage parfait : le « one-time

pad », qui est en fait utilisé par les diplomates.
Sans perte de généralité, nous considérons ici le one-time pad binaire, c.-à-d. que les messages,
cryptogrammes et clés sont des séquences binaires (Σ = {0, 1}).
Dans ce système, la clé est une séquence aléatoire de n bits indépendants, K = K1 K2 ...Kn :
p(Ki = 0) = p(Ki = 0|K1 , ..., Ki−1 ) = 0.5
où n est la taille du plus long message à transmettre.

Le cryptage est effectué simplement par addition (sans retenue)2 des symboles du message et
des symboles de la clé : Ci = Mi + Ki .
Exemple 13.4 (One-Time Pad) Supposons que la clé soit k = 11010101010010101001

et le message à transmettre m = 11110000111100001111 ; le message crypté est alors
c = m + k = 00100101101110100110.
Théorème 13.3 Le « One-Time Pad » est un code parfait.
D ÉMONSTRATION Dans le cas du « One-Time Pad », non seulement H(C|M K) = 0

comme d’habitude (décodage déterministe), mais en plus H(K|M C) = 0 (la clé est to-
talement connue lorsque le message et le cryptogramme sont connus). Donc :
H(C|M ) = H(C|M K) + H(K|M ) − H(K|M C) = 0 + H(K) − 0
Par ailleurs :
n
X n
X X
H(C) = H(Ci |C1 ...Ci−1 ) = P (c1 ...ci−1 )H(Ci |c1 ...ci−1 )
i=1 i=1 c1 ...ci−1
or
X
P (Ci = c|c1 ...ci−1 ) = P (Ki = c − m)P (Mi = m|c1 ...ci−1 )
m∈ΣM
1 X
= P (Mi = m|c1 ...ci−1 )
|ΣK |
m∈ΣM
1
=
|ΣK |
2
L’addition binaire (aussi appelée « ou exclusif » pour le lecteur familier avec l’informatique) est l’addition
modulo 2 habituelle, sans retenue : 1 + 1 = 0 et, comme d’habitude, 0 + 0 = 0, 1 + 0 = 0 + 1 = 1.
donc
H(Ci |c1 ...ci−1 ) = H(Ki )
P
et donc H(C) = i H(Ki ) = H(K). Ainsi H(C|M ) = H(C). ¥
13.2.3 Confidentialité Imparfaite et Distance d’Unicité
Nous avons vu que pour qu’un système de cryptage soit parfait, la clé doit être suffisamment
complexe. En pratique, du moins dans le cas d’une utilisation à large échelle, ceci n’est pas
très commode.
Pour un système pratique à large échelle (p.ex. la sécurité sur Internet) la clé doit être petite
(du moins plus petite que les messages) et pouvoir être utilisée plusieurs fois, c.-à-d. que le
système doit être « imparfait » d’un point de vue formel.
Que pouvons-nous donc dire à propos des systèmes « imparfaits » (mais plus pratiques) ?
Pour déterminer quand un système de chiffrement qui n’offre pas de confidentialité parfaite
pourrait en principe être cassé, Shannon introduit ce qu’on appelle la fonction d’équivocation
de la clé, définie pour des entiers par
a(n) = H(K|C1 ...Cn ).
Il semble évident que plus du texte crypté a été vu, moins il reste d’incertitude sur la clé. De
manière plus formelle :
lim a(n) = 0
n→∞
La distance d’unicité u est alors définie comme le n le plus petit tel que a(n) ≈ 0.
Définition 13.2 (distance d’unicité) La distance d’unicité d’un système de cryptage

est le plus petit n tel que
H(K|C1 ...Cn ) ≈ 0
Ainsi, u est la plus petite quantité de texte chiffré à partir de laquelle des personnes non-
autorisées sont capables de déterminer la clé secrète de manière quasiment unique. En gros, la
distance d’unicité est la plus petite quantité de texte chiffré à partir de laquelle le système de
chiffrement peut être cassé.
Calculons maintenant la distance d’unicité dans certaines circonstances.
Théorème 13.4 Si
– M et C sont de même longueur n et du même alphabet Σ ;
– les messages cryptés ont en gros une incertitude maximale : H(C1 ...Cn ) ≃
n · log |Σ| (ce qui est ce que tout cryptographe cherche à atteindre) ;
– la clé et les messages sont indépendants : H(Mn , K) = H(Mn ) + H(K) (ce qui
est aussi très naturel et habituellement le cas).
Alors la distance d’unicité peut être approximée par
H(K)
u≃ (13.1)
R(M ) · log |Σ|
où R(M ) est la redondance du message non crypté M , comme définie dans la sec-
tion 3.2.1 du chapitre 3 :
h∞ (M )
R(M ) = 1 − .
log |Σ|
D ÉMONSTRATION Faisons l’hypothèse que n est assez grand pour que H(Mn1 ) ≃ n ·
h∞ (M ) ; ce qui est une hypothèse sensée (considérer sinon le maximum entre un tel n et
la valeur de u obtenue avec la formule donnée).
1)
H(KCn
z }| {
H(K|Cn1 ) = H(Mn1 KCn1 ) − H(Mn1 |KCn1 ) −H(Cn1 )
= H(Mn1 KCn1 ) − H(Cn1 )
= H(Mn1 K) − H(Cn1 )
= H(Mn1 ) + H(K) − H(Cn1 )
= n · h∞ (M ) + H(K) − n · log |Σ|
La distance d’unicité u est définie par : H(K|Cu1 ) = 0, c.-à-d.

³ ´
u h∞ (M ) − log |Σ| + H(K) = 0
ou :
H(K)
u =
log |Σ| − h∞ (M )
H(K)
=
R(M ) · log |Σ|
Exemple 13.5 (distance d’unicité) Considérons des messages en anglais (faits de l’alphabet
de 27 lettres, incluant l’espace blanc) chiffrés avec un code utilisant une clé de 20 lettres
indépendantes. H(K) = 20 · log(27).
Sachant que le taux d’entropie de l’anglais est en gros de 2 bits par lettre, la redondance des
messages est R(M ) = 1 − 2/ log(27) ≃ 0.58 et la distance d’unicité d’un tel système est :
H(K)
u =
R log |Σ|
20 · log(27)
= ≃ 35
log(27) − 2
c.-à-d. que des cryptogrammes d’environ 35 caractères permettront de déterminer la clé de

manière presque unique !
Shannon était bien conscient que la formule (13.1) était valide en général et « peut être utilisée
pour estimer les caractéristiques d’équivocation et la distance d’unicité des types de chiffres
ordinaires ». En fait, les cryptographes utilisent cette formule pour estimer la distance d’unicité
de presque tous les chiffres.
Notez aussi que u est, en principe, la quantité de texte chiffré pour déterminer la clé de manière
presque unique. Toutefois, trouver K à partir de C1 , C2 , . . . , Cu peut très bien être un problème
impossible à traiter en pratique. Cette formule dit seulement que toute l’information est là,
mais ne dit pas un mot sur la difficulté à « extraire » cette information. Nous reviendrons sur
cet aspect plus tard, dans la section 13.3.
13.2.4 Distance d’Unicité Croissante : Codage Homophonique
On peut voir de (13.1) qu’un bon moyen d’augmenter la distance d’unicité (c.-à-d. de moins
en dire à propos du système) est de diminuer la redondance des messages, c.-à-d. d’augmenter
leur entropie.
Une bonne idée est par exemple de compresser les messages avant cryptage. En effet, dans les
meilleurs cas de compression, H(Mn1 ) ≃ n log |Σ| et donc R(M ) ≃ 0, alors u → ∞.
Une autre possibilité est d’utiliser un vieux truc de cryptographique appelé « substitution ho-
mophonique ». Dans ce procédé, plusieurs « homophones » différents sont utilisés pour re-
présenter chaque symbole de l’alphabet originel ; plus d’homophones pour les symboles les
plus fréquents, de manière à ce que les homophones aient une probabilité d’apparition presque
égale (ce qui n’est pas le cas des symboles originels).
Exemple 13.6 En anglais, le symbole le plus probable est l’espace blanc, avec une proba-
bilité d’environ .1859, le symbole le plus probable suivant est ‘E’, qui a une probabilité
d’environ .1031. Le moins probable est ‘Z’ avec une probabilité d’environ .0005.
Si nous voulons convertir un tel texte en anglais en utilisant des symboles à probabilité
d’apparition égale, nous avons besoin d’au moins 1/0.005 = 2000 symboles (pour pou-
voir en avoir au moins un pour le ‘Z’). Supposons ainsi utiliser 2000 « homophones »
pour représenter les 27 lettres. L’espace blanc sera représenté par n’importe lequel des 372
(≈ .1859 × 2000) symboles choisis pour le représenter, ‘E’ par n’importe lequel des 206
(≈ .1031 × 2000) autres symboles qui lui sont réservés, etc., et 1 (≈ .0005 × 2000) sym-
bole homophone sera utilisé pour représenter le ‘Z’. Le choix d’un substitut pour une lettre
de l’anglais est alors fait par choix aléatoire uniforme à partir de l’ensemble de substituts
homophones pour cette lettre. Les choix successifs sont effectués de manière indépendante.
Après une telle conversion, chaque symbole homophone du texte converti a par essence une
probabilité d’apparition égale à n’importe quel autre.
13.3. CONFIDENTIALITÉ EN PRATIQUE : SÉCURITÉ ALGORITHMIQUE 229
Le décodage peut être facilement effectué en remplaçant chacun des substituts par la lettre
correspondante. Il n’y a pas besoin de savoir à l’avance quels substituts ont été choisis au
hasard au cours du procédé de pré-codage.
Évaluation 65
Quelle est la distance d’unicité d’un système de cryptage chiffrant des messages de 96 carac-
tères ayant un taux d’entropie de 3 bits par caractère avec des clés dont l’entropie est de 33
bits ?
Évaluation 66
Quelle est la distance d’unicité d’un système de cryptage qui code des messages binaires qui
ont une redondance de 25% avec des clés distribuées uniformément de 16 symboles binaires ?
confidentialité parfaite : I(C; M ) = 0

• pour qu’un système soit parfaitement confidentiel, il doit y avoir au moins autant de clés
que de messages et H(K) doit être supérieur (ou égal) à H(M ).
one-time pad : pour chaque cryptage, une clé aléatoire est choisie, dont la longueur est égale
à celle du message et dont les symboles sont indépendants. La clé est alors simplement
additionnée (symbole par symbole) au message.
• le one-time pad est un code parfait.
distance d’unicité : le nombre minimal de texte crypté qui doit être connu pour déterminer
la clé de manière presque sûre : H(K|C1 ...Cu ) ≃ 0.
• sous certaines hypothèses générales, la distance d’unicité peut être approximée par
H(K)
u≃
R(M ) · log |Σ|
où R(M ) est la redondance du message non crypté M .
13.3 Confidentialité en Pratique : Sécurité Algorithmique

1. comment la confidentialité est atteinte en pratique pour des systèmes de cryp-
tage imparfaitement sûrs ;
2. ce que ‘difficile’ signifie pour un ordinateur (complexité algorithmique) ;
3. ce qu’est une ‘fonction à sens unique’ ;
4. comment marche le DES.
Jusqu’ici, aucune attention particulière n’a été portée à la puissance de calcul effectivement re-
quise pour craquer le système. L’analyse de la confidentialité développée jusqu’ici s’applique
indépendamment du temps et de la puissance de calcul disponibles pour les attaques. La sécu-
rité contre des ennemis à puissance de calcul non restreinte est appelée sécurité incondition-
nelle (ou sécurité « théorique », comme Shannon avait pour habitude de l’appeler). Comme
nous l’avons vu dans les théorèmes 13.1 et 13.2, l’obtention d’une sécurité inconditionnelle
requiert d’énormes quantités de clés secrètes complexes, bien plus grandes que ce qui serait
acceptable en pratique pour des applications à large portée de la cryptographie. La plupart des
systèmes de cryptage utilisés en pratique ne comptent donc pas sur l’impossibilité d’être cas-
sés, mais plutôt sur la difficulté d’un tel cassage. Dans ce cadre, le but recherché est d’assurer
la sécurité à l’encontre de personnes qui disposent pour leurs attaques d’un temps et d’une
puissance de calcul limités. Ceci est appelé sécurité algorithmique (ou « sécurité pratique »,
comme Shannon avait pour habitude de l’appeler). Le point essentiel est de changer le manque
d’information (sécurité inconditionnelle) en difficulté à accéder à l’information.
Mais que signifie effectivement être difficile ? Comment mesurer la difficulté de craquer un
code ? Voici à quoi vise la « complexité algorithmique ».
13.3.1 Complexité Algorithmique
Le but de cette section n’est pas de fournir un cours complet sur la complexité algorithmique,
mais de présenter les concepts de base de manière à ce que le reste de la matière concernant la
sécurité algorithmique puisse être suffisamment bien compris.
La complexité algorithmique vise à définir la complexité des problèmes de décision. Un pro-
blème de décision est simplement une question oui/non sur une entrée bien définie. Par exemple,
un nombre entier n donné (l’« entrée »), ce nombre est-il un nombre premier ?
Si la réponse au problème de décision pourrait être trouvée par quelque algorithme (sur une
machine de Turing), le problème de décision est dit « algorithmique ».3
Pour les problèmes de décision algorithmiques, la complexité(-temps)4 est définie comme le
plus petit nombre de pas de temps (sur une machine de Turing) des algorithmes qui peuvent
répondre à la question.5
Pour de bonnes raisons fondamentales, cette complexité n’est pas exprimée exactement, mais
uniquement de la façon dont elle dépend de la taille de l’entrée : un problème est dit linéaire,
quadratique, exponentiel, ... ce qui signifie que sa complexité croît linéairement, avec le carré,
exponentiellement, ... avec la taille de l’entrée.
La complexité est donc exprimée en termes de notation « grand O ».
Définition 13.3 (Notation grand O) Pour deux fonctions f et g sur les nombres
réels, g est dite O(f ) si et seulement si
∃x0 ∈ R, ∃c ∈ R, ∀x ≥ x0 |g(x)| ≤ c · f (x)
Notez que si g est O(f ) et f est O(h), alors g est aussi O(h). Pour la mesure de la complexité,
3
Dans la théorie de la complexité algorithmique générale, les problèmes de décision algorithmiques sont appelés
« problèmes décidables selon Turing », mais ceci va un peu au-delà du propos de ce chapitre.
4
seule la complexité temporelle est considérée dans ce chapitre.
5
Nous n’entrons pas ici dans les détails des problèmes et co-problèmes.
nous cherchons le « plus petit et plus simple » f tel que g soit O(f ) (p.ex. tel que f soit aussi
O(|g|)).
Exemple 13.7 (Notation grand O) 3 · n + log n + 4 est O(n). Notez qu’elle est aussi O(n +
n3 ), O(n log n), O(n2 ), ... qui ne sont pas pertinents pour la mesure de la complexité.
5 · x2 − 12 · x7 + 5 · x3 est O(x7 ).
1/x est O(1).
La complexité d’un problème linéaire est O(n), où n est la taille de l’entrée.
Un problème dont la complexité est O(2n ) est un problème exponentiel.
Définition 13.4 (P et NP) P est l’ensemble de problèmes de décision algorithmiques

dont la complexité est polynômiale.
NP est l’ensemble de problèmes de décision algorithmiques tels que, si une solution
possible est donnée, il est possible de vérifier cette solution en un temps polynômial.
¨
Un piège classique est de penser que NP signifie ‘not-P’ ou ‘non-P’. Ceci est faux pour plu-
sieurs raisons :
– P et NP ne sont pas complémentaires : P est en fait totalement inclus dans NP ;
– il existe des problèmes qui ne sont ni P ni NP.
Que signifie alors le ’N’ de NP ? Il veut dire « Non-déterministe ». Les problèmes NP sont
des problèmes qui sont polynômiaux d’une manière non-déterministe : choisissez une solution
possible au hasard, vous pouvez conclure (pour cette solution candidate seulement !) en un
temps polynômial.
Manifestement P ⊂ NP, mais la question de savoir si NP ⊂ P ou non reste pour l’instant
ouverte.
Respectivement à cette question, il y a un sous-ensemble de NP qui est d’intérêt particulier :
les problèmes « NP-Complets » (ou « NP-C »).
Définition 13.5 (NP-Complet) Un problème est dit NP-Complet si

– il est dans NP ;
– et il est au moins aussi difficile que tout problème de NP.
Cette catégorie est d’une importance particulière car si quelqu’un réussit à prouver qu’un seul
NP-C est effectivement dans P, alors tout NP est inclus dans P !
Il y a finalement une dernière catégorie de problèmes (les « difficiles ») : les problèmes NP-
difficiles.
Définition 13.6 Un problèmea est dit NP-difficile si il est au moins aussi difficile que
tout problème de NP. ¨
a
Dans sa définition la plus générale, la catégorie NP-difficile inclut aussi les problèmes qui ne sont
pas que des problèmes de décision.
Les problèmes NP-C et NP-difficiles sont souvent confondus. La différence entre les problèmes
NP-C et NP-difficiles est qu’un problème NP-difficile n’a pas besoin d’être dans NP (que ce
soit parce que vous ne vous en préoccupiez pas ou ne vouliez pas passer de temps à le prouver
ou, plus fondamentalement, parce que c’est un problème si difficile que même le tester sur une
seule solution ne peut être accompli en un temps polynômial).
Exemple 13.8 (Problèmes NP-Complets)

Satisfabilité (SAT) :
L’entrée est un ensemble de n variables booléennes (c.-à-d. vrai/faux) x1 , ..., xn . Décision :
peut-on satisfaire
(xi1 ∨ xj1 ∨ xk1 ) ∧ (xi2 ∨ xj2 ∨ xk2 ) ∧ (xi3 ∨ xj3 ∨ xk3 ) ∧ ....
c.-à-d. être vraie pour quelque valeur des variables xi ?

Le problème du marchand itinérant (TSP, traveling salesman problem) :
L’entrée est un graphe (un ensemble de nœuds et d’arcs) G et une distance d. Décision :
existe-t-il un circuit traversant tous les nœuds de G et de longueur inférieure à d ?
Nous avons maintenant tous les ingrédients requis pour élaborer un code difficile à craquer :
inspirons-nous des problèmes NP-difficiles. Concentrons-nous maintenant plus précisément
sur l’utilisation de problèmes difficiles en cryptographie : les fonctions à sens unique et, plus
tard, les fonctions à trappe.
13.3.2 Fonctions à Sens Unique
Définition 13.7 (Fonction à Sens Unique) Une fonction à sens unique∗ est une
fonction qui est facile à calculer mais difficile à inverser (par calcul). ¨
Comment une fonction à sens unique peut-elle être utile en cryptographie ?

L’idée-clé est que le codage e(M, K) = C et le décodage d(C, K) = M sont faciles à calculer,
mais que leur inversion est difficile (même si H(K|C, M ) = 0).
Toutefois, l’application la plus évidente de fonctions à sens unique concerne certainement les
systèmes basés sur des mots de passe.
Pour chaque utilisateur autorisé du système, un mot de passe w est stocké sous forme cryptée
e(w), où e est une fonction à sens unique. Lorsque quelqu’un veut utiliser le système (« log
in »), il fournit un mot de passe we et le système calcule (sens facile) e(w)
e et vérifie si il cor-
respond à l’information enregistrée e(w). Si c’est le cas, l’accès est autorisé à l’utilisateur ; si
non, il lui est refusé. L’avantage de ce système est que les mots de passe cryptés enregistrés
n’ont pas besoin d’être gardés secrets6 . Si e est vraiment une fonction à sens unique, un at-
taquant qui arrive d’une façon quelconque à accéder à ces mots de passe cryptés ne peut rien
en faire puisqu’il lui est calculatoirement impossible de trouver un mot (de passe) x tel que
e(x) = e(w).
Notez, chose intéressante, que ce premier exemple d’application de fonctions à sens unique,
effectivement utilisé en pratique, fournit une authentification plutôt qu’une sécurité, dans le
sens développé plus tôt dans ce chapitre.
6
bien qu’il n’y ait aucune raison de les rendre publics non plus !
Un exemple de fonction à sens unique est donné dans la prochaine section.
13.3.3 DES
Le standard de cryptage de données (abrégé DES, pour Data Encryption Standard) est un
exemple de système de cryptographie algorithmique qui utilise des fonctions à sens unique.
Nous présentons ici l’idée de base du DES en nous concentrant seulement sur le noyau du
système, le standard contenant lui-même plusieurs autres astuces pratiques.
Le DES utilise un problème NP-Complet très similaire au SAT pour ceci : des systèmes d’équa-
tions dans GF(2).
Exemple 13.9 Décider si le système
x1 x4 + x2 x3 x5 = 1
x2 x3 + x1 x3 x4 = 1
x1 x3 + x1 x2 x5 = 1
a une solution ou pas est NP-Complet respectivement au nombre de variables.

Le fait que la solution
(x1 , x2 , x3 , x4 , x5 ) = (1, 0, 1, 1, 0)
soit ici facile à trouver ne devrait pas ternir le fait que pour un plus grand nombre de variables,
l’obtention de la solution est effectivement un problème difficile.
Comment ceci est-il utilisé dans un système cryptographique ?

Choisir deux entiers n et m, et une fonction non-linéaire f de GF(2)m × GF(2)n vers GF(2)n :
f (x1 , ..., xm , y1 , ..., yn ) = (p1 , ..., pn )
Choisir aussi une clé K de (d − 1)m bits, et la partager en (d − 1) parts de m bits chacune :
K = (K1 , ..., , Kd−1 ).
m
13.4. CRYPTOGRAPHIE À CLÉ PUBLIQUE 237
Lesquels des nombres suivants sont des racines primitives dans GF∗ (11): 2, 4, 5, 6, 9, 10 ?
Évaluation 68
Dans GF∗ (11), calculez

– Log7 2
– Log7 4
– Log7 5
– Log7 6
– Log7 10
Conjecture 13.1 (Diffie-Hellman-Pohlig) L’exponentielle discrète est une fonction

à sens unique.
Tout d’abord, l’exponentielle discrète est toujours aisément calculable, nécessitant au plus
2 log2 n multiplications dans GF∗ (p) utilisant l’algorithme « mettre au carré et multiplier ».
Par ailleurs, l’algorithme le plus rapide connu à ce jour (2003) pour trouver des logarithmes
discrets est en O(exp((log n)1/3 (log log n)2/3 )).
Toutefois, il n’y a aucune preuve qu’il n’existe aucun algorithme pour calculer le logarithme
discret général en un temps plus court.
Diffie, Hellman et Pohlig ont émis l’hypothèse que l’exponentielle discrète dans GF∗ (p) (quand
la base est une racine primitive) est une fonction à sens unique, à condition que p soit un
nombre élevé tel que p − 1 ait aussi un facteur premier élevé.
Aucune preuve de cette hypothèse n’a été faire à ce jour (2003). Mais aucun algorithme n’a
non plus été trouvé qui permette la calcul efficace du logarithme discret. En d’autres termes,
les preuves historiques en faveur de l’hypothèse s’accumulent, mais aucune preuve théorique
n’a encore vu le jour.
13.4.2 Le Système de Distribution de Clés de Diffie-Hellman
Dans leur article de 1976, Diffie et Hellman ont suggéré une méthode ingénieuse pour créer
une clé secrète commune entre émetteur et destinataire dans un réseau sans recourir à un canal
sécurisé pour l’échange des clés secrètes ; leur méthode repose sur le fait que l’exponentiation
discrète est à sens unique. Supposons que f (x) = ax soit vraiment une fonction à sens unique
et soit connue de tous les utilisateurs du réseau.
Chaque personne (l’utilisateur A) choisit au hasard (et en secret !) une clé privée (ou secrète)
xA et calcule alors sa clé publique yA = axA , qui est publiée publiquement.
Lorsqu’une autre personne (l’utilisateur B) désire communiquer de manière sécurisée avec A,
chacun va chercher la clé publique de l’autre et utilise cette clé à la puissance de sa propre clé
privée pour la communication ; c.-à-d. que l’utilisateur A calcule yB xA et l’utilisateur B yA xB .
Ce qui est « magique » est que ces deux nombres sont en fait le même : yB xA = (axB )xA =
axA xB = (axA )xB = yA xB . Ce nombre kAB = axA xB , que les deux utilisateurs A et B peuvent
calculer, est leur « secret commun », qu’ils peuvent utiliser en toute tranquillité comme leur
clé secrète pour communiquer en utilisant un système de cryptage à clé secrète conventionnel.
Ce que fournit la méthode de Diffie-Hellman est donc une manière publique de distribuer des
clés secrètes.
Si quelque personne non autorisée désire craquer la clé, il devrait être capable de prendre des
logarithmes discrets de yA ou de yB (p.ex. xA = Loga yA ) et d’obtenir ensuite la clé secrète
par KAB = yB xA . Mais si l’exponentiation discrète utilisée est réellement à sens unique, cette
attaque est calculatoirement irréalisable.
A ce jour (2003), personne n’a produit d’attaque sur le système de distribution des clés pu-
bliques de Diffie-Hellman qui ne soit algorithmiquement équivalente au calcul du logarithme
discret. Toutefois, il n’a pas non plus été prouvé que toute attaque sur ce système soit algorith-
miquement équivalente au calcul du logarithme discret.
Exemple 13.14 (Clé publique de Diffie-Hellman) Dans un système de Diffie-Hellman,

avec p=127 et a=67, un utilisateur A choisit comme clé privée xA = 111. Il publie alors
sa clé publique yA = 67111 = 102 mod 127.
Un autre utilisateur, B, choisit xB = 97 ; donc yB = 6797 = 92 mod 127.
Ces deux utilisateurs peuvent communiquer en utilisant la clé kAB = 92111 = 10297 = 77
mod 127.
Évaluation 69
Dans un système de clé publique de Diffie-Hellman, avec p = 19 et a = 3 (qui est en fait une
racine primitive dans GF∗ (19)),
– quelle est la clé publique correspondant à la clé privée 5 ?
– quelle clé une personne dont la clé privée est 7 utilise-t-elle pour communiquer avec une
personne dont la clé publique est 14 ?
Même question avec p = 101 et a = 51.
13.4.3 Fonctions à trappe
Les fonctions à trappe, le deuxième point crucial présenté par Diffie et Hellman pour leur
système de cryptographie à clé publique, est plus subtil et plus difficile que le premier, les
fonctions à sens unique.
Définition 13.9 Une fonction trappe∗ est en fait une famille de fonctions bijectives
ft , indexée par un paramètre t (la clé de la « trappe »), telle que chaque fonction est
à sens unique mais telle que, lorsque t est connu, ft −1 est facile à calculer. ¨
L’utilité en cryptographie d’une fonction trappe est la suivante : chaque utilisateur choisit au
hasard (et en secret) une clé, disons t, et publie ft (mais pas t elle-même !). Habituellement ft
est prise dans une famille de fonctions de manière à ce que seuls quelques paramètres doivent
être publiés. Ces paramètres sont appelés « clé publique ».
Si quelqu’un veut communiquer un message M aux personnes dont la fonction à trappe publiée
est ft , il envoie simplement ft (M ), qui est facile à calculer comme ft est à sens unique. Pour
obtenir le message correct, le destinataire calcule ft −1 qu’il lui est facile de calculer comme
il connaît la clé t. Ce calcul est toutefois difficile pour toute personne qui ne dispose pas de la
clé.
Un exemple de fonction à trappe est donné dans la section suivante.
13.4.4 RSA
Les premières fonctions à trappe furent élaborées en 1978 par R. L. Rivest, A. Shamir et L.
Adleman (abrégés RSA). La fonction à trappe de RSA est basée sur la difficulté supposée de
factoriser des entiers.
Dans ce cadre, le message et le cryptogramme sont représentés par des (énormes !) entiers.
Chaque utilisateur choisit deux nombres premiers (élevés) p et q (tels que p − 1 et q − 1 aient
aussi des facteurs premiers élevés) de manière à ce que pour tout message M possible, M < pq
(sinon partager M en plusieurs parties de façon à ce que chaque partie soit inférieure à pq et
considérer chaque partie comme M par la suite).
Soit n = pq et m = (p−1)(q−1). L’utilisateur choisit alors d < m qui est premier relativement
à m (c.-à-d. que d et m n’ont aucun diviseur commun) et calcule e tel que ed = 1 mod m. Un
algorithme calculant e à partir de d et de m est donné dans l’appendice à la fin de ce chapitre.
La clé publique (à publier) est alors (e, n) et la clé privée (à garder secrète) est (d, p, q, m).
La fonction de cryptage (qui est publique) est
C = Me mod n
et celle de décryptage (qui est secrète) est
D = Cd mod n
La structure RSA fonctionne de manière adéquate si D = M , c.-à-d. M ed = M mod n.

Ceci est en effet le cas : comme ed = 1 mod m, il existe un λ > 0 tel que M ed = M · M λm .
Rappel : en outre, comme p et q sont des nombres premiers M p−1 = 1 mod p et M q−1 = 1
mod q, ainsi
¡ ¢λ(q−1)
M ed = M · M λm = M · M λ(p−1)(q−1) = M · M p−1 = M · 1 mod p
et, de manière similaire

M ed = M mod q.
Un résultat simple de l’arithmétique de base est maintenant nécessaire :
Théorème 13.6 Soient trois entiers m, n, p donnés, si n et m n’ont aucun diviseur

commun, et si x = 0 mod m et x = 0 mod n, alors x = 0 mod (mn).
La preuve est vraiment simple, de même que le corollaire suivant qui nous intéresse :
Corollaire 13.1 Si p et q sont deux nombres premiers et si x = y mod p et x = y

mod q, alors x = y mod (pq).
Ainsi, nous avons M ed = M mod n.
Exemple 13.15 (RSA) Supposons vouloir utiliser un système RSA pour communiquer, et
que nous choisissions p = 47 et q = 59 (Ceci n’est pas vraiment un système sûr, mais
uniquement fait dans le but d’illustrer ! En pratique, p et q devraient contenir plus de 150
chiffres.)
Nous calculons alors n = pq = 2773 et m = (p − 1)(q − 1) = 2668 et choisissons un d qui
soit premier avec m ; p.ex. d = 157.
Finalement, nous calculons e tel que 157 · e = 1 mod 2668 en utilisant l’algorithme d’Eu-
clide étendu pour le plus grand diviseur commun : e = 17.
e et n sont publiés : (17, 2773), mais les autres nombres sont gardés secrets.
Supposons maintenant que quelqu’un veuille nous envoyer le message ITS ALL GREEK
TO ME. Par une convention préétablie (et qui est publique : hypothèse de Kerckhoff), cette
personne le transforme en nombres :
09 20 19 00 01 12 12 00 07 18 05 05 11 00 ...
Comme M doit être inférieur à n, c.-à-d. M < 2773, elle le découpe la chaîne ci-dessus en
entiers d’au plus 4 chiffres (effectivement, le code maximum sera alors 2626, ce qui corres-
pond à ZZ) :
920, 1900, 112, 1200, 718, 505, 1100, ...
Elle calcule alors 92017 mod 2773, 190017 mod 2773, 11217 mod 2773, ... et nous en-
voie les entiers correspondants ; c.-à-d.
948, 2342, 1084, 1444, 2663, 2390, 778, ...
Ce message est déchiffré en utilisant notre clé privée :
948157 = 920, 2342157 = 1900, ...
et le décodage finit en appliquant la convention dans l’autre sens : 920, 1900, ... =
09, 20, 19, 00, ... = ITS ...
On peut maintenant se demander comment notre correspondant a calculé 190017 mod 2773,
ou comment nous avons calculé 2342157 mod 2773...
Ceci a été effectué par la méthode de « mettre au carré et multiplier » et en gardant à l’esprit
que
a · b = α · β mod n
pour tout a = α mod n et b = β mod n
Par exemple
2342157 = (2342128 ) · (234216 ) · (23428 ) · (23424 ) · 2342

= 1428 · 239 · 284 · 900 · 2342 = 1900 mod 2773
comme
23422 = 4312 = 2743 mod 2773
23424 = 27432 = 302 = 900 mod 2773
23428 = 9002 = 284 mod 2773
234216 = 2842 = 239 mod 2773
et
2342128 = 1428 mod 2773
Évaluation 70
Considérez un système RSA très simple où deux personnes ont les paramètres suivants :
p q d e
A 3 19 5 29
B 5 11 7 23
1. Quelle est la clé publique de A ?

2. Quelle est la clé publique de B ?
3. Comment A envoie-t-il le message ’43’ à B ?
4. Comment B envoie-t-il le message ’43’ à A ?
Sécurité du RSA
Casser le RSA en trouvant m = (p−1)(q −1) est algorithmiquement équivalent à factoriser n.

En fait, toutes les attaques proposées jusqu’ici contre le RSA se sont montrées algorithmique-
ment équivalentes à factoriser n, mais aucune preuve selon laquelle cela doit obligatoirement
être le cas n’est disponible.
En outre, il n’y a pas de preuve que la difficulté soit inhérente à la factorisation des entiers,
mais il y a beaucoup d’indices historiques accréditant cette seconde hypothèse. Quiconque
essaya d’améliorer les algorithmes de factorisation connus se rendit vite compte qu’il s’agit là
d’un problème très compliqué.
En 1999, la factorisation du « RSA Challenge Number » à 155 chiffres (512 bits) fut achevée.
Elle nécessita 3.7 mois (en temps réel) et 35.7 années CPU au total. Cet effort CPU a été estimé
équivalent à approximativement 8000 MIPS-années.8
A ce jour (2003), le système RSA est considéré comme sûr contre les attaques faites par fac-
torisation, du moins avec des clés de plus de 1024 bits... ...jusqu’à ce que des percées ré-
volutionnaires dans les algorithmes de factorisation aient lieu ! [ce qui est peu vraisemblable
aujourd’hui]
racine primitive : un nombre n inférieur à un nombre premier p est dit racine primitive dans
GF∗ (p) si et seulement si la seule puissance 1 < i < p telle que ni = 1 est p − 1.
logarithme discret : un entier n est le logarithme discret en base a d’un autre entier m de
GF∗ (p) si an = m mod p (où p est un nombre premier et a une racine primitive dans
mGF ).
système de distribution de clés publiques de Diffie-Hellman : étant donnés un nombre
premier p et une racine primitive a dans GF∗ (p), chaque utilisateur choisit une clé
8
voir http://www.rsasecurity.com/rsalabs/challenges/factoring/rsa155.html
pour plus de détails.
privée x et publie sa clé publique y = ax mod p.

Lorsque deux utilisateurs veulent communiquer, chacun utilise la clé consistant en la
clé publique de l’autre élevée à la puissance de sa propre clé privée :
kAB = yB xA = yA xB
fonctions à trappe : une famille de fonctions à sens unique dépendant d’un paramètre, telles
que lorsque ce paramètre est connu, la fonction inverse n’est plus difficile à calculer.
RSA : Chaque utilisateur choisit deux nombres premiers p et q et un nombre d < (p−1)(q −
1) qui n’a pas de diviseur commun avec (p−1)(q −1). La clé publique est alors (e, pq)
où e est tel que ed = 1 mod (p − 1)(q − 1), et la clé privée est (d, p, q).
Un message M (qui est un entier inférieur à pq) est crypté en utilisant les clés publiques
par C = M e mod pq. Le décryptage est effectué en utilisant les clés privées : D =
C d mod pq.
13.5 Authentification
1. pourquoi l’authentification et la sécurité sont théoriquement incompatibles ;
2. comment assurer l’authentification en pratique ;
3. en quoi consistent les structures d’identification de Diffie-Hellman et de RSA.
Dans cette dernière section, nous voulons maintenant nous tourner vers le second aspect de
la cryptographie : l’authentification, c.-à-d. les moyens de s’assurer que le message a bien
été envoyé par une personne autorisée. En d’autres termes, nous nous demandons ici si le
cryptogramme C reçu est valide (légal) ou s’il a été falsifié par une personne non autorisée.
13.5.1 Authentification et Sécurité
L’authentification a pendant longtemps été difficile à distinguer de la sécurité. En fait, les

cryptographes n’ont découvert que récemment que ces deux buts sont plutôt indépendants, et
même incompatibles d’un point de vue purement théorique.
Ce résultats est dû au théorème suivant.
Théorème 13.7 La probabilité PI qu’un cryptogramme soit falsifié (c.-à-d. de trou-

ver un cryptogramme qui soit accepté bien qu’il n’ait pas été émis par une personne
autorisée) est minorée par :
PI ≥ 2−I(C;K)
où C est la variable aléatoire représentant les cryptogrammes possibles et K celle
représentant les clés possibles.
Cette limite est serrée et peut être atteinte dans des cas spéciaux.
13.5. AUTHENTIFICATION 243
D ÉMONSTRATION Soit la fonction d’authentification φ(C, K) :

½
1 si ∃M | C = e(M, K)
φ(C, K) =
0 sinon
La probabilité qu’un cryptogramme C soit accepté comme correct est :

X
P (acc(C)|C) = φ(C, K)P (K)
K
donc, la probabilité d’avoir une falsification d’authenticité est :

X
PI = P (acc(C)) = P (C, acc(C))
C
X
= P (C)P (acc(C)|C)
C
X
= φ(C, K)P (C)P (K)
C,K
X
= P (C)P (K)
C,K,P (C,K)6=0
X P (C)P (K)
= P (C, K)
P (C, K)
C,K
· ¸
P (C)P (K)
= E
P (C, K)
c.-à-d. · ¸
P (C)P (K)
log(PI ) = log E
P (C, K)
en utilisant l’inégalité de Jensen, nous avons

· ¸ · ¸
P (C)P (K) P (C)P (K)
log E ≥ E log
P (C, K) P (C, K)
= −I(C; K)
Ainsi
PI ≥ 2−I(C;K)
avec inégalité si et seulement si PP(C)P (K)
(C,K) est constant pour tout (C, K) (tels que P (C, K) >
0), p.ex. si C et K sont indépendants. ¥
Ainsi, pour garantir l’authenticité, c.-à-d. pour avoir une probabilité d’infraction faible, l’infor-
mation mutuelle entre les cryptogrammes et les clés doit être grande ! Toutefois, pour assurer
une confidentialité parfaite, nous avons vu dans les sections précédentes que I(C; M ) = 0 est
nécessaire !
Donc, du point de vue strict du contenu de l’information, l’authentification et la confidentialité
semblent être, d’une façon ou d’une autre, incompatibles. En effet,
I(C; K) = I(C; M ) + H(K) − H(M ) − H(K|M, C)
donc I(C; M ) = 0 (et avec l’hypothèse sensée que H(K|M, C) = 0) implique que I(C; K) =
H(K) − H(M ), ce qui implique que PI ≥ 2H(M )−H(K) . Et donc, PI ≤ ε =⇒ H(K) ≥

H(M ) + log 1ε ; c.-à-d. qu’un système de cryptage parfait devrait avoir des clés très complexes
(H(K) ≫ H(M )) pour assurer en plus l’authentification.
Toutefois, une solution est d’avoir I(C; K) ≫ 0 (pour assurer l’authenticité) mais d’assurer la
confidentialité par sécurité algorithmique. C’est une des raisons pour lesquelles les systèmes
de cryptage basés sur la complexité algorithmique sont devenus très appréciés pour l’authenti-
fication. Voyons maintenant comment ceci peut être effectué.
L’idée de base est d’ajouter une signature numérique aux messages. Une telle signature assu-
rera que l’émetteur du message est effectivement celui qu’il prétend être, et réciproquement en
cas de désaccord, l’émetteur dont le message a été signé ne peut nier l’avoir envoyé, étant le
seul à pouvoir produire cette signature.
13.5.2 Authentification de Diffie-Lamport
Dans le système d’authentification de Diffie-Lamport, chaque utilisateur choisit

– 2 n clés secrètes : k1 , ..., kn et κ1 , ..., κn
– 2 n séquences s1 , ..., sn et t1 , ..., tn
et produit alors les paramètres : λi = e(si , ki ) et µi = e(ti , κi ).
Il publie ensuite (c.-à-d. rend disponibles publiquement) λi , µi , si , ti , pour i = 1...n.
Pour signer le message binaire M de longueur n, M = m1 , ..., mn il utilise σ = σ1 , ..., σn ,
où : ½
ki si mi = 0
σi =
κi si mi = 1
Notez qu’il s’agit là d’une signature énorme comme ki et κi ne sont pas des bits mais des clés,
c.-à-d. des séquences de k bits, où k est la taille de clé requise par l’algorithme d’encryption.
Lorsque le destinataire reçoit le message et sa signature, il peut vérifier que le message a bien
été envoyé par la bonne personne en faisant :
– si mi = 0, e(si , σi ) = λi
– si mi = 1, e(ti , σi ) = µi
Un tel procédé d’identification présente toutefois plusieurs inconvénients :
– beaucoup de matériel doit être communiqué d’avance ;
– un message de n bits nécessite une signature de k · n bits !
– les clés secrètes ne le sont plus très longtemps !
13.5.3 Authentification par RSA
Diffie et Hellman ont aussi montré en 1976 que, tant que le domaine et la portée de la fonction
à trappe ft coïncident pour tout t, ft peut aussi être utilisée pour assurer l’authenticité de
messages avec signature numérique. Étant donné que des messages légitimes ont une structure
interne suffisante pour pouvoir être correctement distingués de séquences aléatoires (ce qui est
à nouveau à l’opposé de ce qui est nécessaire pour assurer la sécurité !), si l’utilisateur A désire
signer un message M de manière à assurer qu’il en est l’émetteur, il applique à M l’algorithme
de décryptage avec sa clé privée pour calculer le message signé M ′ = d(M, k̃A ). Tout autre
utilisateur, soit B, qui obtient M ′ peut utiliser l’algorithme de cryptage avec la clé publique de
A kA pour calculer e(M ′ , kA ) = M . Toutefois, seul l’utilisateur A sait comment transformer
le message M en chaîne pseudo-aléatoire M ′ ; et il est calculatoirement difficile à tout autre

utilisateur de trouver M ′ tel que e(M ′ , kA ) = M .
Ce procédé ne fournit bien sûr aucune confidentialité. Si en outre la confidentialité est dési-
rée, l’utilisateur A pourrait envoyer le message signé M ′ en utilisant la méthode de cryptage
habituelle.
Illustrons ce procédé général avec RSA.
L’utilisateur A envoie M à B en utilisant le cryptgramme C = eB (M ), et le signe avec
S(M ) = eB (dA (M ))
B peut vérifier l’authenticité par : eA (dB (S(M ))), qui doit être égal à M .
Notez que ceci suppose que dA (M ) est dans le domaine de eB , c.-à-d. dans le cas de RSA que
dA (M ) < nB . Il existe plusieurs astuces en pratique pour ce faire, parmi lesquelles la plus
facile est de partager M en plus petites parts de manière à ce que dA (M ) soit effectivement
plus petit que nB .
Exemple 13.16 (Authentification RSA) Pour continuer notre dernier exemple

(exemple 13.15), où p = 47, q = 59, d = 157 et e = 17, comment signerons-nous
le message ’OK’ ?
En utilisant la même convention qu’auparavant, ’OK’ correspond à l’entier 1511. La signature
est alors d(1511) = 1511157 = 1657 mod 2773.
Si nous envoyons ce message à quelqu’un dont la clé publique est (725, 2881), le message
crypté sera 1511725 = 1369 mod 2881 et la signature cryptée 1657725 = 2304 mod 2881 ;
c.-à-d. que nous envoyons (1369, 2304).
Le destinataire décode le message en utilisant sa clé privée d = 65 : M = 136965 = 1511
mod 2881 et vérifie la signature : S = 230465 = 1657 mod 2881, e(S) = 165717 = 1511
mod 2773. e(S) = M : le message est valide.
Évaluation 71
Considérons à nouveau le système RSA très simple où deux personnes ont les paramètres
suivants :
p q d e
A 3 19 5 29
B 5 11 7 23
1. Qu’envoie A à B pour authentifier le message « 43 » ?

2. B reçoit le message « 22 » de A, signé « 41 ». Est-ce vraiment A qui l’a envoyé ?
Sécurité de la signature
A ne peut nier avoir envoyé m : seul dA peut produire S.

B (ou toute personne autre que A) ne peut changer m en m′ : S(m′ ) 6= S(m) et le calcul de
S(m′ ) n’est pas possible sans dA .
Toutefois, en pratique, ce système de signature présente plusieurs inconvénients. Par exemple,

l’émetteur pourrait délibérément publier sa clé privée, rendant alors douteuse toute signature
numérique lui étant attribuée, ou il pourrait aussi « perdre » sa clé privée pour que les mes-
sages qu’il a envoyés deviennent invérifiables. Pour pallier au second point, des organismes
de confiance pourraient jouer le rôle de « banques de clés privées » où les clés devraient être
déposées avant toute transaction.
13.5.4 Secrets partagés
Finissons avec un système d’authentification assez différent, où l’accès à quelque information

ou ressource sensible doit être partagé entre plusieurs personnes. L’idée dans de tels systèmes
est que plusieurs personnes ensemble puissent recomposer la clé complète, mais que personne
ne puisse le faire seul. C’est la méthode du « secret partagé ».
Des exemples de telles situations sont par exemple l’ouverture d’un coffre avec deux clés, ou
le lancement d’un missile nécessitant 3 autorisations.
Supposons avoir n personnes autorisées (« porteurs de clé ») et que k morceaux de clé soient
suffisants pour « ouvrir la porte », c.-à-d. accéder au secret S. Ceci signifie :
H(S|pi1 , ..., pik ) = 0
pour tout sous-ensemble {i1 , ..., ik } de {1, ..., n}, où p1 , ..., pn sont les n morceaux de la clé.
Toutefois, moins de k morceaux sont insuffisants pour obtenir la moindre information sur ce
secret :
H(S|pi1 , ..., pik−1 ) = H(S)
Pour ce faire, choisissons pour tout secret un polynôme d’ordre k−1 dont le plus bas coefficient
est S :
P (X) = S + a1 X + a2 X 2 + ... + ak−1 X k−1
Les autres coefficients ai sont choisis au hasard, et diffèrent d’un secret à l’autre.
L’utilisateur autorisé i a reçu la partie du secret sous la forme de la valeur du polynôme pour
la valeur i :
pi = p(i),
Ceci remplit les conditions ci-dessus : k utilisateurs peuvent recomposer le polynôme par in-
terpolation, mais pas k − 1 utilisateurs (ou moins).
Exemple 13.17 Le secret S = 0105, partagé par n = 5 personnes parmi lesquelles toute
paire peut accéder au secret (k = 2)
p(x) = 105 + 50x
Ainsi
p1 = 155, p2 = 205, p3 = 255, p4 = 305, p5 = 355
Recomposition par 2 participants (p.ex. 2 et 5) :
p(2) = S + a1 · 2 = 205
p(5) = S + a1 · 5 = 355
⇒ 3S + a1 · (10 − 10) = 1025 − 710

S = 105
Mais la reconstruction par 1 seul participant n’est pas faisable.
Le partage de secret peut être utile à la création de « structures d’accès » au secret : il y a moins
de n utilisateurs, et certains d’entre eux reçoivent plus de morceaux que d’autres.
Par exemple, imaginons que l’ouverture d’un coffre nécessite 1 directeur, ou 2 fondés de pou-
voir, ou 1 fondé de pouvoir et 2 caissiers, ou 5 caissiers.
Par exemple, avec k = 10
– le directeur de la banque reçoit 10 parts,
– chaque fondé de pouvoir reçoit 6 parts,
– et chaque caissier 2 parts seulement.
Ainsi
– le directeur seul a les 10 parts requises pour ouvrir le coffre,
– 2 fondés de pouvoir ont 12 parts,
– 1 représentant et 2 caissiers 10 parts,
– et 5 caissiers : 10 parts.
Le seul problème d’une telle solution est que, pour des situations complexes, le nombre de
parts peut être élevé.
• L’authentification (qui assure que le message a bien été envoyé par une personne autorisée)
et la confidentialité (qui assure que le message est reçu par des personnes autorisées)
sont d’une certaine façon théoriquement incompatibles, comme la première nécessite
I(C; K) la plus grande possible et la dernière I(C; M ) aussi petite que possible.
• PI ≥ 2−I(C;K)
système d’authentification de Diffie-Lamport : peut être utilisé pour signer des messages
binaires. Choisir 2n clés et 2n séquences, publier le cryptage de la seconde par la
première et signer en envoyant l’une ou l’autre clé, dépendamment des bits du message.
système d’authentification RSA : La signature est le message élevé à la puissance de la clé
privée. L’envoyer cryptée avec la clé publique du destinataire.
secrets partagés : L’accès à un secret commun est diffusé parmi plusieurs « porteurs de clé »
par l’utilisation d’un polynôme.
La cryptographie vise à transmettre des messages de manière sécurisée (seules les per-
sonnes autorisées peuvent le lire) ou à authentifier des messages (aucune personne
non-autorisée n’aurait pu l’envoyer).
Pour ce faire, les messages en clair M sont codés en utilisant une clé K et une fonction
déterministe : C = e(M, K).
Les messages cryptés peuvent être décodés de manière déterministe en utilisant la fonction
de décodage d et la même clé K, de façon à ce que d(e(M, K), K) = M .
confidentialité parfaite : I(C; M ) = 0

• pour qu’un système soit parfaitement confidentiel, il doit y avoir au moins autant de clés
que de messages et H(K) doit être supérieur (ou égal) à H(M ).
one-time pad : pour chaque cryptage, une clé aléatoire est choisie, dont la longueur est égale
à celle du message et dont les symboles sont indépendants. La clé est alors simplement
additionnée (symbole par symbole) au message.
• le one-time pad est un code parfait.
distance d’unicité : le nombre minimal de texte crypté qui doit être connu pour déterminer
la clé de manière presque sûre : H(K|C1 ...Cu ) ≃ 0.
• sous certaines hypothèses générales, la distance d’unicité peut être approximée par
H(K)
u≃
R(M ) · log |Σ|
où R(M ) est la redondance du message non crypté M .

fonction à sens unique : une fonction facile à calculer mais difficile à inverser.
DES : un système de cryptage basé sur la difficulté de résolution des systèmes booléens
non-linéaires.
logarithme discret : un entier n est le logarithme discret en base a d’un autre entier m de
GF∗ (p) si an = m mod p (où p est un nombre premier et a une racine primitive dans
mGF ).
système de distribution de clés publiques de Diffie-Hellman : étant donnés un nombre
premier p et une racine primitive a dans GF∗ (p), chaque utilisateur choisit une clé
privée x et publie sa clé publique y = ax mod p.
Lorsque deux utilisateurs veulent communiquer, chacun utilise la clé consistant en la
clé publique de l’autre élevée à la puissance de sa propre clé privée :
kAB = yB xA = yA xB
fonctions à trappe : une famille de fonctions à sens unique dépendant d’un paramètre, telles
que lorsque ce paramètre est connu, la fonction inverse n’est plus difficile à calculer.
RSA : Chaque utilisateur choisit deux nombres premiers p et q et un nombre d < (p−1)(q −
1) qui n’a pas de diviseur commun avec (p−1)(q −1). La clé publique est alors (e, pq)
où e est tel que ed = 1 mod (p − 1)(q − 1), et la clé privée est (d, p, q).
Un message M (qui est un entier inférieur à pq) est crypté en utilisant les clés publiques
par C = M e mod pq. Le décryptage est effectué en utilisant les clés privées : D =
C d mod pq.
• L’authentification (qui assure que le message a bien été envoyé par une personne autorisée)
et la confidentialité (qui assure que le message est reçu par des personnes autorisées)
sont d’une certaine façon théoriquement incompatibles, comme la première nécessite
I(C; K) la plus grande possible et le dernier I(C; M ) aussi petite que possible.
• PI ≥ 2−I(C;K)
système d’authentification de Diffie-Lamport : peut être utilisé pour signer des messages
binaires. Choisir 2n clés et 2n séquences, publier le cryptage de la seconde par la
première et signer en envoyant l’une ou l’autre clé, dépendamment des bits du message.
système d’authentification RSA : La signature est le message élevé à la puissance de la clé
privée. L’envoyer crypté avec la clé publique du destinataire.
Les messages secrets ont été depuis longtemps un sujet d’étude passionnant. Cette passion
remonte au moins à l’Égypte antique (1900 avant J.-C.), ou à la Chine antique. En Europe,
bien que les Grecs et les Romains (p.ex. le « code de César ») aient déjà utilisé des messages
chiffrés, la cryptographie et la cryptanalyse n’ont réellement démarré que dans la seconde
moitié du treizième siècle et se sont développées plus sérieusement à partir du quinzième
siècle.
Autour de 1560, le diplomate français Blaise de Vigenère (1523-1596) développa son système
de cryptage à partir du travail de plusieurs de ses prédécesseurs : Alberti (1404-1472), Trithème
(1462-1516) et Porta (1535-1615). Le code de Vigenère est resté inviolable pendant 300 ans.
L’hypothèse selon laquelle la sécurité d’un code devrait reposer uniquement sur la confidentia-
lité de sa clé a été avancée pour la première fois en 1883 par Auguste Kerckhoffs (1835-1903) ;
l’histoire de la cryptographie a démontré sa sagesse. Un ennemi déterminé est généralement
capable d’obtenir les « plans » complèts des mécanismes de chiffrement et de déchiffrement
soit par des déductions intelligentes, soit en les dérobant, ou par toute autre mesure entre ces
deux extrêmes.
Le premier traitement réellement scientifique de la confidentialité n’a été fourni par C. Shannon
qu’en 1949 [10]. La théorie de la confidentialité de Shannon est en fait une application directe
de la théorie de l’information, qu’il avait formulée un an plus tôt. L’ingéniosité de sa publica-
tion de 1949 ne repose pas sur les méthodes utilisées, mais plutôt sur la nouvelle manière de
voir et la formulation intelligente de Shannon du problème de la confidentialité.
Bien que Shannon ait donné sa théorie de la condentialité en 1949, ce n’est qu’en 1984 que
Simmons donna une théorie analogue de l’authenticité, illustrant la difficulté et la subtilité plus
importantes de celle-ci.
Les fondations de la pensée cryptographique tremblèrent une fois de plus en 1976 lorsque deux
chercheurs de l’Université de Stanford, Whitfield Diffie et Martin E. Hellman, publièrent leur
article intitulé « New Directions in Cryptography ». Diffie et Hellman suggéraient qu’il est pos-
sible d’avoir des systèmes de cryptage algorithmique ne requérant pas de canal sécurisé pour
l’échange des clés secrètes. Ralph Merkle, alors étudiant diplômé de l’Université de Berkeley,
formula de manière indépendante les idées de base de cette « cryptographie à clé publique » et
soumit un article à ce sujet presque au même moment que Diffie et Hellman, mais son article
fut publié presque deux ans après le leur, et il perdit ainsi malheureusement le crédit dû à sa
découverte.
La contribution fondamentale de l’article de Diffie-Hellman consistait en les deux définitions
cruciales de fonction à sens unique (qu’ils empruntèrent au travail de R. M. Needham sur les
mots de passe des ordinateurs) et de fonction à trappe (qui était complètement nouvelle), de
même que des suggestions sur la façon d’utiliser de telles fonctions pour éliminer le besoin
d’échanger des clés secrètes dans des systèmes de cryptage algorithmiquement confidentiels.
Bien que Diffie et Hellman aient astucieusement défini les fonctions à trappe dans leur article
de 1976 et aient clairement montré le potentiel cryptographique de telles fonctions, la première
proposition d’une telle fonction ne fut faite que deux ans plus tard, en 1978, par les chercheurs
du M.I.T. R. L. Rivest, A. Shamir et L. Adleman (d’où RSA !).
Pendant ce temps, les bases du DES (1977) virent le jour à partir du système de cryptage d’IBM
Lucifer (publiées pour la première fois par Feistel en 1973 !). Toutefois, tandis que le système
de Lucifer utilisait une clé de 128 bits, le US National Bureau of Standard (connu maintenant
sous le nom de National Institute of Standards and Technology), qui publia le DES ne retint
que 56 bits pour la clé. Depuis la première proposition du DES, celui-ci a toujours été critiqué
à cause de la petite taille de sa clé.
En 1998, l’EFF (Electronic Frontier Foundation) a construit une machine, Deep Crack, pour
montrer au monde que le DES n’est pas (ou du moins n’est plus) un algorithme sûr. Deep
Crack, qui coûta $250’000 et était composé de 1536 puces spécialisées, était capable de récu-
pérer une clé de 56 bits, en utilisant une recherche exhaustive, en 4 jours en moyenne, vérifiant
92 milliards de clés à la seconde.9
Plus tard (le 18 janvier 1999), avec l’aide de distributed.net, une organisation spécialisée dans
la collecte et le contrôle du temps d’inactivité d’ordinateurs, ils cassèrent une clé DES en 22
heures et 15 minutes ! Plus de 100’000 ordinateurs (du plus lent PC aux puissantes machines
multiprocesseurs) ont reçu et effectué une petite part du travail ; ceci permit le traitement de
250 milliards de clés à la seconde. 10
En novembre 2002, l’AES (Advanced Encryption Standard), successeur du DES, fut publié.
L’AES utilise un autre type d’algorithme (l’algorithme de Rijndael, inventé par Joan Daemen
et Vincent Rijmen) et supporte des tailles de clé de 128 bits, 192 bits, et 256 bits, ce qui semble
suffisant de nos jours (2003).
D. Welsh, « Codes and Cryptography », Oxford University Press, 1988.

http://www.ars-cryptographica.com/
Annexe : Résolution de e · d = 1 mod m
Trouver e et k tels que e · d − k · m = 1 peut être fait en utilisant l’algorithme du plus

grand diviseur commun d’Euclide (comme le plus grand diviseur commun de d et de m est
précisément 1).
Soient u, v et t des vecteurs de Q2 (c.-à-d. des paires de nombres rationnels).
L’étape d’initialisation de l’algorithme consiste en u = (0, m), v = (1, d).
La condition d’arrêt est que la deuxième composante v2 de v égale 1. Dans ce cas, la première
composante est v1 = e, c.-à-d. qu’à la fin de l’algorithme v = (e, 1) .
Après l’étape d’initialisation, l’algorithme continue en boucle jusqu’à ce que la condition d’ar-
rêt soit remplie : t ← u − r v,
u ← v,
v←t
où r = uv22
9
Cette partie a été empruntée à http://lasecwww.epfl.ch/memo_des.shtml
10
pour plus de détails, voir http://www.rsasecurity.com/rsalabs/challenges/des3/index.html
Exemple 13.18 Trouvons e tel que 7e = 1 mod 60, c.-à-d. d = 7 et m = 60 :
u v r t
60
(0, 60) (1, 7) =8 (−8, 4)
7
7
(1, 7) (−8, 4) =1 (9, 3)
4
4
(−8, 4) (9, 3) =1 (−17, 1)
3
(9, 3) (−17, 1) (stop)
ainsi e = −17 mod 60, c.-à-d. : e = 43.

Chapitre 14
14.1 Cadre général – Exemples historiques
Exercice 14.1.1:
a– Coder à l’aide de la permutation suivante (l’espace est notée ’_’)
_ A B C D E F G H I J K L M N O P Q R
S D F B P M _ R H I A J L X N Z O W Q
S T U V W X Y Z
T E V G C Y U K
la phrase « VOICI_UN_EXERCICE_PASSIONNANT »
b– Coder la même phrase avec le système de codage par transposition à 6 éléments suivants :
( 2 5 3 6 1 4 ).
c– Même question avec un code de Vigenère de clé CLEFS (avec la convention ’_’ = ’0’ et
’A’ = ’+1’).
d– Coder cette même phrase en utilisant successivement les trois codes précédents (dans
l’ordre des questions, c.-à-d. appliquer la transposition au résultat de la permutation et
appliquer le cryptage de Vigenère au résultat ainsi obtenu).
Exercice 14.1.2:
Considérons un message chiffré C correspondant au cryptage d’un message d’origine M avec

une clé K.
a– Que valent H(C|M, K) et H(M |K, C) dans le cas général ?
b– Montrez que H(K, C) = H(M ) + H(K) sachant que la clé et le message sont (statisti-
quement) indépendants.
253
c– Sous les même hypothèses, montrez que H(C|M ) = H(K) − H(K|C, M ).
Exercice 14.1.3:
Considérons un système de cryptage « one-time pad » où M est le message d’origine (une

suite binaire), K est la clé (également une suite binaire) et C le message crypté correspondant.
Soient Mi et Ki un bit quelconque (en même position) respectivement du message d’origine
et de la clé. Ce sont deux v.a. binaires indépendantes. Le bit correspondant du message chiffré
est alors obtenu par Ci = Mi ⊕ Ki = Mi + Ki (mod 2).
a– Montrer que H(Ci |Mi ) = H(Ki )

b– Calculer I(Mi ; Ci ) et I(Mi ; Ci |Ki ) en fonction de H(Mi ), H(Ki ) et H(Ci ).
c– En supposant que P (Ki = 0) = P (Ki = 1) = 0.5, montrer que
I(Mi ; Ci ) < I(Mi ; Ci |Ki )
Intérêt : Ceci prouve que I(X; Y |Z) > I(X; Y ) est possible.
Exercice 14.1.4:
Ceci constitue plus un jeu qu’un exercice.

En vous aidant de la table (empirique) de distribution de probabilité sur les caractères en anglais
suivante :
carac. (espace) E T A O I N S
proba. 0.1859 0.1031 0.0796 0.0642 0.0632 0.0575 0.0574 0.0514
carac. R H L D U C F M
proba. 0.0484 0.0467 0.0321 0.0317 0.0228 0.0218 0.0208 0.0198
carac. W Y G P B V K X
proba. 0.0175 0.0164 0.0152 0.0152 0.0127 0.0083 0.0049 0.0013
carac. J Q Z
proba. 0.0008 0.0008 0.0005
essayez de décoder le message (anglais) suivant, sachant qu’il a été codé par un code à substi-
tution (l’espace est noté ici ’_’) :
WHAT_MAKESEYOAU_ADOR_DOAUNWIAIOSUOSROAUNEUAD_OIAS_
UAKOESAT_MAEFOAEAJ_ _DANERLOF
14.2 Confidentialité parfaite
Exercice 14.2.1:
Si l’on suppose que l’entropie de l’anglais est comprise entre 1 et 2 bit par lettre, quelles bornes
trouve-t-on pour la distance d’unicité.
a– d’un système de cryptage par transposition de blocs de taille d ?
b– d’un système de cryptage de Vigenère de taille d ?
c– Si l’on suppose que l’entropie de l’anglais est de 1.5 bit par caractère, quelle taille (d)
doit on prendre pour chacun de ces cryptages afin de s’assurer une sécurité raisonnable
sur des textes de 100 caractères (c.-à-d. pour avoir une distance d’unicité supérieure à
100 ?).
On supposera que les messages n’utilisent que les 27 lettres majuscules (espace comprise) et
on fera l’approximation de processus stochastique sans mémoire pour les messages.
14.3 Sécurité algorithmique
Exercice 14.3.1:
Résoudre en binaire le système :


 xyz + wty = 1
xw + wu + uy + 1 = 0

xu + yt + xz − 1 = 0
Note : on travaille ici en binaire, donc le ’+’ est un ou-exclusif et, entre autres, ’+1 = −1’,
’x2 = x’, ’2 x = x + x = x − x = 0’.
Exercice 14.3.2:
On utilise ici le système de cryptage DES avec n = 4, d = 3 et f donnée par :

 
f1 = x1 y1 + x2 y2 + x4 y4 + x5
 f2 = x1 y4 + x3 y2 + x5 y1 + x2 + y3 + x4 
f (x1 , x2 , x3 , x4 , x5 , y1 , y2 , y3 , y4 ) = 
 f3 = (x1 + x3 + x5 + y2 ) · y1


f4 = (x2 + x4 + y4 ) · y3
toutes les opérations s’effectuant bien entendu en binaire.

Les clés ont donc (d − 1) · 5 = 10 bits. Nous choisirons la clé K = K1 K2 = 0110110110.
a– Avec ce système, coder le message 0100110001110011.
b– Avec ce système, décoder le message 0100110001110011.
14.4 Cryptographie à clé publique
Exercice 14.4.1:
On choisit d’utiliser le système de distribution de clés vu en cours avec p = 11 et a = 2.

a– Vérifiez que a est une racine primitive de l’unité modulo p.
b– Dans ce système, j’utilise la clé publique 9. Pouvez vous « craquer » ma clé privée ?
c– Supposant que votre clé publique soit 3, quelle clé commune utiliserait-on pour communi-
quer ?
Exercice 14.4.2:
Un assistant envoie votre note au professeur concerné par mail encrypté en RSA. La clé pu-
blique du professeur est (7, 55) et le message envoyé (i.e. encrypté) est 25.
Quelle est votre note ?
Exercice 14.4.3:
Cet exercice nécessite une bonne calculatrice ou d’écrire un petit programme.
PGP est un système de cryptographie hybride combinant un algorithme à clé publique (RSA) et
un algorithme à clé secrète (IDEA en l’occurence). En ce qui concerne l’utilisateur cependant,
PGP se comporte comme un cryptosystème à clé publique.
Son principe est le suivant : une clé secrète est générée puis est utilisée pour coder le message.
Cette clé secrète est elle-même codée en utilisant RSA. Le message envoyé est la concaténation
de la clé secrète codée et du message codé.
Supposons ici que le système à clé secrète utilisé soit un one-time pad décimal (i.e. pour
chaque chiffre une addition modulo 10 de la clé) agissant sur des blocs de 6 chiffres d’une
suite de chiffres. Un texte est lui-même transformé en suite de chiffres par la convention ’_’
=00, ’A’=01, ’B’=02, ...
Exemple : Texte=« UN TEST » → ’21140020051920’ et si la clé secrète est « 123456 », cela
donne comme message codé ’211400 200519 20’ + ’123456 123456 12’ = ’33485632396532’.
Sachant que votre clé publique RSA est (21, 172 831) et votre clé privée est 16 381, décoder
le message
58423
17237714237119365013215214405835485718277314346213327723
où par convention le cryptage RSA de la clé secrète est sur la première ligne.
14.5 Authentification
Exercice 14.5.1:
Utilisant un système d’authentification de type « Diffie-Lamport » basé sur la fonction d’en-

cryptage par blocs de 2 chiffres (en base dix)
C2i−1 = M2i−1 + K1 ( mod 10) C2i = M2i + K2 ( mod 10)
Dominique a choisi pour clés secrètes :
a1 = 33 a2 = 83 b1 = 27 b2 = 51
et pour messages de validation
X1 = 1967 X2 = 1998 Y1 = 67 Y2 = 98
a– Qu’envoie Dominique comme paramètres de validation à ses correspondants ?

b– Dominique envoie à Claude le message suivant : 10. Quelle en est la signature ?
c– Quelle critique peut-on faire du système employé ici ?
d– Reprendre les questions a) et b) avec la fonction d’encryptage
e(M, K) = M K ( mod 10)
Exercice 14.5.2:
Pour assurer l’authenticité des messages contenant les notes, le professeur demande à l’assis-
tant de signer ses messages (toujours en utilisant le système RSA). Sachant que la clé publique
de l’assistant est à présent (3, 15) et celle du professeur (7, 77),
a– Quel message envoie l’assistant pour la note 4 ?
b– Quelle note correspond au message 41, 41 ?
c– Un message signé 27 a-t-il bien été envoyé par l’assistant ?
Bibliographie
[1] R. Ash. Information Theory. Wiley, 1965.
[2] R. Blahut. Theory and Practice of Error Control Codes. Addison-Wesley, 1983.
[3] P. Elias. Coding for noisy channels. In IRE Conv. Rec., volume 4, pages 37–47, 1955.
[4] A. Feinstein. A new basic theorem of information theory. IRE Trans. Information Theory,
IT-4:2–22, 1954.
[5] R. G. Gallager. A simple derivation of the coding theorem and some applications. IEEE
Trans. Information Theory, IT-11:3–18, 1965.
[6] R. G. Gallager. Information Theory and Reliable Communication. Wiley, 1968.
[7] S. Lin and D. J. Costello. Error Control Coding: Fundamentals and Applications.
Prentice-Hall, 1983.
[8] David Salomon. Data Compression – The complete reference. Springer, 1998.
[9] C. E. Shannon. A mathematical theory of communication. Bell Sys. Tech. Journal,

27:379–423, 623–656, 1948.
[10] C. E. Shannon. Communication theory of secrecy systems. Bell Sys. Tech. Journal,
28:656–715, 1949.
[11] J. H. van Lint. Introduction to Coding Theory. Springer-Verlag, 1982.
[12] A. J. Viterbi. Error bounds for convolutional codes and an asymptotically optimum de-
coding algorithm. IEEE Transactions on Information Theory, 13:260–269, 1967.
[13] J. M. Wozencraft and B. Reiffen. Sequential Decoding. MIT Press, 1961.
259
260 BIBLIOGRAPHIE
Glossaire
BSC: Canal binaire symétrique, pour Binary Symmetric Channel. 145

BSS: Binary Symmetric Source, ou source binaire symétrique : une source binaire sans mé-
moire avec P (0) = P (1) = 21 . 156
DMC: ou canal discret sans mémoire, pour Discrete Memoryless Channel. 145
Distance Minimale: la distance de Hamming minimale (non nulle) entre toute paire de mots
de code (différents). 177
arité: taille de l’alphabet. Pour un arbre n-aire: n, le nombre de fils de chaque nœud. 90
canal de communication: formalisation de ce qui arrive aux messages transmis entre leur
émission et leur réception. 145
capacité d’un canal: la quantité maximale moyenne d’information que la sortie du canal peut
fournir sur l’entrée. 147
code complet: un code instantané dont l’arbre de codage n’a pas de feuilles inutilisées. 96
code cyclique: un code linéaire, dont tout décalage des mots de code est aussi un mot de
code.. 195
code de Huffman: une structure de codage efficace pour sources d’information sans mé-
moire. 109
code linéaire: un code par bloc avec une structure d’espace vectoriel. 180
code par bloc: un ensemble non vide de mots de même longueur, considérés comme des
« vecteurs ligne ». 173
codes non-ambigus: un code pour lequel toute séquence de mots de code ne correspond qu’à
un seul message-source. 92
codes non-singuliers: codes pour lesquels différents symboles-source sont mis en correspon-
dance avec différent mots de code. 91
décodage à distance minimale: cadre de décodage dans lequel chaque mot reçu est décodé
en le mot de code le plus proche. 176
distance de Hamming: le nombre de coordonnées pour lesquelles deux vecteurs diffèrent.
173
fonction à sens unique: une fonction qui est facile à calculer, mais difficile à inverser par le
calcul. 232
fonction trappe: famille de fonctions à sens unique dépendant d’un paramètre telles que,
lorsque le paramètre est connu, la fonction inverse n’est plus difficile à calculer.. 238
instantané: on dit qu’un code est instantané si et seulement si chaque mot de code dans toute
chaîne de mots de code peut être décodé dès que l’on a atteint la fin de ce mot de code.
93
261
262 BIBLIOGRAPHIE
l’espérance de la longueur de code: espérance de la valeur de la longueur des mots de code.

101
matrice de vérification: (pour un code linéaire C) : une matrice dont le noyau est C. 186
matrice génératrice: Une matrice dont les lignes sont des mots de code linéairement indé-
pendants. Une telle matrice est utilisée pour coder les messages.. 183
messages: sequence of symbols. 90
mot de code nul: Le mot de code constitué uniquement de zéros. 174
mot de code: une séquence non vide de symboles de l’alphabet de codage. 90
poids: le nombre de symboles non nuls. 173
préfixe: une séquence de symboles S est le préfixe de toute autre séquence de symboles com-
mençant par S. 92
probabilités de transmission: distributions de probabilité conditionnelle de la sortie d’un ca-
nal, connaissant l’entrée. 145
sans retour: on dit qu’un canal est sans retour lorsque la distribution de probabilité des entrées
ne dépend pas de la sortie.. 147
source d’information: générateur de séquences de symboles. 90
sources stationnaires: sources d’information dont les statistiques ne dépendent pas du temps.
91
syndrome: produit d’un mot reçu par une matrice de vérification. 188
treillis: Le déploiement dans le temps de tous les chemins du diagramme d’état d’un code
convolutionnel correspondant à tous les codages possibles de messages de différentes
tailles. 207
Index
capacité, 147
code
cyclique, 195
linéaire, 180
par bloc, 173
décodage
à distance minimale, 176
distance
Hamming, 173
distance minimale
d’un code, 177
décodage (à), 176
fonction à sens unique, 232

function
à sens unique, 232
Hamming
distance, 173
matrice de vérification, 186

matrice génératrice, 183
messages, 90
mot de code nul, 174
poids, 173
source d’information, 90
syndrome, 188
taux de transmission, 151

treillis, 207
263

FullCourseEPFL FR

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

FullCourseEPFL FR

Transféré par

Droits d'auteur :

Formats disponibles

EIDGENÖSSISCHE TECHNISCHE HOCHSCHULE – LAUSANNE

POLITECNICO FEDERALE – LOSANNA

Faculté Informatique et Communications

Introduction à la Théorie de l’Information

F. Bavaud J.-C. Chappelier J. Kohlas

version 2.4FR – 20080130 – cours EPFL

Cours destiné aux étudiants :

Ecublens, Février 2008.

3 Processus stationnaires & chaînes de Markov 53

5 Codage efficace de l’information 89

6 Exercices du module C2 117

7 Compléments au Codage efficace de l’Information 121

8 Exercices du module I1 139

9 Transmission d’information en présence de bruit 143

9.3.2 La partie réciproque du théorème de codage en présence de bruit pour

10 Exercices du module C4 167

11 Codes correcteurs d’erreurs 171

12 Exercices du module I2 215

13.2.3 Confidentialité Imparfaite et Distance d’Unicité . . . . . . . . . . . . . 226

14 Exercices du module I3 253

VX : ensemble des valeurs de la variable aléatoire X.

par J ÜRG KOHLAS

O BJECTIFS PÉDAGOGIQUES DU CHAPITRE 1

théorie de l’information telle que Shannon et ses successeurs l’ont établie.

O BJECTIFS PÉDAGOGIQUES DE LA SECTION 1.1

1.1.1 Choix et incertitude

O BJECTIFS PÉDAGOGIQUES DE LA SOUS - SECTION 1.1.1

Définition 1.1 La quantité d’incertitude d’un schéma de choix. Pour un système de

h(|S|) = log |S|.

h(|S|) = log 64 = 6 bit.

h(|S|) = log 5 ≈ 2, 3219 bit

F IG . 1.3 – Example: L’arbre de questions binaires d’un sytème de 5 possibilités.

{(e1,1 , e2,1 ), (e1,1 , e2,2 ), . . . , (e1,2 , e2,1 ), . . . , (e1,n , e2,m )} .

S1 × S2 = {(e1,1 , e2,1 ), (e1,1 , e2,2 ), . . . , (e1,2 , e2,1 ), . . . , (e1,n , e2,m )} .

On appelle ce nouveau système de choix un système de choix indépendants. Ceci exprime

Théorème 1.1 (Additivité de l’incertitude) L’incertitude du système de choix indé-

h(|S1 × S2 |) = h(|S1 |) + h(|S2 |).

D ÉMONSTRATION La démonstration est simple, puisqu’il s’agit essentiellement de l’additi-

h(|S1 × S2 |) = log |S1 × S2 | = log(|S1 | · |S2 |)

Ce théorème est une parfaite justification de notre définition de la mesure de l’incertitude : on

Exemple 1.3 (Echiquier - Suite) Retournons à la situation de l’échiquier, décrite dans

6 = log 64 = log 8 + log 8.

S1 × S2 × · · · × Sm = {(e1,1 , e2,1 , . . . , em,1 ), . . .}

est le système de choix indépendants correspondant.

h(|S1 × S2 × · · · × Sm |) = h(|S1 |) + h(|S2 |) + · · · + h(|Sm |). (1.1)

h(|S1 × S2 × · · · × Sm |) = h(|S1 |) + h(|S2 |) + · · · + h(|Sm |) = m · log 6.

R ÉSUMÉ DE LA SOUS - SECTION 1.1.1

Pour x ≥ 0, le logarithme log2 (x) est

1.1.2 Choix avec probabilité connue

O BJECTIFS PÉDAGOGIQUES DE LA SOUS - SECTION 1.1.2

Définition 1.2 Système de choix probabiliste. Si S est un système de choix, et P un

Si E ⊆ S est un sous-ensemble de S, soit un événement dans le langage de la théorie de la

Exemple 1.5 (Arbres liés à un système de choix probabiliste) Posons un sys-

tème de choix probabiliste (S, P ) par S = {e1 , e2 , . . . , e8 } et P =

F IG . 1.4 – L’arbre binaire de notre exemple avec la longueur moyenne de mot de 3.

Définition 1.3 La quantité d’incertitude dans un système de choix probabiliste. Ad-

L’entropie est réellement une notion fondamentale dans la théorie de l’information et de la

Propriété 1.1 L’entropie de la distribution de probabilité uniforme sur m possibili-

H(P ) ≤ h(|S|) = log m.

Ceci est vrai et peut être démontré.

Lemme 1.1 Soient p1 , p2 , . . . , pm et q1 , q2 , . . . , qm deux distributions de probabilité

avec égalité si, et seulement si, pi = qi .

Nous en concluons que