Probabilités et statistiques avec Scilab

Université Joseph Fourier (Grenoble I) Préparation à l’agrégation de mathématiques

Année 2010-2011 Épreuve de modélisation

Probabilités et statistiques avec Scilab

version du 6 septembre 2013

Table des matières 1 Introduction à Scilab 1.1 Un premier contact . . . . . . . . . . . . . . . . . . . 1.2 Algèbre élémentaire . . . . . . . . . . . . . . . . . . . 1.2.1 Vecteurs et matrices . . . . . . . . . . . . . . 1.2.2 Extraction . . . . . . . . . . . . . . . . . . . . 1.2.3 Modification, insertion, suppression . . . . . . 1.3 Opérations matricielles . . . . . . . . . . . . . . . . . 1.4 Programmation . . . . . . . . . . . . . . . . . . . . . 1.4.1 Utilisation des fichiers . . . . . . . . . . . . . 1.4.2 Fonctions . . . . . . . . . . . . . . . . . . . . 1.4.3 Opérateurs logiques . . . . . . . . . . . . . . 1.4.4 Boucle for . . . . . . . . . . . . . . . . . . . 1.4.5 Boucle while . . . . . . . . . . . . . . . . . . 1.4.6 Instructions conditionnelles . . . . . . . . . . 1.5 Compléments . . . . . . . . . . . . . . . . . . . . . . 1.5.1 Systèmes linéaires . . . . . . . . . . . . . . . 1.5.2 Résolution d’équations non linéaires . . . . . 1.5.3 Équations différentielles . . . . . . . . . . . . 1.5.4 Polynômes . . . . . . . . . . . . . . . . . . . . 1.6 Commandes graphiques de base . . . . . . . . . . . . 1.6.1 Courbes planes et nuages de points . . . . . . 1.6.2 Courbes paramétrées et surfaces en dimension 1.6.3 Fenêtres et sous-fenêtres graphiques . . . . . 1.7 Quelques conseils . . . . . . . . . . . . . . . . . . . . 1.8 Exercices . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

1 1 3 3 5 6 6 9 9 9 12 12 12 13 13 13 14 14 14 15 15 16 16 17 17

2 Fonctions de base pour les probabilités et les statistiques 2.1 Générateurs aléatoires . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Le générateur rand . . . . . . . . . . . . . . . . . . . . 2.1.2 La fonction grand . . . . . . . . . . . . . . . . . . . . 2.1.3 Simulation de lois quelconques . . . . . . . . . . . . . 2.2 Représentation de lois . . . . . . . . . . . . . . . . . . . . . . 2.2.1 Représentation de lois discrètes . . . . . . . . . . . . . 2.2.2 Représentation de lois à densité . . . . . . . . . . . . . 2.2.3 Quantiles . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Echantillons . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Moyenne, variance, covariance empiriques . . . . . . . 2.3.2 Répartition en classes : les fonctions dsearch et tabul 2.3.3 Représentations graphiques . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

19 19 19 19 20 23 23 23 25 25 25 25 26

i

. . . . . . . . . . . . . . . . . . . . 3 . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . .

2.4

Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

30

3 Loi des grands nombres, méthode de Monte-Carlo 3.1 Loi des grands nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Vérification graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.2 Vitesse de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.3 Comparaison des bornes dans l’inégalité de Bienaymé-Tchebychev et dans l’approximation normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Convergence des histogrammes et des fonctions de répartition empiriques . . . . . 3.2.1 Théorème de Glivenko-Cantelli . . . . . . . . . . . . . . . . . . . . . . . . 3.2.2 Convergence des histogrammes . . . . . . . . . . . . . . . . . . . . . . . . 3.3 Méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.1 L’aiguille de Buffon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.2 Calcul d’intégrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35 35 35 36

4 Variables aléatoires gaussiennes, théorème limite central 4.1 Loi multinormale . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Échantillons gaussiens, loi du χ2 et lois associées . . . . . . 4.2.1 Loi du χ2 . . . . . . . . . . . . . . . . . . . . . . . . 4.2.2 Loi de Student . . . . . . . . . . . . . . . . . . . . . 4.2.3 Loi de Fisher-Snedecor . . . . . . . . . . . . . . . . . 4.2.4 Échantillons gaussiens . . . . . . . . . . . . . . . . . 4.3 Théorème limite central . . . . . . . . . . . . . . . . . . . . 4.3.1 Le cas unidimensionnel . . . . . . . . . . . . . . . . . 4.3.2 Le cas multidimensionnel . . . . . . . . . . . . . . . 4.3.3 Application à la loi multinomiale . . . . . . . . . . . 4.4 Mouvement brownien . . . . . . . . . . . . . . . . . . . . . . 4.4.1 Mouvement brownien standard . . . . . . . . . . . . 4.4.2 Mouvement brownien dans Rd . . . . . . . . . . . . . 4.4.3 Pont brownien . . . . . . . . . . . . . . . . . . . . . 4.5 Processus gaussiens stationnaires . . . . . . . . . . . . . . . 4.5.1 Un peu de terminologie . . . . . . . . . . . . . . . . 4.5.2 Moyennes mobiles . . . . . . . . . . . . . . . . . . . 4.5.3 Processus auto-régressifs . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

45 45 47 47 48 48 49 50 50 51 51 52 52 53 54 55 55 55 58

5 Chaînes de Markov à temps discret 5.1 Simulation de chaînes de Markov . . . . . . . . . 5.1.1 Commandes de base . . . . . . . . . . . . 5.1.2 Chaînes absorbantes . . . . . . . . . . . . 5.1.3 Estimation de la probabilité de transition 5.2 Exemples . . . . . . . . . . . . . . . . . . . . . . 5.2.1 Le modèle d’urne d’Ehrenfest . . . . . . . 5.2.2 Le modèle de Wright-Fisher . . . . . . . . 5.2.3 Le processus de Galton-Watson . . . . . . 5.2.4 L’urne de Polya . . . . . . . . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

61 61 61 62 63 64 64 67 69 71

ii

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

36 37 37 39 39 39 40 42

6 Processus à temps continu 6.1 Le processus de Poisson . . . . . . . . . . . . . . . . . 6.1.1 Âge et durée de vie résiduelle . . . . . . . . . . 6.1.2 Loi conditionnelle des instants d’arrivées . . . . 6.1.3 Superposition et décomposition de processus de 6.1.4 Processus de Poisson composé . . . . . . . . . . 6.1.5 Processus de Poisson non homogène . . . . . . 6.1.6 Processus de Poisson dans le plan : . . . . . . . 6.2 Processus markoviens de sauts . . . . . . . . . . . . . . 6.2.1 Définition et propriétés . . . . . . . . . . . . . . 6.2.2 Lois stationnaires . . . . . . . . . . . . . . . . . 6.2.3 Simulation par variables exponentielles . . . . . 6.2.4 Simulation par la chaîne incluse . . . . . . . . . 6.2.5 Simulation par la chaîne harmonisée . . . . . . 6.3 Files d’attente . . . . . . . . . . . . . . . . . . . . . . . 6.3.1 La file d’attente G/G/1 . . . . . . . . . . . . . 6.3.2 Le cas markovien . . . . . . . . . . . . . . . . . 6.3.3 Files d’attente à plusieurs serveurs . . . . . . . 6.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

73 73 74 74 75 75 75 76 77 77 77 78 78 79 80 80 81 82 83

7 Statistique 7.1 Régions et intervalles de confiance . . . . . . . . . . . . . . . 7.1.1 Régions et intervalles de confiance exacts . . . . . . . 7.1.2 Régions et intervalles de confiance approchés . . . . . 7.2 Tests d’adéquation . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1 Test du χ2 . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.2 Test de Kolmogorov-Smirnov . . . . . . . . . . . . . . 7.3 Comparaison de deux échantillons . . . . . . . . . . . . . . . . 7.3.1 Test de Wilcoxon-Mann-Whitney . . . . . . . . . . . . 7.3.2 Test de Smirnov . . . . . . . . . . . . . . . . . . . . . 7.4 Régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.1 Ajustement affine par la méthode des moindres carrés 7.4.2 Régression linéaire simple . . . . . . . . . . . . . . . . 7.4.3 Le modèle linéaire . . . . . . . . . . . . . . . . . . . . 7.4.4 Régression linéaire multiple . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

85 85 85 86 88 88 91 91 91 91 92 92 94 94 95

8 Indications de solutions 8.1 Chapitre 1 . . . . . . . 8.2 Chapitre 2 . . . . . . . 8.3 Chapitre 3 . . . . . . . 8.4 Chapitre 4 . . . . . . . 8.5 Chapitre 5 . . . . . . . 8.6 Chapitre 6 . . . . . . . 8.7 Chapitre 7 . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

97 97 99 104 106 108 111 119

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

iii

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

iv

Chapitre 1

Introduction à Scilab Scilab est un logiciel de calcul numérique développé par l’INRIA et l’ENPC. Sa syntaxe et ses possibilités sont très proches de celles du logiciel commercial Matlab, mais contrairement à celuici, il est distribué gratuitement, avec ses sources, sur le site http://www.scilab.org Scilab n’est pas un logiciel de calcul formel : il ne fait pas de calcul exact (à de rares exceptions près), mais permet de faire très rapidement des calculs numériques approchés et dispose de nombreuses fonctionnalités graphiques.

1.1

Un premier contact

Lorsque Scilab est lancé, une fenêtre de commande s’ouvre et une invite de commande --> indique que le logiciel attend vos instructions. Cette fenêtre peut être utilisée comme une supercalculatrice : vous entrez un calcul, vous tapez sur la touche « Entrée » et Scilab vous donne le résultat. Mais dès que vous aurez à écrire des programmes un peu plus développés, vous aurez besoin de deux fenêtres supplémentaires : la fenêtre de l’éditeur, accessible par le menu « Editeur », qui vous permettra d’écrire, de sauvegarder, de modifier et d’exécuter ces programmes, et la fenêtre de l’aide en ligne, indispensable pour retrouver rapidement la syntaxe précise des fonctions dont vous ne vous servez pas tous les jours. On accède à l’aide en tapant help mot-clé — en anglais ! — ou par le menu « ? » et le sous-menu « Aide de Scilab » (ou « Help browser », suivant la version et le système d’exploitation que vous utilisez). On peut aussi utiliser la commande apropos mot-clé. Tapez : --> x=1 les lignes suivantes s’affichent : x

= 1.

--> Par contre, si vous tapez y=1;, la valeur 1 est bien affectée à y (vérifiez en tapant y), mais le résultat de l’affectation ne s’affiche pas (ce qui est particulièrement utile si y est une matrice 100 × 100 !). Si on tape simplement 3*5 sans affecter le résultat à une variable nommée, il est automatiquement affecté à une variable nommée ans (pour answer ). La valeur de cette variable est conservée jusqu’au premier calcul non affecté. 1

Dans les noms de variables, les majuscules sont distinctes des minuscules. Toutes les variables d’une session sont globales et conservées en mémoire. Des erreurs proviennent souvent de confusions avec des noms de variables déjà affectés. Il faut penser à ne pas toujours utiliser les mêmes noms ou à libérer les variables par clear. Vos variables sont listées par who_user. a=[1,2]; A=[1,2;3,4]; 1+1 who_user clear a who_user clear who_user

// affecte a et A // affecte ans // vos variables // a disparait // a, A et ans disparaissent

On peut, dans la fenêtre de Scilab copier et coller des lignes à l’aide de la souris (y compris les exemples donnés par l’aide) ; on peut aussi naviguer dans l’historique des commandes au moyen des flèches ↑ ou ↓. Chaque instruction doit être tapée sur une ligne. Si une instruction est trop longue, on peut la continuer sur la ligne suivante en terminant la première ligne par deux points (ou plus) : -->a=.. -->7 a = 7. Les constantes e, π et i sont prédéfinies ; elles sont notées %e, %pi et %i respectivement. Scilab est un logiciel de calcul numérique et non de calcul formel : il effectue des calculs numériques approchés et non des calculs exacts. On peut le constater en calculant eiπ : -->%e^(%i*%pi) ans = - 1. + 1.225D-16i Par défaut les réels sont affichés avec 7 décimales. On peut cependant, si besoin est, changer cet affichage par défaut en utilisant la commande format (cette commande ne change que l’affichage, et non la valeur des variables en mémoire) : -->%pi %pi = 3.1415927 -->format(20);%pi %pi = 3.14159265358979312 En fait, les réels sont codés dans Scilab sur 64 bits : un bit pour le signe, 11 bits pour l’exposant et 52 bits pour la mantisse, ce qui permet de coder des réels entre environ 2.10−308 et 2.10308 avec une précision de l’ordre de 2.10−16 . Cette valeur est celle de la variable prédéfinie %eps : -->%eps %eps = 2.220D-16 Le nombre de mots en mémoire (un mot=un réel en double précision) peut être très grand (de l’ordre de 5000000 par défaut). Si l’espace alloué n’est pas suffisant, on peut l’augmenter en utilisant la commande stacksize(k), où k est le nombre de mots disponibles souhaité. Il n’est naturellement pas extensible à l’infini : 2

-->stacksize(1e10) !--error 1504 Out of bounds value for stacksize argument La commande who liste les variables utilisées. Un éditeur de variables, accessible par le menu, permet également de visualiser et de modifier ces variables. Chaque variable a un type. Les principaux types qui nous intéresseront sont : – les constantes (matrices réelles ou complexes) ; – les booléens (vrai : %t ou faux : %f) ; – les chaînes de caractères (’x’ ou "x", qui représentent le même objet). Il en existe d’autres (polynômes, fonctions, listes, . . .). On obtient le type d’une variable x en tapant typeof(x). Des fonctions permettent de convertir certains types entre eux (string(7) équivaut à ’7’ (string=chaîne de caractères), evstr(’7’) à 7 (evstr=evaluate string), bool2s(%t) donne 1 (bool2s=boolean-to-scalar), . . .). Certaines conversions entre booléens et réels sont effectuées automatiquement par le logiciel. Les types des variables ne doivent pas être déclarés et ils peuvent changer à tout instant : on peut toujours affecter à une variable déjà existante une valeur d’un autre type.

1.2

Algèbre élémentaire

Pour Scilab, tout (ou presque) est matrice : un réel est simplement une matrice 1×1. Les matrices peuvent avoir des coefficients réels, complexes, booléens, chaînes de caractères, polynômes . . .. Les coefficients d’une matrice doivent cependant tous être de même type. Il faut, chaque fois qu’on le peut, utiliser les opérations matricielles prédéfinies. Le gain de temps, par rapport à l’utilisation de boucles, peut être considérable : -->timer(); -->for j=1:100 -->for i=1:100 -->B(i,j)=rand(1,1,’n’); -->end -->end -->timer() ans = 1.3

1.2.1

-->timer(); -->C=rand(100,100,’n’); -->timer() ans = 0.02

Vecteurs et matrices

En petite dimension, la façon la plus simple de définir une matrice n × m est d’en écrire entre crochets les éléments séparés par des virgules, les lignes étant séparées par des points-virgules : x=[a11, ... , a1m ; ... ;an1, ... ,anm]. -->A=[1,1,1;3,0,0;2,0,1] A = ! 1. 1. 1. ! ! 3. 0. 0. ! ! 2. 0. 1. ! 3

On peut aussi séparer les colonnes par des espaces au lieu de virgules : ainsi [1 -2,2] et [1,-2,2] définissent le même objet (la deuxième écriture est cependant fortement conseillée). De nombreuses matrices sont prédéfinies : matrice nulle, matrice unité, matrices aléatoires, intervalles. zeros (n,m) ones(n,m) eye(n,m) rand(n,m)

diag(A,k) triu(A) tril(A) toeplitz linspace(a,b,k+1) logspace(a,b,k+1)

matrice n × m nulle matrice n × m telle que ai,j = 1 pour tout i, j matrice n × m ayant des 1 sur la diagonale principale et des zéros ailleurs les coefficients sont des réalisations de variables aléatoires indépendantes de loi uniforme sur ]0, 1[ extrait la k-ième diagonale de la matrice A annule les coefficients au-dessous de la diagonale annule les coefficients au-dessus de la diagonale matrices à diagonales constantes vecteur (matrice 1 × (k + 1)) de coordonnées a + j(b − a)/k avec 0 ≤ j ≤ k. analogue au précédent en échelle logarithmique (xi+1 = Cxi entre 10a et 10b (sauf si b = π !) Matrices : construction

Si une matrice A est déjà définie, la commande rand(A) (resp. zeros(A). . .) définit une matrice aléatoire (resp. nulle, . . .) ayant la même taille que A. Ainsi la commande rand(7) ne produit pas un vecteur aléatoire à 7 éléments, mais une matrice aléatoire de même taille que la matrice [7], i.e. un seul nombre. Si x est un vecteur, la commande diag(x) construit la matrice diagonale de diagonale x. Par contre, si A est une matrice, cette commande renvoie le vecteur formé par la diagonale de A. Ainsi, la commande diag(diag(A)) renvoie la matrice diagonale dont la diagonale est celle de A. Il existe deux façons de définir une suite de points régulièrement espacés : la commande linspace(a,b,k+1) renvoie un vecteur ligne de k + 1 points régulièrements espacés (par défaut k + 1 = 100), le premier étant égal à a et le dernier à b ; la commande a:h:b renvoie sous forme de vecteur ligne la progression arithmétique de premier terme a et de raison h, le dernier terme étant le plus grand élément de cette progression ≤ b (si h > 0). Les commandes linspace(0,1,11) et 0:0.1:1 sont donc équivalentes. Par défaut, h est égal à 1 : les commandes a:1:b et a:b sont équivalentes. 0:%pi ans = 0.

1.

2.

3.

La raison h peut également être négative : 10:-1:%pi ans = 10.

9.

8.

7.

6.

5.

4. 4

1.2.2

Extraction

Pour accéder à l’élément ai,j d’une matrice A, on tape A(i,j). Plus généralement, si A est une matrice n × m et v = (v1 , v2 , . . . , vk ), w = (w1 , . . . , wp ) deux vecteurs d’indices (non nécessairement distincts) vérifiant : a) 1 ≤ vi ≤ n pour tout i ∈ {1, . . . , k} b) 1 ≤ wi ≤ m pour tout i ∈ {1, . . . , p} alors B=A(v,w) est la sous-matrice de A formée des éléments ai,j pour i parcourant v1 , . . . , vk et j parcourant w1 , . . . , wp . -->A=(1:6)’*(2:7) A = ! 2. 3. ! 4. 6. ! 6. 9. ! 8. 12. ! 10. 15. ! 12. 18. -->v=1:2:6 v = ! 1. 3.

4. 8. 12. 16. 20. 24.

5. 10. 15. 20. 25. 30.

6. 12. 18. 24. 30. 36.

7. 14. 21. 28. 35. 42.

! ! ! ! ! !

5. !

-->A(v,v) ans =

//extraction par copie: A n’est pas modifiée

! ! !

4. 12. 20.

2. 6. 10.

6. ! 18. ! 30. !

-->A(2*ones(1,3),:) ans = 4. 4. 4.

6. 6. 6.

8. 8. 8.

10. 10. 10.

12. 12. 12.

14. 14. 14.

Le symbole : représente le vecteur de tous les indices lignes ou colonnes. Si A est une matrice, A(:) est le vecteur colonne obtenu en concaténant toutes les colonnes de A. Pour un vecteur (ligne ou colonne), on peut se contenter de n’indiquer qu’un indice : -->v=5:-1:1;v([3:$]) ans = 3. 2. 1. Le symbole $ représente le dernier indice (de ligne ou de colonne). La commande size(A) renvoie la taille de la matrice A sous forme d’un vecteur ligne à deux éléments (voir aussi size(A,1), size(A,"c") et size(A,"*")). La longueur d’un vecteur v (ligne ou colonne) est obtenue par la commande length(v). La commande matrix permet de remodeler une matrice : -->matrix(1:6,2,3) 5

ans = 1. 2.

1.2.3

3. 4.

5. 6.

Modification, insertion, suppression

La commande a(i,j)=x, où a est une matrice scalaire déjà définie et x un scalaire, affecte la valeur x au coefficient a(i,j). On peut de même modifer une sous-matrice de a en remplaçant les indices i et j par des vecteurs d’indices. Si l’un des indices i et j est supérieur au nombre de lignes ou de colonnes de a, la matrice a est automatiquement complétée par des 0 : -->a=diag(1:2);a(3,1)=5 a = 1. 0. 0. 2. 5. 0. On peut supprimer des lignes ou des colonnes d’une matrice en leur affectant comme valeur la matrice vide [ ] : -->a(2,:)=[ ] a = 1. 0. 5. 0.

1.3

Opérations matricielles

Les opérations ont en général deux versions : l’une correspond à l’opération usuelle sur les matrices, l’autre à l’opération effectuée élément par élément. Ainsi, les opérations .∗, .^, ./ sont les versions élément par élément alors que les opérations *, ^, / représentent les opérations usuelles sur les matrices (produit, puissance, division) lorsque ces opérations ont un sens. Une fonction usuelle f (sin, cos, exp, abs, int, floor. . .) appliquée à la matrice A = (ai,j ) donne la matrice (f (ai,j )). Par exemple, si A = (ai,j ), exp(A) = (exp(ai,j )). Par contre, si A est +∞ n X A une matrice carrée, l’exponentielle matricielle s’obtient par la commande expm(A). On n! n=0 trouve de même les fonctions cosm, sinm, etc . . . Exemple : -->x=rand(2,2) x = ! 0.2113249 ! 0.7560439

-->U=bool2s(x>0.1) U = ! 1. O ! ! 1. 1. !

0.0002211 ! 0.3303271 !

Les commandes min et max retournent respectivement le plus petit et le plus grand élément de A si elles sont employées avec un seul argument A (matrice ou vecteur) ; si elles sont employées avec plusieurs arguments A1 , . . . , An (matrices ou vecteurs de même taille), elles s’interprètent coefficient par coefficient ; on peut également obtenir les plus petits (ou plus grands) éléments de chaque ligne (ou colonne) : 6

+ * .* / ./ ^ .^ \

addition usuelle des matrices soustraction usuelle des matrices multiplication usuelle des matrices multiplication élément par élément des matrices division à droite division élément par élément fonction puissance puissance élément par élément division à gauche Matrices : opérations binaires

bool2s(A)

A’ A.’ sum(A,’c’) sum(A,’r’) cumsum(A,’c’) cumsum(A,’r’) cumprod(A,’c’) cumprod(A,’r’)

matrice de même taille que la matrice booléenne A dont les éléments sont 1 pour %t et 0 pour %f. matrice adjointe de A (conjuguée de la transposée) matrice transposée de A P vecteur colonne : xi = j ai,j P vecteur ligne : xj = i ai,j Pj matrice : xi,j = k=1 ai,k P matrice : xi,j = ik=1 ak,j Q matrice : xi,j = jk=1 ai,k Q matrice : xi,j = ik=1 ak,j Opérations sur les matrices

-->x=rand(2,3) x = 0.7783129 0.2119030 -->min(x) ans = 0.1121355 -->min(x,’c’) ans = 0.1121355 0.2119030 -->y=rand(x) y = 0.8415518 0.4062025 -->min(x,y) ans = 0.7783129 0.2119030

0.1121355 0.6856896

0.1531217 0.6970851

0.4094825 0.8784126

0.1138360 0.1998338

0.1121355 0.6856896

0.1138360 0.1998338 7

L’addition d’un scalaire à une matrice s’interprète comme l’addition à chaque coefficient. De même la multiplication, la division par un scalaire, l’élévation à une puissance : -->2^(0:6) ans = 1. 2. 4. -->eye(2,3)-1 ans = 0. - 1. - 1. - 1. 0. - 1.

8.

16.

32.

64.

Notez cependant que A^2 renvoie le vecteur des carrés de A si A est un vecteur, mais le carré matriciel de A si A est une matrice carrée (et un message d’erreur si A est une matrice rectangulaire). Attention : la commande 1./ ne donne pas le résultat escompté : -->1./(1:3) ans = 0.0714286 0.1428571 0.2142857 En effet Scilab l’interprète comme (1.)/ et non comme 1 ./ et résout un système linéaire au sens des moindres carrés. Le rang d’une matrice A, le déterminant et le spectre d’une matrice carrée A, l’inverse d’une matrice carrée inversible A, sont donnés par les commandes rank(A), det(A), spec(A), inv(A) (ou A^(-1)). La diagonalisation (quand elle est possible) s’obtient par la commande bdiag(A). De nombreuses autres fonctions ou décompositions matricielles sont implémentées (voir la rubrique d’aide Algèbre linéaire).

La commande find La fonction find permet de trouver, et donc d’extraire etc..., les éléments d’un vecteur (ou d’une matrice) vérifiant une propriété donnée. -->a=rand(2,3) a = 0.2113249 0.0002211 0.7560439 0.3303271 -->find(ax=a(find(afunction y=sq(x) -->y=x.^2 -->endfunction; -->sq(1:4) ans = 1. 4. 9.

16.

Pour des fonctions très courtes, on peut aussi utiliser la syntaxe deff(’y=sq(x)’,’y=x.^2’) en n’oubliant pas les guillemets (mais function y=sq(x),y=x.^2,endfunction tient aussi sur une ligne). Une fonction peut avoir plusieurs arguments tant en entrée qu’en sortie. Par exemple la fonction 9

prédéfinie max peut renvoyer à la fois le maximum des coefficients d’un vecteur (ou d’une matrice) de scalaires et le premier indice où ce maximum est atteint. Si on appelle cette fonction seule, elle ne renvoie que le maximum : -->x=floor(3*rand(1,10)) x = 2. 2. 1. 1. -->max(x) ans = 2.

1.

2.

2.

1.

1.

2.

Si on veut obtenir aussi l’indice, on appelle la fonction en explicitant deux valeurs en sortie : -->[y,k]=max(x) k = 1. y = 2. La même remarque vaut pour la fonction de tri gsort qui permet de récupérer le rang de chacun des éléments d’un vecteur : -->x=rand(1,7) x = 0.26395 0.41481 0.28064 0.12800 -->[y,ind]=gsort(x,’g’,’i’) ind = 7. 4. 6. 1. 3. 2. 5. y = 0.11213 0.12800 0.21190 0.26395

0.77831

0.21190

0.11213

0.28064

0.41481

0.77831

De manière générale, si une fonction retourne plusieurs valeurs, il faut lui demander explicitement de retourner ces valeurs en les nommant sous forme d’un vecteur si on veut toutes les obtenir ; sinon seul le premier argument de sortie (en général le plus important) est retourné. Une fonction peut être récursive (s’appeler elle-même au cours de son exécution). Ainsi pour calculer la factorielle d’un entier naturel, on pourrait définir la fonction : function x=fact(n) if nfactorial(0:5) ans = 1. 1. 2.

6.

24.

120.

de même que la fonction gamma qui permet d’obtenir le même résultat). 10

1.4.2.1

Variables locales et variables globales

Une fonction peut très bien ne pas renvoyer de valeur, mais effectuer une action (par exemple dessiner une figure ou afficher un message). La fonction dessinercercle(x,y,r) définie par function dessinercercle(x,y,r) square(x-r,y-r,x+r,y+r); xarc(x-r,y+r,2*r,2*r,0,64*360) endfunction; dessine le cercle de centre (x,y) et de rayon r. De même la fonction affichercarre(x) définie par : -->function affichercarre(x) -->disp(x^2); -->endfunction; -->affichercarre(5) 25. affiche à l’écran le carré de son argument, mais ne renvoie aucune valeur. Les résultats des calculs intermédiaires effectués lors de l’exécution d’une fonction ne s’affichent jamais à l’écran, si bien qu’il est indifférent de terminer les instructions à l’intérieur d’une fonction par un point-virgule ou un passage à la ligne. La commande disp permet d’afficher la valeur d’une variable ; on peut y ajouter un texte sous forme de chaîne de caractères, comme disp(’Valeur de x: ’+string(x)). Une fonction peut accéder en lecture à toutes les variables déjà définies, mais ne peut pas modifier en cours d’exécution une variable existante, sauf si celle-ci a été déclarée globale. Par exemple la fonction double() définie par : function double() a=2*a; endfunction; ne modifie pas la variable a dans le script suivant : -->a=2;double();a a = 2. Pour qu’elle modifie a, il faudrait déclarer cette variable globale : -->global a; -->function double() -->global a; -->a=2*a; -->endfunction; -->a=3;double();a a = 6. Le plus simple est naturellement de définir la fonction autrement : -->function y=double(x) -->y=2*x; -->endfunction; -->a=3;a=double(a) a = 6. et d’éviter ainsi l’utilisation de variables globales. 11

1.4.3

Opérateurs logiques == < > = ∼= ou ∼ & ou and | ou or

égal à inférieur à supérieur à inférieur ou égal à supérieur ou égal à différent de négation et logique ou logique (non exclusif)

Ces opérateurs s’appliquent coefficient par coefficient sur des matrices de même taille : -->a=rand(2,3),b=rand(a),bwhile 1 -->i=i+1; -->end (Scilab transforme la constante non nulle 1 en le booléen %t). On peut dans ce cas arrêter l’exécution du programme au moyen de la commande stop du menu control de la barre de menu. La commande break interrompt l’exécution d’une boucle : -->for k=1:100, if k^2>50 then break;end;end;k k = 8. 12

1.4.6 1.4.6.1

Instructions conditionnelles if then else

Elle s’écrit : if condition(s) then instruction(s), else instructions, end . L’alternative else n’est pas obligatoire. Si elle est suivie d’un if, on peut contracter les deux mots-clés en elseif. Attention : le mot-clé then doit être situé sur la même ligne que if ou elseif ; il peut être remplacé par un passage à la ligne ou une virgule. 1.4.6.2

select case

Elle s’écrit : select n,case n1 instruction,case n2 instruction,...else instruction,end Un exemple suffira à l’illustrer : -->nom=’jean’;select nom, case ’pierre’ y=1, case ’jean’ y=2,else y=3,end y = 2.

1.5 1.5.1

Compléments Systèmes linéaires

Pour résoudre un système de Cramer Ax = b, où A est une matrice carrée inversible, on peut soit exprimer la solution sous la forme x = A−1 b, soit utiliser la division matricielle à gauche x=A\b : -->A=rand(3,3);b=rand(3,1);x1=A\b;x2=inv(A)*b;norm(A*x1-b),norm(A*x2-b) ans = 1.241D-16 ans = 2.719D-16 On peut ainsi résoudre simultanément plusieurs équations ayant le même premier membre, mais des seconds membres différents, en remplaçant le vecteur b par la matrice rectangulaire obtenue en concaténant les seconds membres. Si la matrice A n’est pas inversible (ou est numériquement proche d’une matrice non inversible), ou si A a le même nombre de lignes que la matrice b, mais n’est pas carrée, Scilab envoie un message d’avertissement et résoud le système au sens des moindres carrés : -->A=ones(3,3);b=rand(3,2);x1=A\b warning matrix is close to singular or badly scaled. rcond = computing least squares solution. (see lsq) x1 = 0.5119654 0.5524123 0. 0. 0. 0. 13

0.0000D+00

1.5.2

Résolution d’équations non linéaires

La résolution d’équations non linéaires se fait par la commande fsolve. La fonction dont on cherche les zéros est d’abord définie comme fonction Scilab (par function ou deff). Le premier argument de fsolve est la valeur initiale destinée à initialiser l’algorithme de résolution, le second la fonction : -->function y=f(x),y=x-cos(x),endfunction;x=fsolve(0,f) x = 0.7390851 -->cos(x)-x ans = 0.

1.5.3

Équations différentielles

La résolution d’équations différentielles ordinaires se fait par la fonction ode (Ordinary Differential Equation). La commande de base pour résoudre l’équation différentielle y ′ = f (t, y) est de la forme y=ode(y0,t0,t,f), où y0 est la donnée initiale, t0 l’instant initial, t le vecteur des instants auxquels on veut obtenir la solution et f la fonction Scilab définissant le second membre (attention : f doit nécessairement être définie comme fonction de t et y, même si l’équation est de la forme y ′ = g(y)). Pour résoudre numériquement l’équation y ′′ + y = 0, avec y(0) = 1, y ′ (0) = 0, on peut donc écrire : function y1=f(t,y),y1=[0 -1;1 0]*y,endfunction; t=linspace(0,2*%pi);y=ode([1;0],0,t,f); //vérification: norm(y(1,:)-cos(t)) ans = 0.0000009

1.5.4

Polynômes

Scilab possède un type polynôme. On définit un polynôme soit par ses racines (comportement par défaut), soit par ses coefficients. L’indéterminée est entrée sous forme de chaîne de caractères. Ainsi les deux commandes P=poly([1 2],’s’) et Q=poly([2 -3 1],’s’,’c’) définissent le même polynôme (s − 1)(s − 2) = s2 − 3s + 2. La variable prédéfinie %s représente le polynôme élémentaire s : poly(0,’s’)==%s ans = T Les racines s’obtiennent par la fonction roots, les coefficients par coeff. L’addition, la multiplication, la multiplication par un scalaire utilisent les symboles ordinaires. L’évaluation en un point ou la composition se font par la fonction horner. Si A est une matrice, poly(A,’t’) est le polynôme caractéristique de A. Le script suivant représente sur un même graphique la première bissectrice, le graphe sur l’intervalle [0, 1] de la fonction génératrice g d’une loi discrète sur {0, 1, 2, 3} ainsi que celui de ses itérées successives, et résoud l’équation g(s) = s sur ce même intervalle, d’abord en utilisant la commande fsolve, puis en entrant la fonction génératrice sous forme d’un polynôme (pour l’interprétation d’un tel programme, voir la section 5.2.3) :

14

loi=[0.2 0.4 0.2 0.2]; function y=g(t) y=loi*t^(0:length(loi)-1)’; endfunction; t=linspace(0,1); y=t; for k=1:10 plot2d(t,y,style=k); y=feval(y,g); end; function y=gg(t) y=g(t)-t; endfunction; q=fsolve(0,gg)

1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0 0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

pg=poly(loi,’s’,’c’);fg=poly(0,’s’); qq=roots(fg-pg); for k=1:10 plot2d(t,horner(fg,t),style=k); fg=horner(pg,fg); end; disp(qq);

1.6

Commandes graphiques de base

Les possibilités graphiques de Scilab sont importantes. Nous n’indiquerons ici que quelques commandes de base. Pour les autres, se reporter à l’aide en ligne, rubrique Graphics.

1.6.1

Courbes planes et nuages de points

La commande de base pour tracer des courbes planes est plot2d. Les variantes plot2d2 et plot2d3 permettent de tracer des courbes en escalier ou des diagrammes en bâtons. Cette commande prend en arguments les vecteurs des abscisses et des ordonnées d’une suite de points et représente la ligne brisée joignant ces points. Si le nombre de points est suffisant, on peut ainsi représenter le graphe d’une fonction : x=linspace(0,%pi);plot2d(x,sin(x)); De nombreux arguments facultatifs permettent de règler l’affichage (couleur, échelle, axes . . .), d’ajouter un titre (xtitle) ou des légendes (legends) : consulter à ce propos l’aide en ligne. La commande square permet d’obtenir directement une échelle isométrique (par défaut, Scilab représente un cercle comme une ellipse : t=linspace(0,2*%pi);plot2d(cos(t),sin(t));). Si on veut représenter plusieurs courbes sur le même graphique, on donne en arguments de plot2d deux matrices x et y à n lignes et nc colonnes, où n est le nombre de points de chaque courbe et nc le nombre de courbes : x=linspace(0,%pi);plot2d([x’,x’],[sin(x’),cos(x’)]) Pour représenter un nuage de points (ou une courbe dont les points ne sont pas reliés entre eux), il faut donner un paramètre style=-n, où n est un entier entre 1 et 10, qui représente la marque utilisée pour représenter chaque point. Il existe aussi une commande plot, dont la syntaxe est plus souple. Elle permet de représenter directement le graphe d’une fonction en donnant son nom, ou de choisir style et couleur de représentation par des paramètres simples. Par exemple : 15

xy=[3 -1;-1 2]*rand(2,100,’n’); plot(xy(1,:),xy(2,:),’or’) représente le nuage de points dont les coordonnées sont données dans la matrice xy, chaque point étant représenté par un petit cercle (’o’) de couleur rouge (’r’).

1.6.2

Courbes paramétrées et surfaces en dimension 3

La commande de base pour représenter une surface est plot3d. Dans sa version la plus simple, la surface d’équation z = f (x, y) est obtenue en entrant les intervalles de définition discrétisés de x et y, de longueurs respectives n et m, et une matrice z à n lignes et m colonnes donnant les valeurs de la fonction en les points de la grille ainsi définie : x=linspace(-%pi,%pi,40); y=linspace(-%pi/2,%pi/2,20); z=cos(x)’*sin(y); plot3d(x,y,z); Pour représenter une courbe paramétrée dans l’espace, il faut utiliser la commande param3d ou param3d1. En particulier, pour représenter un nuage de points dans R3 , on utilise la commande param3d1 avec un argument de couleur négatif : n=1000; xyz=[2 1 0;1 3 0;0 0 1]*rand(3,n,’n’); param3d1(xyz(1,:),xyz(2,:),list(xyz(3,:),-ones(1,n)));

1.6.3

Fenêtres et sous-fenêtres graphiques

On efface le contenu d’une fenêtre graphique par la commande clf(). Cela évite de superposer un graphique à un graphique déjà existant (par défaut, Scilab superpose le nouveau graphique au précédent, en réajustant éventuellement l’échelle). La commande show_window() force la fenêtre à apparaître au premier plan. On peut créer une nouvelle fenêtre graphique par la commande xset(’window’,n), où n est le numéro de la fenêtre que l’on veut créer. Si la fenêtre numérotée n existe déjà, elle devient la fenêtre graphique courante. La commande la plus simple pour diviser une fenêtre graphique en plusieurs sous-fenêtres est subplot. La commande subplot(mnp) (ou subplot(m,n,p)), où m, n et p sont trois entiers (p ≤ mn) divise la fenêtre graphique en mn sous-fenêtres de même taille (m lignes et n colonnes) et situe le dessin courant dans la p-ième de ces fenêtres (numérotées par ligne, puis colonne). La commande xsetech permet plus de souplesse, mais a une syntaxe un peu plus compliquée.

1.7

Quelques conseils

– Nommez systématiquement vos variables en utilisant des noms facilement identifiables (pour vous d’abord, et pour ceux qui liront vos programmes ensuite). Il est bien plus facile (et beaucoup plus sûr) de modifier un paramètre (par exemple le nombre de simulations) qui a reçu un nom que de modifier dans tout le programme la valeur de ce paramètre à chacune de ses occurences. – Initialisez toujours les vecteurs et les matrices : la commande : 16

n=100000; x=zeros(1,n); timer();for i=1:n,x(i)=i;end;timer() ans = 0.421875 s’exécute beaucoup plus rapidement que la commande : n=100000; timer();for i=1:n,y(i)=i;end;timer() ans = 68.828125 et donne le même résultat (naturellement aucune de ces commandes n’est ici à recommander : trouvez la bonne. . .). Ensuite, la première permet de contrôler la taille du résultat (un vecteur ligne, alors que la seconde fournit un vecteur colonne). Enfin, et surtout, si le vecteur x est déjà défini et de longueur supérieure à n, la commande for i=1:n x(i)=i;end; ne modifie que les n premières composantes de x, et laisse les suivantes en place, ce qui constitue une source fréquente d’erreur. – Indentez le contenu des boucles si elles contiennent plusieurs instructions imbriquées, ce qui rend la structure du programme plus lisible.

1.8

Exercices

Exercice 1.1. Ecrire un vecteur aléatoire de 10 réels. Réécrire ce vecteur dans l’ordre inverse. Exercice 1.2. Ecrire un vecteur ligne à 10 éléments dont les éléments sont successivement +1 et -1. Ecrire un vecteur ligne aléatoire à 10 éléments, dont les éléments sont indépendamment +1 et -1 avec équiprobabilité. Exercice 1.3. Ecrire une matrice aléatoire 4 × 4, puis la matrice obtenue en remplaçant la première ligne par la dernière. Exercice 1.4. Ecrire une matrice carrée aléatoire d’ordre 5 à coefficients ±1, puis la matrice obtenue en remplaçant les éléments diagonaux de cette matrice par des zéros. Exercice 1.5. Soit a le vecteur ligne a = (1, 2, 3, 4) et b le vecteur ligne b = (1, 3, 5, 7). Ecrire la matrice de terme général ai bj . Plus généralement, étant donné un vecteur ligne et un entier n, écrire la matrice à n lignes toutes égales au vecteur donné. Idem en remplaçant ligne par colonne. Exercice 1.6. Ecrire une matrice aléatoire A à 3 lignes et 5 colonnes, puis les matrices tAA et A tA. Comparer les spectres de ces deux matrices. Exercice 1.7. Soit A une matrice 5 × 5. Multiplier les colonnes de A respectivement par 1, 2, 3, 4, 5. Proposer plusieurs solutions. Idem pour les lignes. Remplacer la deuxième ligne par la somme de la première et de la dernière. Calculer le déterminant, puis le rang de la matrice obtenue. Exercice 1.8. Écrire une fonction dif réciproque de la fonction cumsum agissant sur les vecteurs. √ nn e−n 2πn Exercice 1.9. Écrire la suite des quotients qn = de l’approximation de n! par la forn! mule de Stirling par la vraie valeur n! pour n = 1, . . . , 1000. Idem avec l’approximation de n! par   √ 1 . nn e−n 2πn 1 + 12 n Exercice 1.10. Écrire des fonctions calculant les nombres d’arrangements A(n, p) et les nombres de   n combinaisons de p objets parmi n : p – en utilisant la fonction factorial ; – en utilisant la fonction gamma ;

17

– en utilisant la fonction gammaln (logarithme de la fonction gamma). Discuter les avantages et les inconvénients de ces méthodes. Ces fonctions peuvent-elles prendre comme arguments des vecteurs ? Exercice 1.11. Écrire une fonction renvoyant les n+1 premières lignes du triangle de Pascal (complétées par des 0 pour apparaître sous forme de matrice carrée). Exercice 1.12. Écrire une fonction renvoyant la liste de tous les nombres premiers inférieurs ou égaux à son argument en utilisant la méthode du crible d’Eratosthène. π(x) ln(x) Représenter graphiquement la fonction x 7→ , où π(x) est le nombre de nombres premiers x inférieurs ou égaux à x.

18

Chapitre 2

Fonctions de base pour les probabilités et les statistiques 2.1

Générateurs aléatoires

Scilab dispose de deux générateurs de nombres pseudo-aléatoires : un générateur de base rand et un générateur plus sophistiqué grand.

2.1.1

Le générateur rand

La commande x=rand(n,m) renvoie une matrice n × m dont les coefficients sont des nombres pseudo-aléatoires indépendants uniformément distribués sur l’intervalle [0, 1]. Si A est une matrice n × m, rand(A) équivaut à rand(n,m). On peut également obtenir des nombres suivant la loi normale réduite par la commande x=rand(n,m,’n’). On peut, par la commande rand(’n’), modifier le comportement par défaut de manière à obtenir systématiquement des nombres suivant cette loi normale ; on revient au comportement par défaut par la commande rand(’u’). L’état de ce paramètre est obtenu par la commande rand(’info’). Le générateur rand est un générateur congruentiel linéaire de paramètres a = 843314861, c = 453816693, m = 231 , ce qui signifie que la suite xn des nombres renvoyés par la commande rand est de la forme xn = un /m, où la suite un d’entiers satisfait à la relation de récurrence un+1 ≡ aun + c (mod m), la valeur initiale (la « graine ») u0 étant 0 au démarrage de Scilab. On peut obtenir la valeur courante un de la graine par la commande rand(’seed’) et changer la valeur de cette graine par la commande rand(’seed’,k). Cette commande est utile pour répéter à l’identique un tirage aléatoire et pouvoir ainsi contrôler ses résultats.

2.1.2

La fonction grand

La commande grand permet de simuler directement la plupart des lois usuelles. Elle fait appel à un générateur beaucoup plus sophistiqué (en fait, elle permet même d’utiliser différents générateurs très performants), ce qui constitue une raison supplémentaire de l’utiliser. On peut ainsi simuler des lois uniformes, des lois normales uni ou multidimensionnelles, des lois géométriques, des lois exponentielles, des lois gamma, des lois bêta, des lois du χ2 , des lois uniformes sur un intervalle de réels ou d’entiers, . . . Elle permet également de simuler l’évolution de chaînes de Markov à espace d’états fini, ainsi que de générer des permutations aléatoires. Pour plus de détails et pour les différents paramètres permettant d’obtenir ces lois, consulter l’aide de la rubrique grand, dans le chapitre Fonctions de distributions statistiques. Elle ne permet pas de simuler directement une loi arbitraire sur un ensemble fini (on peut cependant simuler une chaîne de Markov dont la matrice de transition a toutes ses lignes égales, 19

ou utiliser une loi multinomiale). Pour simuler une telle loi p = (p1 , . . . , pr ) sur l’ensemble {1, . . . , r}, où r est un entier et (p1 , . . . , pr ) une famille de réels positifs de somme 1, on peut définir sa propre fonction. Par exemple : function x=drand(m,n,p) //matrice mxn de nombres pseudo-aléatoires de loi p sur [1,...,length(p)] cp=cumsum(p); y=rand(m,n);// ou : y=grand(m,n,’def’) x=ones(y); for k=1:length(p)-1, ind=find(y>cp(k)); x(ind)=x(ind)+1; end; endfunction; Si p est une loi sur un ensemble fini {x1 , . . . , xr } et non pas sur {1, . . . , r}, on en obtient un échantillon de taille n en écrivant x(drand(1,n,p)), où x est le vecteur x1 , . . . , xr .

2.1.3 2.1.3.1

Simulation de lois quelconques Inversion de la fonction de répartition

On sait que si F est une fonction de répartition sur R et G la fonction (appelée pseudo-inverse de F ) de ]0,1[ dans R définie par : G(x) = sup{y ∈ R | F (y) < x} = inf{y ∈ R | F (y) ≥ x} , la variable aléatoire G(U ), où U est une variable aléatoire de loi uniforme sur [0, 1], admet pour fonction de répartition F . On peut donc ainsi simuler une variable aléatoire de fonction de répartition F quelconque, à condition toutefois que la fonction G ne soit pas trop difficile à implémenter. C’est en fait cette méthode qui a permis de simuler une variable aléatoire discrète à valeurs dans {1, . . . , r} (la fonction de répartition F était dans ce cas en escalier, ainsi que G). En particulier, si F est une bijection d’un intervalle I de R sur ]0, 1[, la fonction G n’est autre que la bijection réciproque de F . C’est le cas dans les exemples qui suivent : Exemple : loi exponentielle Une variable aléatoire réelle suit la loi exponentielle de paramètre λ > 0 si elle admet la densité λe−λx sur ]0, +∞[. Sa fonction de répartition F (x) = 1−e−λx 1 définit une bijection de ]0, +∞[ sur ]0, 1[ dont la bijection réciproque est G(y) = − ln(1 − y). λ 1 1 La variable aléatoire − ln(1 − U ) (ou encore − ln(U ), puisque U et 1 − U ont même loi), où λ λ U suit la loi uniforme sur ]0, 1[, suit donc la loi exponentielle de paramètre λ. Pour simuler un échantillon de cette loi, on peut donc utiliser indifféremment les commandes : lambda=2;n=1;m=1000; x=-log(grand(n,m,’def’))/lambda; ou x=grand(n,m,’exp’,1/lambda) cette loi étant déjà préprogrammée dans Scilab (attention : le paramètre à entrer est la 1 moyenne de la loi, i.e. , et non λ). λ 20

Exemple : loi de Cauchy Une variable aléatoire réelle suit la loi de Cauchy de paramètre c >0 1 x c 1 1 si elle admet la densité sur R. Sa fonction de répartition est F (x) = + arctan . 2 2 π c + x 2 π c  1 La variable aléatoire c tan π(U − ) (ou, plus simplement, c tan(πU )), où U suit la loi uni2 forme sur ]0, 1[, suit donc la loi de Cauchy de paramètre c. La loi de Cauchy de paramètre 1 est aussi la loi du quotient de deux variables aléatoires gaussiennes réduites indépendantes, ce qui fournit une autre façon de simuler cette loi. Les deux commandes n=10000;x=tan(%pi*rand(1,n)); et n=10000;x=rand(1,n,’n’)./rand(1,n,’n’); fournissent donc toutes deux un échantillon de cette loi. 2.1.3.2

La méthode de rejet

Soit f une densité de probabilité bornée et à support borné : f est nulle en-dehors d’un intervalle [a, b] et majorée par un réel M . Soit (Yn )n≥1 une suite indépendante de variables aléatoires de loi uniforme sur [a, b] et (Un )n≥1 une suite indépendante (et indépendante de la précédente) de variables aléatoires de loi uniforme sur [0,1]. On montre alors que la variable aléatoire T à valeurs dans N ∪ {+∞} définie par f (Yn ) T = inf{n ≥ 1 | Un ≤ } M est presque sûrement finie et suit une loi géométrique et que la variable aléatoire réelle X = YT suit la loi de densité f et est indépendante de T . La loi de X est la loi conditionnelle de Y f (Y ) sachant U ≤ . M Ce résultat permet de simuler une variable aléatoire admettant la densité f : on tire Y suivant la loi uniforme sur [a, b], U suivant la loi uniforme sur [0, 1], on accepte Y comme valeur de X si 1 f (Y ) , sinon on rejette Y et on recommence. La probabilité d’accepter Y est α = . U≤ M M (b − a) On a donc intérêt à prendre M le plus petit possible. En pratique, si on veut obtenir un échantillon de grande taille n de la loi de densité f , on génère un échantillon y1 , . . . , ym de taille m = kn de la loi uniforme sur [a, b], un échantillon u1 , . . . , um de même taille de la loi uniforme sur [0, 1], avec k un peu supérieur à 1/α, et on conserve les n f (yk ) premières valeurs yk vérifiant uk ≤ . M Plus généralement, si f et g sont deux densités de probabilité sur R, M un réel positif vérifiant f ≤ M g, (Yn )n≥1 une suite indépendante de variables aléatoires de loi de densité g et (Un )n≥1 une suite indépendante (et indépendante de la précédente) de variables aléatoires de loi uniforme sur [0,1], la variable aléatoire T définie par   f (Yn ) T = inf n ≥ 1 | Un ≤ M g(Yn ) est presque sûrement finie et X = YT suit la loi de densité f . On peut ainsi simuler une variable aléatoire de densité f si l’on sait simuler une variable aléatoire de densité g. On remarque que M ≥ 1 et qu’on a ici encore intérêt à prendre M le plus petit possible. Le résultat est encore valable si f et g sont des densités de probabilité sur Rd . En particulier, pour simuler une variable aléatoire de loi uniforme sur un domaine compact A de Rd , il suffit de simuler une variable aléatoire Y de loi uniforme sur un pavé contenant A. On accepte Y comme valeur si Y appartient à A et on la rejette sinon. 21

Simulation de lois conditionnelles Plus généralement, si A est un événement de probabilité P(A) > 0 lié à une certaine expérience aléatoire et si on veut simuler sous la probabilité conditionnelle P( · | A) une variable aléatoire dépendant de cette expérience, on effectue une suite de tirages successifs sous la probabilité P et on conserve les tirages pour lesquels l’événement A est réalisé. Exemple : une propriété de la loi de Pareto Soit X une variable aléatoire réelle admettant 2 1 la densité 3 sur [1, +∞[. La fonction de répartition FX (x) = 1 − 2 de X s’inverse aisément. Il x x 1 1 √ √ en résulte que X a même loi que , ou encore que , où U suit la loi uniforme sur [0, 1]. 1−U U Une propriété remarquable d’une telle variable est que, pour tout réel b ≥ 1, E(X | X ≥ b) = 2b, ou encore E(X − b | X ≥ b) = b. On peut vérifier cette propriété en simulant un échantillon de grande taille de cette loi et en ne conservant que les valeurs supérieures à b : n=1000000;x=1 ./sqrt(rand(1,n));mean(x),mean(x(x>2)) ans = 1.9996072 ans = 4.0023543 2.1.3.3

Mélange de lois

Les mélanges de lois apparaissent de façon assez naturelle. Considérons par exemple un système constitué de r serveurs en parallèle ; on se connecte sur le k-ième serveur avec une probabilité pk r X pk = 1) et le temps de service sur ce serveur suit une loi exponentielle de paramètre λk (et ( 1

donc d’espérance µk = 1/λk ). On se propose de déterminer la loi du temps de service. Pour modéliser cette situation avec r = 2, on peut utiliser le script suivant : //melange de lois N=5000; p=0.7; X=grand(1,N,’bin’,1,p); //muk: esperance de Yk mu1=3; mu2=1; Y1=grand(1,N,’exp’,mu1); Y2=grand(1,N,’exp’,mu2); Z=X.*Y1 +(1-X).*Y2;

Si on ne s’intéresse qu’à l’échantillon dans son ensemble, et non pas à l’ordre d’apparition des individus, on pourrait tirer d’abord le nombre d’individus de chaque espèce en utilisant une loi multinomiale, puis réunir les échantillons obtenus : y=grand(1,’mul’,nb,p(1:$-1)’) //nb est la taille de l’échantillon //p la loi de probabilité des types (vecteur ligne) x=[]; for k=1:size(y,’r’) x=[x,grand(1,y(k),’exp’,mu(k))]; //mu vecteur des espérances des lois de Poisson end; Si on veut un vrai échantillon, on peut écrire : 22

y=grand(nb,’mul’,1,p(1:$-1)’); for i=1:size(y,’r’) y(i,:)=y(i,:).*grand(1,nb,’exp’,mu(i)); end; x=sum(y,’r’);

2.2 2.2.1

Représentation de lois Représentation de lois discrètes

Une loi discrète sur une partie finie de R peut se représenter par un diagramme en bâtons ou par un diagramme en barres. On dispose pour cela des commande plot2d3 et bar :

x=binomial(0.6,20); subplot(121); plot2d3(0:20,x); subplot(122); bar(0:20,x)

2.2.2

Représentation de lois à densité

Pour représenter graphiquement la densité d’une loi à densité sur R, il suffit d’utiliser la commande plot2d. On peut ainsi vérifier que la loi binomiale de paramètres n et p est proche de la loi normale de mêmes moyenne et variance si n est grand et p et 1 − p pas trop petits : x=binomial(0.6,20); plot2d3(0:20,x,style=5); x1=linspace(0,20);m=12;v=4.8; plot2d(x1,exp(-(x1-m).^2/2/v)/sqrt(2*%pi*v),style=2); 23

0.20 0.18 0.16 0.14 0.12 0.10 0.08 0.06 0.04 0.02 0.00 0

2

4

6

8

10

12

14

16

18

20

Pour représenter la fonction de répartition d’une loi à densité, on peut intégrer numériquement cette densité. Mais la plupart des fonctions de répartition classiques sont préprogrammées (voir la rubrique Fonctions de distributions statistiques de l’aide). Les commandes associées commencent toutes par cdf (Cumulative Distribution Function) : cdfbet (lois bêta), cdfnor (lois normales),. . . Le premier argument en entrée est la chaîne de caractères ’PQ’ si on veut évaluer la fonction de répartition elle-même. On peut ainsi tracer le graphe de la fonction de répartition de la loi normale réduite : x=linspace(-3,3); y=cdfnor(’PQ’,x,zeros(x),ones(x)); plot2d(x,y) ou de la loi bêta de paramètres 1 et 3 : x=linspace(-3,3); y=cdfbet(’PQ’,x,1-x,ones(x),3*ones(x)); plot2d(x,y)

1.0

1.0

0.9

0.9

0.8

0.8

0.7

0.7

0.6

0.6

0.5

0.5

0.4

0.4

0.3

0.3

0.2

0.2

0.1

0.1

0.0

0.0 −3

−2

−1

0

1

2

3

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

On peut aussi, à partir de la fonction de répartition, reconstituer numériquement la densité si celle-ci est suffisamment régulière : x=-3:0.01:3; y=cdfnor(’PQ’,x,zeros(x),ones(x)); dy=100*(y(2:$)-y(1:$-1)); plot2d(x,y); 24

2.2.3

Quantiles

Les commandes cdf* permettent également d’inverser les fonctions de répartition et ainsi de déterminer les quantiles des lois usuelles. Il faut pour cela donner comme premier argument en entrée la chaîne de caractères ’X’. Par exemple, pour déterminer le réel x tel que P(|X| > x) = α, i.e. tel que P(|X| ≤ x) = 1 − α, pour une variable aléatoire réelle X normale réduite, il suffit d’écrire : -->alpha=0.05;x=cdfnor(’X’,0,1,1-alpha/2,alpha/2) x = 1.959964 Ces quantiles seront particulièrement utiles dans la recherche d’intervalles de confiance.

2.3

Echantillons

Un échantillon de taille n d’une variable aléatoire X (ou d’une loi PX ) est une suite X1 , . . . , Xn de n variables aléatoires indépendantes de même loi que X (ou de loi PX ). On aura souvent tendance par la suite à appeler également échantillon de cette variable aléatoire (ou de cette loi) la suite x1 = X1 (ω), . . . , xn = Xn (ω) des valeurs prises par cette suite de variables aléatoires.

2.3.1

Moyenne, variance, covariance empiriques n

1X xi d’un échantillon (x1 , . . . , xn ) est donnée par la fonction n i=1 mean : mean(x) donne le même résultat que sum(x)/length(x). n 1 X (xi − x ¯)2 de cet échantillon est donnée par variance(x) (AttenLa variance empirique n−1 i=1 tion : il s’agit de l’estimateur sans biais de la variance, d’où le facteur n − 1 et non n). La covariance empirique d’une série statistique à deux variables (xi , yi )i=1,...,n est donnée par corr(x,y,1). On peut vérifier que variance(x)=n*corr(x,x,1)/(n-1) : La moyenne empirique x ¯ =

-->n=5;x=rand(1,n,’n’);y=rand(x,’n’); -->corr(x,x,1),variance(x) ans = 0.6437903 ans = 0.8047378

2.3.2

Répartition en classes : les fonctions dsearch et tabul

Pour analyser et visualiser rapidement les propriétés d’un échantillon d’une variable aléatoire réelle (discrète ou continue), on est souvent amené à regrouper ses valeurs par classes. La fonction dsearch (dichotomic search) est là pour cela. La fonction tabul remplit le même rôle dans le cas d’un échantillon d’une loi discrète : elle donne les valeurs distinctes prises par la variable et les fréquences d’apparition de ces valeurs. -->x=floor(5*rand(1,10)) x = 2. 3. 3. 0. 2. -->[ind,occ]=dsearch(x,0:2:4) occ = 6. 4.

1.

1.

25

1.

4.

3.

ind = 1. 2. 2. 1. 1. 1. -->[ind,occ]=dsearch(x,0:2:4,’d’) occ = 1. 2. 1. ind = 2. 0. 0. 1. 2. 0. -->tabul(x) ans = 4. 1. 3. 3. 2. 2. 1. 3. 0. 1.

2.3.3

1.

1.

2.

2.

0.

0.

3.

0.

Représentations graphiques

Pour visualiser les propriétés d’un échantillon d’une loi réelle et tenter d’identifier cette loi, on dispose de plusieurs possibilités : l’histogramme de l’échantillon est analogue au diagramme en bâtons de la loi si cette loi est discrète et permet d’approcher la densité si cette loi en admet une ; le graphe de la fonction de répartition empirique permet dans tous les cas d’approcher la fonction de répartition de la loi théorique. 2.3.3.1

Histogrammes

L’histogramme d’un échantillon est un diagramme constitué de barres verticales juxtaposées, chacune de ces barres représentant le nombre de termes de l’échantillon appartenant à une classe donnée. Pour représenter un histogramme d’un échantillon d’une loi réelle, on commence donc par répartir cet échantillon en classes, chacune de ces classes correspondant aux valeurs appartenant à un certain intervalle de R, et on représente cette classe par un rectangle vertical dont l’aire est proportionnelle à l’effectif de la classe. On normalise souvent ces aires de façon à ce que l’aire totale soit égale à 1 (comme l’aire sous la courbe représentative d’une densité de probabilité). La commande histplot permet de tracer directement un tel histogramme. Son premier argument est soit un entier (nombre de classes) soit un vecteur dont les composantes donnent les limites des classes. Son second argument est le vecteur x = (x1 , . . . , xn ) des données ; on peut aussi ajouter des arguments de style comme dans plot2d. // melange de lois normales N=5000; p=0.7; X=grand(1,N,’bin’,1,p); //faire varier les paramètres Y1=grand(1,N,’nor’,0,1); Y2=grand(1,N,’nor’,4,1); Z=X.*Y1 +(1-X).*Y2; histplot(100,Z); function y=f(x) // la densité du mélange y=(p/sqrt(2*%pi))*exp(-x.^2/2)+((1-p)/sqrt(2*%pi))*exp(-(x-4).^2/2); endfunction;

26

u=linspace(min(Z),max(Z),200); plot2d(u,f(u),5,"000"); legends([’histogramme’;’densite théorique’],[1,5],2); xtitle(’mélange de deux gaussiennes’);

mélange de deux gaussiennes 0.35 histogramme densite théorique 0.30

0.25

0.20

0.15

0.10

0.05

0.00 −4

−2

0

2

4

6

8

Si le premier argument est un entier (nombre de classes), les classes sont de longueurs égales, la limite inférieure de la première classe est le minimum min(x) des données et la limite supérieure de la dernière le maximum max(x) des données. La commande histplot(p,x) équivaut donc à histplot(linspace(min(x),max(x),p+1),x). Si le premier argument est un vecteur (a1 , a2 , . . . , ap+1 ), l’histogramme est obtenu en déterminant le nombre de données dans chaque classe Ci (i = 1, . . . , p), où la première classe C1 est égale à l’intervalle fermé [a1 , a2 ] et les classes suivantes Ci aux intervalles semi-ouverts ]ai , ai+1 ]. Ni Les rectangles de base [ai , ai+1 ] (i = 0, . . . , p) et de hauteur , où Ni est le nombre N (ai+1 − ai ) de données xk appartenant à la classe Ci et N le nombre total de données (N=length(x)), sont alors dessinés. L’histogramme est ainsi normalisé : si a1 ≤ min(x) ≤ max(x) ≤ ap+1 , la somme des aires des rectangles représentés est égale à 1. On peut changer ce comportement par défaut en ajoutant l’argument normalization=%f. Si on veut représenter l’histogramme d’un échantillon de valeurs entières, on a donc intérêt à préciser les limites (entières) de chaque classe : par exemple, si x est un échantillon d’une loi portée par {0, 1, 2}, la commande histplot(4,x) divisera l’intervalle [0, 2] en quatre intervalles de même longueur (si les valeurs 0 et 2 sont prises par l’échantillon), soit [0, 1/2], ]1/2, 1], ]1, 3/2], ]3/2, 2] et la troisième classe sera toujours vide. Il faut faire attention également à ce que la première classe est fermée : ainsi si x est à valeurs dans {0, . . . , m}, la commande histplot(0:m,x) mettra les valeurs 0 et 1 dans la même classe. Pour remédier à ce problème, il suffit par exemple d’entrer histplot((-0.5:m+0.5,x) (les rectangles dessinés seront alors centrés en les valeurs prises). Si on représente ainsi un échantillon x = (x1 , . . . , xN ) de grande taille d’une loi admettant N 1 1 X une densité continue f , la valeur 1{ai 0, αaα de densité 1+α 1[a,+∞[ (x). Estimer, pour différentes valeurs des paramètres, l’espérance et la variance x de cette loi (on pourra, soit étudier la loi de ln(X) pour X suivant cette loi, soit expliciter l’inverse de sa fonction de répartition)). Représenter sur un même graphique l’histogramme de cet échantillon et la densité de sa loi. Vérifier la propriété suivante de la loi de Pareto : si X suit la loi de Pareto αb , ce qui s’écrit encore de paramètres α > 1 et a > 0, alors pour tout b ≥ a, E(X | X ≥ b) = α−1 b E(X − b | X ≥ b) = . α−1 Exercice 2.6. Loi de Weibull : Une variable aléatoire réelle positive X suit la loi de Weibull de paramètre d’échelle λ > 0 et de paramètre de forme a > 0 si sa fonction de répartition F vaut a

F (x) = 1 − exp [− (λx) ]

30

pour x ≥ 0 .

Montrer qu’une variable aléatoire suivant une loi de Weibull admet une densité dont on donnera l’expression. Représenter graphiquement cette densité pour diverses valeurs du paramètre a. Calculer l’espérance d’une variable aléatoire suivant une loi de Weibull. Que peut-on dire d’une loi de Weibull de paramètre de forme a = 1 ? Pourquoi le paramètre λ est-il appelé paramètre d’échelle ? Montrer que si une variable aléatoire U suit la loi uniforme sur [0, 1], alors la variable aléatoire X = 1 1/a [− ln(U )] suit la loi de Weibull de paramètres λ et a. Utiliser cette propriété pour simuler un λ échantillon de grande taille de la loi de Weibull et représenter un histogramme de cet échantillon. Les lois de Weibull sont souvent utilisées en fiabilité pour modéliser la durée de vie de certains composants. Elles interviennent également dans la loi des valeurs extrêmes. Exercice 2.7. La loi de Fréchet de paramètres a > 0 et α > 0 est la loi sur [0, +∞[ de fonction de répartition exp(−(a/x)α ). Simuler par inversion un échantillon de grande taille de cette loi. Représenter sur un même graphique la fonction de répartition empirique de cet échantillon et la fonction de répartition théorique de la loi. Exercice 2.8. On rappelle que la distance en variation totale de deux lois de probabilité µ et ν sur un ensemble fini ou dénombrable E est définie par : dV T (µ, ν) =

1X |µ({x}) − ν({x})| . 2 x∈E

Evaluez numériquement la distance en variation totale entre la loi de Poisson de paramètre λ et la loi binomiale de paramètres n et λ/n pour différentes valeurs de n et λ. Représentez graphiquement ces deux lois sur une même figure, puis sur deux figures juxtaposées. Exercice 2.9. Loi de Dirichlet On veut tirer au hasard une loi de probabilité sur un ensemble fini à n éléments. On considère pour cela une famille indépendante Y1 , . . . , Yn de n variables aléatoires suivant des lois gamma de paramètres respectifs α1 , . . . αn . Montrer que la somme Y = Y1 + · · · + Yn de ces variables aléatoires suit la loi gamma Y1 Yn de paramètre α1 + · · · + αn et que la famille ,..., suit la loi de Dirichlet de densité Y Y Γ(α1 + · · · + αn ) α1 −1 n −1 p . . . pα 1∆n (p1 , . . . , pn ) n Γ(α1 ) + · · · + Γ(αn ) 1 sur le simplexe ∆n = {(p1 , . . . , pn ) | p1 ≥ 0, . . . , pn ≥ 0, p1 + · · · + pn = 1}. Simuler cette loi dans le cas où tous les αi sont égaux : α1 = · · · = αn = α > 0. Dans ce cas les pi ont, 1 par symétrie, tous la même espérance , mais leur répartition diffère suivant la valeur de α : pour α = 1, n on obtient la loi uniforme sur ∆n ; pour α grand, la loi se concentre autour de sa valeur moyenne, tandis que pour α proche de 0, cette loi se concentre vers le bord du simplexe (typiquement, un petit nombre des pi sont grands et les autres très petits). Vérifier cette propriété dans le cas n = 3 en représentant dans le plan le nuage des points (p1 , p2 ) correspondant à un échantillon de taille 1000. Exercice 2.10. Soit X une variable aléatoire réelle à valeurs dans un intervalle I de R, et F sa fonction de répartition. On suppose que F réalise une bijection de l’intérieur de I sur l’intervalle ]0, 1[ et on note F −1 la bijection réciproque. On souhaite simuler une variable aléatoire suivant la loi conditionnelle de X sachant que X appartient à un sous-intervalle J de I. 1) Proposer une méthode de rejet. La mettre en œuvre dans le cas où X suit la loi normale N (0, 1) et J =]m, +∞[ pour un réel donné m (on prendra successivement m = 1, m = 3, m = 5 et on évaluera la probabilité de rejet). 2) On suppose ici J = [m, +∞[ pour un réel donné m ∈ I. Montrer que la variable aléatoire Z = F −1 (F (m)+(1−F (m))U ), où U est une variable aléatoire de loi uniforme sur ]0, 1[ suit la loi conditionnelle de X sachant X > m. Expliciter cette variable aléatoire dans le cas où X suit la loi exponentielle de paramètre λ > 0. 3) Généraliser la méthode précédente au cas où J =]a, b]. 4) Proposer une méthode de rejet utilisant une loi exponentielle pour simuler une variable aléatoire réelle suivant la loi conditionnelle de X sachant X > m, où X est une variable aléatoire de loi N (0, 1) (on 1 2 cherchera deux réels λ et M strictement positifs tels que √ e−x /2 ≤ M λe−λ(x−m) pour tout x > m). 2π

31

Exercice 2.11. Estimer par simulation la probabilité p(n) que le déterminant d’une matrice aléatoire A d’ordre n dont les coefficients sont des variables aléatoires i.i.d. de loi uniforme sur {−1, 1} soit nul. On estimera p(n) pour n = 2, . . . , 20 et on tracera la courbe représentative de p(n) en fonction de n. Estimer par simulation l’espérance de (det A)2 pour n = 2, . . . , 5. Énoncer, puis démontrer une conjecture sur l’espérance de ce déterminant. Exercice 2.12. Temps de retour en 0 de la marche aléatoire symétrique simple Pnsur Z Soit (Sn )n≥0 la marche aléatoire symétrique simple sur Z issue de 0 : Sn = k=1 Xk , où (Xk )k≥1 est une suite i.i.d. de variables aléatoires de loi P(Xk = 1) = P(Xk = −1) = 0.5. On montre que√le temps de 2 retour T = inf{n ≥ 1 | Sn = 0} de cette marche en 0 a pour r fonction génératrice gT (s) = 1 − 1 − s . On 2 de la queue de T quand t tend vers l’infini. en déduit la loi de T , ainsi que l’équivalent P(T > t) ∼ πt Illustrer la loi de T par simulation et comparer la valeur exacte de la queue de cette loi à son équivalent. Exercice 2.13. On désire simuler la marche Pnaléatoire simple symétrique sur Z conditionnée à revenir en 0 à un instant déterminé. On a donc Sn = k=1 Xk , où (Xk )k≥1 est une suite i.i.d. de variables aléatoires de loi P(Xk = 1) = P(Xk = −1) = 0.5, et on veut simuler des trajectoires (Sk )0≤k≤2n jusqu’à l’instant 2n sous la probabilité conditionnelle P(· | S2n = 0). a) Que peut-on penser de la méthode de rejet ? Donner en particulier un équivalent de la proportion de trajectoires conservées en appliquant cette méthode quand n est grand. b) Proposer une autre méthode. c) Traiter le même problème pour une marche aléatoire simple non symétrique (i.e. pour P(Xk = 1) = p, P(Xk = −1) = 1 − p avec p quelconque dans ]0, 1[). Exercice 2.14. Mots Soit (Xn )1≤n≤N une suite aléatoire de 0 et de 1. On cherche à déterminer, pour toute suite finie s de 0 et de 1, la fréquence d’apparition de cette suite dans la suite (Xn )1≤n≤N . Ainsi la suite s = 00 apparaît trois fois dans la suite 010001100. 1) Ecrire une fonction [n,t]=nbappar(x,s) calculant le nombre n d’apparitions du vecteur s dans le vecteur x ainsi que l’indice t de la première apparition de s. 2) Ecrire une version vectorialisée de cette fonction permettant de rechercher les apparitions d’une même suite s dans chaque ligne d’une matrice x de 0 et de 1. 3) Déterminer le nombre moyen d’apparitions de la suite 00, puis de la suite 01 dans une longue suite aléatoire de 0 et de 1. Simuler ensuite le temps d’attente moyen de la première apparition pour chacune de ces suites. Que constate-t-on ?

Exercice 2.15. Permutations aléatoires Le générateur grand permet de simuler des permutations aléatoires par la commande x=grand(n,’prm’,v) où n est le nombre de permutations souhaité et v le vecteur colonne à permuter ; le résultat x est alors une matrice à n colonnes, chaque colonne représentant une permutation aléatoire du vecteur v. Montrer que l’algorithme suivant génère une permutation aléatoire uniformément répartie du vecteur v de longueur m et écrire une fonction implémentant cet algorithme : pour i = 1, . . . , m − 1, on choisit aléatoirement un entier r dans [i, . . . , m] et on permute vi et vr . Tester cette fonction, par exemple en évaluant la moyenne et la variance du nombre de points fixes de la permutation engendrée. Exercice 2.16. Parties aléatoires a) Simuler un tirage uniforme d’une partie à n élements d’un ensemble E à N éléments (1 ≤ n ≤ N étant des entiers fixés) en utilisant la fonction grand. On supposera ici que l’entier N n’est pas trop grand. b) Adapter l’algorithme étudié à l’exercice précédent à la simulation d’un tel tirage. c) Proposer un algorithme basé sur une méthode de rejet dans le cas où N est très grand et n petit par rapport à N (on pourra par exemple simuler un tirage uniforme de 1000 individus dans une population de 50 millions d’habitants). Exercice 2.17. Echantillons ordonnés, statistique de Wilcoxon Soient x et y deux familles finies de réels supposés tous distincts représentées par des matrices de tailles quelconques. Expliquez pourquoi la fonction suivante compte le nombre de couples (xi , yj ) vérifiant yj < xi : function r=nb(x,y); n=size(x,’*’);

32

m=size(y,’*’); [z,k]=gsort([x(:);y(:)],’g’,’i’); ind=1:n+m; r=sum(ind(k 0. Cette inégalité permet de donner un intervalle de confiance pour l’estimation de E(X1 ) si la variance de X1 est connue, ou si on sait la majorer. Par exemple, dans le cas où les Xn suivent une loi de Bernoulli de paramètre inconnu p, la variance p(1 − p) de X1 est majorée par 1/4. Il en résulte que 1 P(Mn − ε ≤ p ≤ Mn + ε) ≥ 1 − 4nε2 pour tout ε > 0. L’inégalité de Bienaymé-Tchebychev est en fait très mauvaise comme on peut le constater : le programme suivant tire 1000 fois un échantillon de la loi de Bernoulli de paramètre p = 0.5 et compte le nombre de fois où l’inégalité |Mn − E(X1 )| > ε est vérifiée pour n = 105 et ε = 0.01. : 36

n=1e5; nb=1000; epsilon=0.01; m=zeros(1,nb); for k=1:nb x=grand(1,n,’uin’,0,1); m(k)=mean(x); end; sum(abs(m-0.5)>epsilon)/nb ans = 0. On constate que, sur 1000 expériences, la borne n’est jamais dépassée, alors que l’inégalité de Bienaymé-Tchebychev nous apprend simplement que la probabilité qu’elle le soit est inférieure à 1/40. Le théorème limite central nous donne en fait une bien meilleure approximation, puisqu’il nous √ apprend que n(Mn − E(X1)) suit asymptotiquement la loi normale N (0, σX1 ). Il en résulte que  |Mn − 0.5| √ ≥ 1.96 est de l’ordre de 0.05 : dans l’exemple précédent P 2 n sum(abs(m-0.5)>1.96/2/sqrt(n))/nb ans = 0.054

3.2 3.2.1

Convergence des histogrammes et des fonctions de répartition empiriques Théorème de Glivenko-Cantelli

Soit (Xn )n≥1 une suite de variables aléatoires réelles i.i.d. de fonction de répartition F . On rapn 1X pelle que la loi empirique de l’échantillon X1 (ω), . . . , Xn (ω) est la loi de probabilité δXk (ω) . n k=1 La fonction de répartition Fn (ω, ·) de cette loi est appelée fonction de répartition empirique de l’échantillon. Elle est définie par : n

Fn (ω, x) =

1X 1{Xk ≤x} (ω) pour x ∈ R . n k=1

Il résulte immédiatement de la loi forte des grands nombres que, pour tout réel x, Fn (·, x) tend presque sûrement vers F (x) quand n tend vers l’infini. Le théorème de Glivenko-Cantelli affirme que cette convergence est uniforme sur R : Théorème : Soit (Xn )n≥1 une suite de variables aléatoires réelles i.i.d. de fonction de répartition F et Fn la fonction de répartition empirique de l’échantillon X1 , . . . , Xn . Alors la variable aléatoire Dn = sup |Fn (·, x) − F (x)| tend presque sûrement vers 0 quand n tend vers l’infini. x∈R √ √ Plus précisément, la variable aléatoire nDn = n sup |Fn (x) − F (x)| converge en loi vers une x∈R

variable aléatoire W suivant la loi de Kolmogorov-Smirnov de fonction de répartition K(w) =

+∞ X

k −2k2 w2

(−1) e

k=−∞

+∞ X 2 2 (−1)k e−2k w =1+2 k=1

37

pour w > 0 .

Cette convergence en loi est à la base d’un important test d’adéquation, le test de KolmogorovSmirnov (voir 7.2.2). La fonction de répartition de la loi de Kolmogorov-Smirnov n’est pas préprogrammée dans le noyau de Scilab, mais elle est accessible par la commande pks de la boîte à outils Stixbox : x=linspace(0,2);y=pks(x); plot(x,y,’b’); xtitle(’Fonction de répartition de la loi de Kolmogorov-Smirnov’); Fonction de répartition de la loi de Kolmogorov−Smirnov 1.0 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0.0 0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

1.6

1.8

2.0

On montre de plus que la loi de Dn est la même pour toutes les variables aléatoires diffuses : elle ne dépend donc pas de la fonction de répartition F si celle-ci est continue. Vérifions-le pour un échantillon de la loi uniforme sur [0, 1] et un échantillon de même taille de la loi de Cauchy : function d=dks(x,F) //distance de KS de la loi empirique de l’échantillon x à la fr F xs=gsort(x(:)’,’g’,’i’); n=length(xs); Fxs=F(xs);//F doit s’évaluer sur un vecteur d=max(abs([Fxs-(1:n)/n,Fxs-(0:n-1)/n])); endfunction; function y=F1(x),y=x,endfunction; function y=F2(x),y=0.5+atan(x)/%pi,endfunction; n=100; nbsimul=5000; d1=zeros(1,nbsimul);d2=zeros(d1); for k=1:nbsimul x1=rand(1,n); d1(k)=dks(x1,F1); x2=rand(1,n,’n’)./rand(1,n,’n’); d2(k)=dks(x2,F2); end; subplot(121); histplot(20,d1,style=2); xtitle(’Loi uniforme sur [0,1]’); subplot(122); histplot(20,d2,style=5); xtitle(’Loi de Cauchy’);

Loi uniforme sur [0,1]

Loi de Cauchy

18

18

16

16

14

14

12

12

10

10

8

8

6

6

4

4

2

2

0 0.02 0.04 0.06 0.08 0.10 0.12 0.14 0.16 0.18 0.20 0.22

0 0.02 0.04 0.06 0.08 0.10 0.12 0.14 0.16 0.18 0.20 0.22

On remarque que pour calculer Dn , il suffit d’évaluer F en les valeurs Xk prises par l’échantillon. ∗ [, En effet comme F est continue croissante et Fn constante sur chacun des intervalles [Xk∗ , Xk+1 38

où (X1∗ , . . . , Xn∗ ) est l’échantillon (X1 , . . . , Xn ) réordonné par ordre croissant, on a : Dn = max{ |F (Xk ) − Fn (Xk )|, |F (Xk ) − Fn (Xk −)| | k = 1, . . . , n } k k−1 = max{ |F (Xk∗ ) − |, |F (Xk∗ ) − | | k = 1, . . . , n } . n n

3.2.2

Convergence des histogrammes

Si les variables aléatoires Xk admettent une densité continue f , pour tout intervalle [a, b] la pro1[a,b] (X1 ) + · · · + 1[a,b] (Xn ) portion d’éléments de l’échantillon tombant dans l’intervalle [a, b] n Rb tend vers E(1[a,b] (X1 )) = a f (x) dx. Ce nombre est proche de (b − a)f (x) pour xi n[a, b] si la longueur de l’intervalle est petite et la densité suffisamment régulière. Il en résulte que l’histogramme normalisé de l’échantillon est proche du graphe de la densité si le nombre de classes est assez grand.

3.3

Méthode de Monte-Carlo

On appelle méthode de Monte-Carlo toute méthode de calcul numérique consistant à représenter la valeur qu’on cherche à calculer sous forme d’espérance d’une certaine variable aléatoire et à estimer cette espérance par simulation. Historiquement, le premier exemple en est attribué à Buffon, qui a proposé en 1777 une méthode de calcul de π basée sur la simulation d’expériences répétées (jets d’une aiguille sur des lames de parquet), mais ce n’est qu’avec l’apparition des ordinateurs que cette méthode a pris son véritable essor.

3.3.1

L’aiguille de Buffon

On lance une aiguille au hasard sur un plan où sont tracées des droites parallèles et équidistantes. On montre alors facilement que la probabilité pour que l’aiguille rencontre une de ces droites est p = 2l/πd, où l est la longueur de l’aiguille et d la distance entre les droites, à condition de supposer l < d, de sorte que l’aiguille ne peut rencontrer au plus qu’une des droites. En répétant un grand nombre de fois l’expérience, on peut ainsi approcher π par 2lN/nd, où N est le nombre d’expériences et n le nombre de fois où l’aiguille rencontre une des droites. Le programme suivant simule cette expérience. Nombre de lancers: 20 Nombre d’intersections: 13 Approximation de pi: 3.0769231

//une représentation graphique pour vérifier: 39

n=input("Nombre de lancers"); r=rand(3,n); x=[r(1,:);r(1,:)+cos(2*%pi*r(3,:))]; y=[r(2,:);r(2,:)+sin(2*%pi*r(3,:))]; lx=[-1,-1;2,2];ly=[0,1;0,1];rectangle=[-1,0,2,1]; colors=2*ones(1,n); cuts=find(((y(2,:)>1)|(y(2,:)1)|(y(2,:) p + ε) ≤ e−nε P(X

¯ n < p − ε) ≤ e−nε P(X

¯ n − p| > ε) ≤ 2e P(|X

2

/2q

,

2

/2p

,

−nε2 /2

pour tout ε > 0 (bornes de Chernov). Comparer graphiquement cette dernière borne à celle obtenue en appliquant l’inégalité de BienayméTchebychev, puis à la borne asymptotique résultant du théorème limite central. Tester la validité de ces bornes par la simulation.

43

44

Chapitre 4

Variables aléatoires gaussiennes, théorème limite central 4.1

Loi multinormale

Pour générer un échantillon d’une loi multinormale sur Rd de moyenne m et de matrice de covariance Γ données, on utilise la fonction grand avec l’option ’mn’. Le script suivant génère t 2 un échantillon de  taille  100 de la loi de Gauss sur R de moyenne m = (2, 3) et de matrice de 2 1 covariance Γ = et représente dans le plan le nuage de points associé : 1 3 m=[2;3];Gamma=[2 1;1 3];//moyenne et matrice de covariance n=100;//nombre de points du nuage points=grand(n,’mn’,m,Gamma); xbasc(); plot(points(1,:),points(2,:),’.b’); On peut également générer un tel échantillon à partir d’un échantillon de la loi normale réduite (i.e. de moyenne nulle et de matrice de covariance l’identité). En effet si A est une racine carrée symétrique de Γ et Y une variable aléatoire gaussienne réduite, le vecteur aléatoire X = m + AY suit la loi normale d’espérance m et de matrice de covariance AId tA = Γ. Le script suivant génère un échantillon de même taille de la même loi normale et superpose le nuage de points obtenu au précédent : A=sqrtm(Gamma);//racine carrée matricielle: A symétrique positive, A*A=Gamma Y=rand(2,n,’n’);//échantillon de la loi normale réduite X=m(:,ones(1,n))+A*Y;//échantillon de la loi voulue plot(X(1,:),X(2,:),’xr’);

9 8 7 6 5 4 3 2 1 0 −1 −3

−2

−1

0

1

2

45

3

4

5

6

Si on veut représenter la densité d’une loi multinormale non dégénérée sur R2 , on peut opter pour une représentation en 2D ou en 3D. La commande Sfgrayplot permet de représenter cette densité en niveaux de gris. Il faut d’abord entrer l’expression de la densité sous forme d’une fonction Scilab. Reprenons l’exemple précédent : function z=f(x,y)//densité de la loi multinormale z=exp(-[x-m(1),y-m(2)]*inv(Gamma)*[x-m(1);y-m(2)]/2)/2/%pi/sqrt(det(Gamma)); endfunction; xset(’colormap’,graycolormap(32)); x=linspace(m(1)-3,m(1)+3); y=linspace(m(2)-3,m(2)+3); Sfgrayplot(x,y,f); La représentation en 3D s’obtient par la fonction fplot3d fplot3d(x,y,f);//représentation 3D de la densité

8 7 6

0.08 5

0.06 Z

4

0.04

3

0.02

10

2

8

0.00

1

6 −4

0

4

−2 0

−1

2

2 X

−2 −3

−2

−1

0

1

2

3

4

5

6

7

4

Y

0

6 −2 8

On peut également représenter les lignes de niveau de la densité en utilisant la fonction contour2d. Ces lignes de niveau sont aussi celles de la forme quadratique Q(x) = t (x − m)Γ−1 (x − m) associée à la matrice inverse de la matrice de covariance, i.e. des ellipses centrées en m. Plus précisément, si X suit la loi normale N (m, Γ), la variable aléatoire Q(X) = t (X − m)Γ−1 (X − m) suit la loi du χ2 à 2 degrés de liberté. On en déduit que les lignes de niveau de la densité contenant en leur intérieur 50% et 95% de la masse totale de la loi de X sont les ellipses d’équations Q(x) = α et Q(x) = β, où α et β sont les quantiles d’ordre 0.5 et 0.95 de cette loi du χ2 . Le script suivant superpose ces lignes de niveau au nuage de points et vérifie que la proportion de points tombant à l’intérieur de ces lignes est correcte : function z=Q(x,y)//forme quadratique associée à Gamma^-1 z=[x-m(1),y-m(2)]*inv(Gamma)*[x-m(1);y-m(2)]; endfunction; xbasc(); plot(points(1,:),points(2,:),’.b’); x=linspace(min(points(1,:)),max(points(1,:))); y=linspace(min(points(2,:)),max(points(2,:))); xset("fpf"," ");//pour ne pas afficher les valeurs sur la figure cdf=cdfchi(’X’,[2 2],[0.5 0.95],[0.5 0.05]); //quantiles de la loi du chi-deux 46

contour2d(x,y,Q,cdf,style=5*ones(cdf));//lignes de niveau de Q //la moitié des points à l’intérieur de la première ellipse //95% à l’intérieur de la seconde //vérification Qp=zeros(1,n); for k=1:n,Qp(k)=Q(points(1,k),points(2,k));end; sum(Qp 2 (sa variance est alors égale à ). n−2 nb=10000;//taille de l’échantillon n=5;//degrés de liberté a=5;//borne du graphique x=grand(1,nb,’nor’,0,1); y=grand(1,nb,’chi’,n); z=x ./sqrt(y/n); histplot(linspace(-a,a,50),z,style=2); t=linspace(-a,a); y=cdft(’PQ’,t,5*ones(t)); plot2d((t(1:$-1)+t(2:$))/2,(y(2:$)-y(1:$-1))/(t(2)-t(1)),style=5); En particulier, pour n = 1, la loi de Student T (1) n’est autre que la loi de Cauchy de densité 1 1 . C’est aussi la loi du quotient de deux variables aléatoires normales réduites indépenπ 1 + t2 dantes, comme le vérifie le script suivant : t=linspace(-10,10);y=cdft(’PQ’,t,ones(t)); plot((t(1:$-1)+t(2:$))/2,(y(2:$)-y(1:$-1))/(t(2)-t(1)),’+g’) plot2d(t,1 ./(1+t.^2)/%pi,style=2); nb=10000; x=grand(1,nb,’nor’,0,1); y=grand(1,nb,’nor’,0,1); z=x ./y; histplot(-10:0.2:10,z,style=5);

4.2.3

Loi de Fisher-Snedecor

X/n où X et Y Y /p sont des variables aléatoires indépendantes suivant respectivement les lois du χ2 à n et p degrés de liberté. Elle admet la densité :  n/2 n 1 t 2 −1 n f (t) =  (n+p)/2 1[0,+∞[ (t) , B( n2 , p2 ) p 1 + nt p La loi de Fisher-Snedecor F (n, p) de paramètres n et p est la loi du quotient

où la fonction bêta est définie par B(n, p) =

Γ(n)Γ(p) pour n > 0, p > 0. Γ(n + p) 48

nb=10000;//taille de l’échantillon n=10;//degrés de liberté du numérateur p=5;//degrés de liberté du dénominateur x=grand(1,nb,’chi’,n); y=grand(1,nb,’chi’,p); z1=(x/n)./(y/p); histplot(0:0.2:10,z1,rect=[0,0,10,0.7],style=2); t=linspace(0,10); yt=cdff(’PQ’,t,10*ones(t),5*ones(t)); plot2d((t(1:$-1)+t(2:$))/2,(yt(2:$)-yt(1:$-1))/(t(2)-t(1)),style=5); xtitle(’Loi de Fisher F(10,5)’);

Loi de Fisher F(10,5)

0.6

0.5

0.4

0.3

0.2

0.1

0.0 0

4.2.4

1

2

3

4

5

6

7

8

9

10

Échantillons gaussiens

Ces lois interviennent dans l’étude des échantillons des lois normales et jouent un rôle crucial dans plusieurs problèmes d’estimation ou de tests. Si X1 , . . . , Xn est un échantillon d’une loi gaussienne N (m, σ 2 ), on sait que la moyenne empirique ¯ = X1 + · · · + Xn de cet échantillon suit la loi de Gauss N (m, σ 2 /n). X n n 1 X ¯ 2 est indépendante de X ¯ et La variance empirique non biaisée S 2 = (Xk − X) n−1 k=1

(n − 1)S 2 /σ 2 suit la loi du χ2 à n − 1 degrés de liberté.

¯ −m √ X suit la loi de Student à n − 1 degrés de liberté. L’intérêt Il en résulte que le quotient n S de ce résultat est que cette variable aléatoire ne dépend pas de la variance des Xk , qui n’a pas besoin d’être connue. Si X = (X1 , . . . , Xn1 ) et Y = (Y1 , . . . , Yn2 ) sont deux échantillons gaussiens de lois respectives (n1 − 1)S12 N (m1 , σ12 ) et N (m2 , σ22 ) et de variances empiriques respectives S12 et S22 , alors et σ12 (n2 − 1)S22 suivent respectivement les lois du χ2 à (n1 − 1) et (n2 − 1) degrés de liberté et sont σ22 S2 indépendantes. Il en résulte que si σ1 = σ2 , alors F = 12 suit la loi de Fisher F (n1 − 1, n2 − 1). S2 49

Ce résultat ne dépend pas des espérances m1 et m2 des deux échantillons, qui n’ont pas besoin d’être connues, pas plus que la valeur commune de la variance des deux échantillons.

4.3 4.3.1

Théorème limite central Le cas unidimensionnel

Le théorème limite central nous apprend que si (Xn )n≥1 est une suite de variables aléatoires réelles indépendantes équidistribuéesde carré intégrable d’espérance m et d’écart-type σ > 0, et  Sn − nm √ converge en loi vers une variable aléatoire Sn = X1 + · · · + Xn , alors la suite σ n n≥1   Sn − nm √ réelle gaussienne réduite, i.e. pour tout intervalle [a, b] de R, P a ≤ ≤ b tend vers σ n Z b x2 1 √ e− 2 dx. 2π a Cette convergence permet en particulier d’approcher une loi binomiale de paramètres n grand et p pas trop proche de 0 ou de 1 par une loi normale. En pratique, on utilise cette approximation pour np et n(1 − p) tous deux supérieurs à 5. Historiquement, la première version de ce théorème concernait la convergence de chacun des coefficients de la loi binomiale renormalisée : Théorème (de Moivre-Laplace) Si B(n, p, k) désignep la probabilité qu’une variable p aléatoire suivant la loi binomiale B(n, p) prenne la valeur k, alors np(1 − p)B(n, p, [np + x np(1 − p)]) tend vers ϕ(x) quand n tend vers l’infini, où [y] désigne la partie entière de y et ϕ la densité de la loi normale réduite. //la loi binomiale réduite et son approximation gaussienne n=30;p=0.4;q=1-p; pr=binomial(p,n);//loi binomiale B(n,p) valeurs=((0:n)-n*p)/sqrt(n*p*q);//valeurs prises par une variable binomiale réduite plot2d3(valeurs,sqrt(n*p*q)*pr,2);//diagramme en bâtons normalisé x=linspace(min(valeurs),max(valeurs)); plot2d(x,exp(-x.^2/2)/sqrt(2*%pi),5);//densité de la loi normale N(0,1)

0.40

0.35

0.30

0.25

0.20

0.15

0.10

0.05

0.00 −6

−4

−2

0

2

50

4

6

8

4.3.2

Le cas multidimensionnel

Théorème limite central multidimensionnel : Soit (Xn )n≥1 une suite de variables aléatoires indépendantes équidistribuées de carré intégrable à valeurs dans Rd , m = E[X1 ]leur espérance,  Sn − nm √ Γ = ΓX1 leur matrice de covariance, et Sn = X1 + · · · + Xn . Alors la suite n n≥1 converge en loi vers une variable aléatoire gaussienne à valeurs dans Rd de loi N (0, Γ).

4.3.3

Application à la loi multinomiale

Soit (Yn )n≥1 une suite de variables aléatoires indépendantes équidistribuées à valeurs dans un ensemble fini {y1 , . . . , yd } de loi commune p = (p1 , . . . , pd ) : P(Yn = yi ) = pi > 0 pour tout n ≥ 1 et tout i = 1, . . . , d. Notons, pour tout n, Xn la variable aléatoire à valeurs dans Rd : Xn = (1Yn =y1 , . . . , 1Yn =yd ) et : Sn = (Sn(1) , . . . , Sn(d) ) =

n X

Xj

j=1

le vecteur aléatoire des nombres d’obtention des yi au cours des n premières expériences. La variable aléatoire Sn suit la loi multinomiale de paramètres n et p1 , . . . , pd . La loi forte des Sn tend presque sûrement vers p quand n tend vers l’infini grands nombres nous apprend que n Sn − np √ converge en loi vers un vecteur gaussien Z de loi et le théorème central limite que n N (0, Γ), où Γ est la matrice de covariance de X1 . Les coefficients Γi,j de cette matrice valent Γi,j = pi δi,j − pi pj , de sorte qu’on peut écrire Γ = D − tpp, où D est la matrice diagonale de coefficients diagonaux p1 , . . . , pd . Cette matrice a un déterminant nul (la somme de chacune de ses d X lignes ou de ses colonnes est nulle), ce qui traduit la relation de dépendance affine Sn (i) = n, i=1

et la loi normale N (0, Γ) n’admet donc pas de densité par rapport à la mesure de Lebesgue sur Rd . (1)

(d−1)

Par contre la loi de la variable aléatoire S˜n = (Sn , . . . , Sn ) converge vers la loi normale d−1 ˜ centrée sur R de matrice de covariance Γ = (Γi,j )1≤i,j≤d−1 qui est définie positive. Cette loi normale admet donc une densité. Vérifions ce résultat en représentant sur un même graphique, pour d = 3, un nuage de points associé à un échantillon d’une loi multinomiale normalisée (les marqueurs sont des cercles) et le ˜ (les marqueurs sont des croix). nuage de points associé à un échantillon de la loi normale N (0, Γ) nbsimul=100;n=100;p=[0.2;0.5;0.3]; Gammatilde=[p(1)*(1-p(1)),-p(1)*p(2);-p(1)*p(2),p(2)*(1-p(2))]; y=grand(nbsimul,’mul’,n,p(1:$-1));//échantillon de la loi multinomiale plot((y(1,:)-n*p(1))/sqrt(n),(y(2,:)-n*p(2))/sqrt(n),’ob’); z=grand(nbsimul,’mn’,zeros(2,1),Gammatilde);//échantillon de la loi normale plot(z(1,:),z(2,:),’+r’) 51

1.5

1.0

0.5

0.0

−0.5

−1.0

−1.5 −1.5

−1.0

−0.5

0.0

On montre aussi que la variable aléatoire réelle Dn2 =

0.5

1.0

1.5

d (i) X (Sn − npi )2 i=1

npi

converge en loi vers une

variable aléatoire suivant la loi du χ2 à d − 1 degrés de liberté. Cette loi limite ne dépend donc pas de la loi p. Exercice 4.4. Générer un échantillon de la loi multinomiale de paramètres n = 100, p = (0.2, 0.5, 0.3) en simulant n tirages de la loi p. Déterminer la moyenne et la matrice des covariances empiriques de 3 X (Ni − npi )2 , où Ni est le nombre cet échantillon. Comparer aux valeurs théoriques. Évaluer Dn2 = npi i=1 d’occurences de i dans l’échantillon. Refaire la même chose en utilisant la fonction grand pour simuler cet échantillon. Recommencer avec d’autres valeurs de n. Générer un nombre suffisant d’échantillons pour pouvoir comparer la loi empirique de Dn2 à la loi du χ2 à 2 degrés de liberté.

4.4 4.4.1

Mouvement brownien Mouvement brownien standard

On appelle mouvement brownien standard tout processus à temps continu (Bt )t≥0 qui vérifie les propriétés suivantes : (i) B0 = 0 ; (ii) pour tout 0 ≤ s < t, Bt − Bs suit la loi normale centrée de variance t − s ; (iii) pour toute suite 0 < t1 < · · · < tn , les accroissements Bt1 − B0 , Bt2 − Bt1 , . . ., Btn − Btn−1 sont indépendants ; (iv) presque toutes les trajectoires t 7→ Bt (ω) sont continues. Il existe plusieurs façons de construire un tel processus ; nous en admettrons ici l’existence. Son importance vient en particulier de ce qu’il apparaît comme limite de nombreuses familles de processus. Pour simuler une trajectoire d’un mouvement brownien, il suffit de simuler des variables gaussiennes indépendantes et d’interpoler les sommes cumulées de ces variables. dt=0.001;//pas tmax=1; nb=5;//nombre de trajectoires B=[zeros(1:nb);cumsum(grand(tmax/dt,nb,’nor’,0,sqrt(dt)),’r’)]; plot2d((0:dt:tmax)’*ones(1,nb),B); 52

1.5

1.0

0.5

0.0

−0.5

−1.0

−1.5 0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

Exercice 4.5. On peut démontrer que pour tout réel t > 0, la variable aléatoire Bt∗ = max Bs suit la 0≤s≤t

même loi que |Bt |. Vérifier cette propriété en simulant un grand nombre de trajectoires du mouvement brownien et en représentant les histogrammes de ces deux variables aléatoires.

On montre facilement que, pour tout couple (s, t) de réels positifs, la covariance des variables aléatoires Bs et Bt est égale à min(s, t). On pourrait utiliser cette propriété pour simuler les trajectoires d’un mouvement brownien. Cette approche est à déconseiller dans le cas du mouvement brownien, mais elle peut s’avérer utile pour simuler d’autres processus gaussiens. Exercice 4.6. Simuler une trajectoire d’un mouvement brownien en utilisant une loi multinormale.

4.4.2

Mouvement brownien dans Rd (1)

(d)

Un processus à temps continu Bt = (Bt , . . . , Bt ) à valeurs dans Rd est un mouvement brow(i) nien standard si ses composantes Bt (i = 1, . . . , d) sont des mouvements browniens standard indépendants. Il est facile de simuler une trajectoire d’un tel processus : dt=0.001; tmax=1; B=[zeros(2,1),cumsum(grand(2,tmax/dt,’nor’,0,sqrt(dt)),’c’)]; plot2d(B(1,:),B(2,:),frameflag=4);//échelle isométrique

0.6

0.4

0.2

0.0

−0.2

−0.4

−0.6

−0.8 −1.0

−0.5

0.0

53

0.5

4.4.3

Pont brownien

Le pont brownien standard est le processus (Zt )0≤t≤1 défini par Zt = Bt − tB1 , où (Bt )t≥0 est un mouvement brownien standard. Il représente le mouvement brownien standard conditionné à revenir en son point de départ à l’instant 1. C’est un processus gaussien centré de matrice de covariance Cov(Zs , Zt ) = s(1 − t) pour 0 ≤ s ≤ t ≤ 1. 1.5

1.0

0.5

0.0

−0.5

−1.0

−1.5 0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

Exercice 4.7. Simuler une trajectoire d’un pont brownien en utilisant cette dernière propriété.

Pont brownien et fonctions de répartition empiriques Soit (Xn )n≥1 une suite indépendante de variables aléatoires suivant toutes la loi uniforme sur [0, 1], et Fn la fonction de répartition empirique de l’échantillon (X1 , . . . , Xn ) définie par n

Fn (s) =

1X 1[0,s] (Xk ) n k=1

pour s ∈ [0, 1] .

Pour tout couple 0 < s < t < 1 de réels, la suite (Yn )n≥1 de variables aléatoires à valeurs dans R2 définie par Yn = (1[0,s] (Xn ), 1[0,t] (Xn )) est indépendante équidistribuée d’espérance (s, t) et de matrice de covariance   s(1 − s) s(1 − t) Γs,t = . s(1 − t) t(1 − t)

√ 1 Il en résulte que √ (nFn (s) − ns, nFn (t) − nt) = n(Fn (s) − s, Fn (t) − t) converge en loi vers n une variable aléatoire suivant la loi normale N (0, Γs,t ). Cette loi est celle du couple (Zs , Zt ), où (Z ) est un pont brownien. Plus généralement, pour 0 < s1 < · · · < sr < 1, le r-uplet √ t 0≤t≤1 n(Fn (s1 ) − s1 , . . . , Fn (sr ) − sr ) converge en loi vers (Zs1 , . . . , Zsr ). Ceci laisse penser (et on √ peut démontrer) que la variable aléatoire nDn , où Dn = sup |Fn (s) − s|, converge en loi s∈[0,1]

vers une variable aléatoire suivant la loi de Z ∗ = sup |Zs |. Cette loi n’est autre que la loi de s∈[0,1]

Kolmogorov-Smirnov vue à la section 3.2.1. On sait par ailleurs que la loi de Dn = sup |Fn (s) − F (s)|, où Fn est la fonction de répartition s∈[0,1]

empirique d’un échantillon de taille n d’une loi de fonction de répartition continue F , ne dépend pas de F . Le résultat précédent s’étend donc à toute suite i.i.d. de variables aléatoires réelles de loi diffuse. 54

Exercice 4.8. Simuler un grand nombre de trajectoires du pont brownien. Tracer l’histogramme du maximum des valeurs absolues de ces trajectoires. Représenter sur le même diagramme la densité de la loi de Kolmogorov-Smirnov.

4.5 4.5.1

Processus gaussiens stationnaires Un peu de terminologie

Un processus réel indexé par Z est une suite (Xk )k∈Z de variables aléatoires réelles indexée par Z. En pratique, l’indice k représente souvent le temps, supposé discrétisé. Le processus (Xk )k∈Z est dit de carré intégrable si toutes les variables aléatoires Xk sont de carré intégrable. On peut alors définir la moyenne m du processus comme la fonction m : Z → R qui à tout entier k associe l’espérance m(k) = E(Xk ) de Xk et la fonction de covariance K : Z×Z → R qui à tout couple (i, j) d’indices associe la covariance de Xi et Xj : K(i, j) = Cov(Xi , Xj ). Cette fonction de covariance est définie positive, en ce sens que X zi z¯j K(ki , kj ) ≥ 0 1≤i,j≤n

pour toute famille (k1 , k2 , . . . , kn ) d’entiers relatifs et toute famille (z1 , z2 , . . . , zn ) de nombres complexes. Le processus (Xk )k∈Z est dit gaussien si le vecteur (Xk )k∈I est gaussien pour toute partie finie I de Z. Un processus gaussien est de carré intégrable et sa loi est entièrement déterminée par sa moyenne et sa fonction de covariance. Un processus est dit fortement stationnaire si sa loi est invariante par translation du temps : pour tout entier j ∈ Z et toute famille (k1 , k2 , . . . , kn ) d’entiers relatifs, les n-uplets (Zk1 , . . . , Zkn ) et (Zj+k1 , . . . , Zj+kn ) ont même loi. Un processus de carré intégrable est dit faiblement stationnaire si sa moyenne m et sa fonction de covariance K sont invariantes par translation du temps, autrement dit si sa moyenne m est constante et si K(n + i, n + j) = K(i, j) pour tout triplet (i, j, n) d’entiers relatifs. Il existe alors une fonction paire r : Z → R telle que K(i, j) = r(j − i) pour tout couple (i, j) ∈ Z × Z. Un processus fortement stationnaire de carré intégrable est faiblement stationnaire, mais la réciproque est en général forte. Elle est vraie si le processus est gaussien : tout processus gaussien faiblement stationnaire est fortement stationnaire. On appelle bruit blanc tout processus stationnaire (Wk )k∈Z de carré intégrable de moyenne nulle tel que Wi et Wj soient non corrélées pour i 6= j, i.e. tel que la fonction de covariance r associée soit nulle en-dehors de 0. Un bruit blanc (Wk )k∈Z est dit gaussien si le processus (Wk )k∈Z est gaussien.

4.5.2

Moyennes mobiles

Une série chronologique est simplement une suite de variables aléatoires indexée par le temps, supposé discrétisé. De telles séries interviennent naturellement en météorologie, en économie et dans bien d’autres domaines de la vie économique et sociale. L’utilisation de processus gaussiens pour modéliser de tels phénomènes est justifiée, pour une part par le thérème limite central, mais surtout par la grande facilité avec laquelle sont effectués les calculs dans de tels modèles. Dans l’observation de phénomènes chronologiques, on distingue souvent une tendance déterministe globale (augmentation générale des prix en économie) doublée de variations saisonnières péridodiques, cette évolution déterministe étant perturbée par des variations aléatoires. On modélise souvent ces perturbations par un bruit blanc gaussien. On peut alors être amené à considérer des moyennes mobiles de la série observée pour éliminer les variations saisonnières : par exemple, dans le cas d’une étude des prix de produits agricoles, on fera une moyenne sur les douze mois de l’année. 55

Dans l’exemple suivant, on génère de manière pseudo-aléatoire une série chronologique présentant une tendance haussière doublée d’une variation saisonnière de période 12, l’unité de temps étant le mois ; cette évolution déterministe est perturbée par un bruit blanc gaussien. On commence par estimer la tendance globale, que l’on soustrait à la variation brute ; on estime ensuite les variations saisonnières, que l’on retranche à leur tour pour faire apparaître la partie aléatoire des variations, que l’on représente en même temps que le bruit blanc initial qui nous avait servi à générer l’exemple. On estime ensuite la variance du bruit, ainsi que la corrélation ou l’absence de corrélation de ce bruit, en utilisant la fonction corr de Silab.

2.5

2.0

1.5

1.0

0.5

0.0

−0.5 0

20

40

60

n=10;//nombre d’annees a=0.01;//tendance mensuelle b=0.1;//fluctuations periodiques c=0.05;//fluctuations aleatoires t=1:12*n;//temps e=rand(1,12*n,’n’);//bruit blanc //les pseudo-donnees: x=1+a*t+b*sin(2*%pi*t/12)+c*e; clf plot2d(t,x) //moyennes mobiles: X=zeros(12,12*n-11); for i=1:12 X(i,:)=x(i:12*n-12+i); end; xm=mean(X,’r’); plot2d(12:12*n,xm,style=5); //estimation de la tendance: aest=(x($)-x(12))/(n-1)/12; y=x-aest*t; plot2d(t,y,style=3); //estimation des fluctuations saisonnieres: my=mean(y); 56

80

100

120

fs=zeros(1,12); for i=1:12 fs(i)=mean(y(i:12:12*n))-my; end; //estimation du bruit w=zeros(y); for i=1:n w(1+12*(i-1):12*i)=y(1+12*(i-1):12*i)-fs-my; end; plot2d(t,w,style=2); plot2d(t,c*e,style=4); disp(corr(w,10)) column 1 to 6 0.0028704 0.0004340 column 7 to 10 0.0003022 0.0008124

0.0003434

0.0005744

0.0001707

0.0003716

0.0005102

0.0000684

La fonction corr retourne les autocovariances empiriques de la série X1 , . . . , Xn : n−k 1X ¯ ¯ rˆ(k) = (Xi − X)(X i+k − X) n i=1

¯ désigne la moyenne (X1 + · · · + Xn )/n. En particulier, pour k = 0, rˆ(0) est la variance où X empirique (biaisée). Si le processus est stationnaire, ces autocovariances empiriques convergent quand n tend vers l’infini vers les covariances théoriques r(k). En particulier, dans le cas d’un bruit blanc, rˆ(k) converge vers la variance du bruit blanc si k = 0 et vers 0 pour k > 0. Dans le cas d’une moyenne mobile : Xn =

q X

bj Wn−j

j=0

les covariances théoriques sont données par : r(k) =

(

σ2 0

Pq−k

j=0 bj bk+j

si j ≤ q − k sinon

où σ 2 est la variance du bruit blanc W . Vérifions le pour une moyenne mobile sur 12 mois (et une très longue durée) : n=12000; W=rand(1,n,’n’); X=W(1:$-11); for i=1:11 X=X+W(1+i:$-11+i); end; X=X/12; plot(corr(X,20))

57

4.5.3

Processus auto-régressifs

Un processus autorégressif est un processus (Xn )n∈Z vérifiant une relation de récurrence de la forme p X Xn = ai Xn−i + Wn i=1

pour tout n ∈ Z, où p est un entier positif, les ai des scalaires et (Wn )n∈Z un bruit blanc. Si ap 6= 0, on dit que le processus est autorégressif d’ordre p. Ces processus sont très utilisés, par exemple en économie pour modéliser l’évolution d’un marché : les prix dans le futur sont une fonction linéaire des prix des quelques derniers mois perturbée par une variation aléatoire. Le cas p = 1 Dans ce cas, l’équation s’écrit : Xn = aXn−1 + Wn en notant a = a1 . Le processus est markovien : son évolution future ne dépend de son passé qu’au travers de son état présent (ce n’est plus le cas si p > 1). Si |a| < 1, on peut alors écrire Xn comme somme d’une série : Xn =

∞ X

ak Wn−k .

k=0

Cette série converge presque sûrement et dans L2 . Le processus X apparaît ainsi comme une moyenne mobile d’ordre infini et sa variance se calcule facilement : Var(Xn ) =

∞ X

a2k σ 2 =

k=0

σ2 1 − a2

où σ 2 est la variance du bruit blanc W . La simulation d’un tel processus est donc simple : on simule X0 suivant la loi normale centrée de variance σ 2 /(1 − a2 ), puis on génère le bruit blanc W et on en déduit les Xn en utilisant la relation de récurrence. Pour calculer la fonction de covariance r, il suffit de remarquer qu’elle vérifie la relation de récurrence r(k) = ar(k − 1) pour tout k ≥ 1. Cette relation s’obtient en multipliant l’égalité Xn = aXn−1 + Wn par Xn−k et en prenant l’espérance. Le cas général Si un processus stationnaire centré vérifie la relation de récurrence Xn − a1 Xn−1 − · · · − ap Xn−p = Wn , on obtient, en multipliant cette relation par Xn−k (supposé indépendant de Wn ) et en prenant l’espérance, une relation de récurrence vérifiée par la fonction de covariance r : r(k) = a1 r(k − 1) + a2 r(k − 2) + · · · + ap r(k − p) pour k ≥ p. Si toutes les racines du polynôme q(z) = z p − a1 z p−1 − · · · − ap sont de module strictement inférieur à 1, ou, ce qui revient au même, si toutes les racines du polynôme 1 − a1 z − · · · − ap z p sont extérieures au disque unité, r(k) tend 0 quand k tend vers l’infini. 58

Pour simuler une trajectoire du processus, on peut donc partir d’une valeur quelconque de X0 , . . . , Xp−1 , générer le bruit blanc et utiliser la relation de récurrence pour calculer Xn . La stabilisation autour du processus stationnaire se fera d’autant plus vite que les racines du polynôme q sont petites en module. Estimation des coefficients ai et prévision En statistique, on dispose seulement d’une partie de la série chronologique et le but est de trouver un modèle le plus simple possible rendant compte au mieux de ces données. Si on pense qu’une modélisation par un processus autorégressif peut convenir, le premier problème est de déterminer l’ordre du modèle, i.e. la valeur de l’entier p, puis d’estimer les paramètres ai (1 ≤ i ≤ p) et la variance du bruit blanc au vu des données. On commence par estimer la moyenne et la fonction d’autocovariance en utilisant les covariances empiriques. Si on suppose déterminée la valeur de p, les coefficients ai vérifient les équations de Yule-Walker, qui peuvent s’écrire sous forme matricielle :      r(1) a(1) r(0) r(1) . . . r(p − 1)     r(1)  r(0) . . . r(p − 2)  a(2) = r(2)  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   . . .   . . .  r(p) a(p) r(p − 1) r(p − 2) . . . r(0)

(ces équations s’obtiennent de même que précédemment en multipliant la relation de récurrence définissant le processus successivement par Xn−1 , . . . , Xn−p et en prenant l’espérance). On obtient donc une estimation des ai en résolvant ce système, après avoir remplacé les autocovariances théoriques par leurs estimées. Si on veut essayer de prévoir le futur du processus au vu de son passé, on utilisera comme prévision de Xn+1 l’espérance conditionnelle de Xn+1 connaissant la tribu FnX du passé de X jusqu’à l’instant n : E(Xn+1 | FnX ) = a1 Xn + a2 Xn−1 + · · · + ap Xn−p+1 . Remarque : ces deux types de processus (autorégressifs et moyennes mobiles) sont en fait des cas particuliers d’une classe plus large de processus, appelés processus ARMA (Auto Regressive Moving Average). Un processus ARMA(p, q) vérifie une relation de récurrence du type p X

ai Xn−i =

i=0

q X

bj Wn−j

j=0

pour tout n ∈ Z, où p et q sont deux entiers positifs, les ai et les bj des scalaires et (Wn )n∈Z un bruit blanc. Les moyennes mobiles correspondent donc à p = 0 et les processus autorégressifs à q = 0. Scilab possède une bibliothèque de fonctions arma pour simuler les processus ARMA et estimer leurs paramètres, mais l’étude se situant ici à un niveau élémentaire, nous nous sommes contentés d’utiliser les fonctions statistiques usuelles.

59

60

Chapitre 5

Chaînes de Markov à temps discret 5.1 5.1.1

Simulation de chaînes de Markov Commandes de base

Le générateur grand permet de simuler des trajectoires d’une chaîne de Markov d’espace d’états fini dont on connaît la matrice de transition. La commande Y=grand(n,’markov’,P,x0) renvoie une trajectoire de longueur n de la chaîne de Markov d’espace d’états E = {1, . . . , N }, de matrice de transition P , et d’état initial x0 , où P est une matrice stochastique d’ordre N et x0 un élément de E. On peut simuler simultanément par la même commande m trajectoires de la chaîne en prenant pour x0 un vecteur de longueur m : Y est alors une matrice à m lignes et n colonnes, la i-ième ligne de cette matrice représentant une trajectoire de la chaîne issue de x0 (i). La fonction eigenmarkov(P) renvoie l’unique loi stationnaire d’une chaîne de Markov irréductible de matrice de transition P . Si la chaîne comporte m classes récurrentes, elle renvoie une matrice à m lignes dont la i-ième ligne est la loi stationnaire correspondant à la i-ième classe récurrente. Avec deux arguments en sortie, la commande [M,Q]=eigenmarkov(P) renvoie en outre une matrice Q à m colonnes, où Q(i, j) est la probabilité de terminer dans la j-ième classe, l’état initial étant i. La commande genmarkov renvoie une matrice de transition aléatoire. Ses arguments sont en entrée un vecteur contenant le nombre d’éléments de chacune des classes récurrentes, et le nombre d’états transients. Ainsi genmarkov([n1,n2,...,np],nt) renvoie la matrice de transition d’une chaîne de Markov ayant p classes récurrentes, de cardinaux respectifs n1 , n2 , . . ., np , et nt états transients communiquant tous entre eux. En particulier, la commande genmarkov(N,0) renvoie la matrice de transition d’une chaîne irréductible d’espace d’états {1, . . . , N }. Cette commande peut être utile pour tester certaines propriétés d’une chaîne de Markov. La commande [perm,rec,tr,indsRec,indsT]=classmarkov(P) permet de trouver le nombre d’états transients (tr), les tailles des classes récurrentes (rec), les indices des états récurrents (indsRec) et transients (indsT) ainsi qu’une permutation (perm) de ces indices permettant de mettre la matrice de transition P sous forme canonique. Vérifions pour commencer sur un exemple le théorème ergodique : N=5;n=10000;//5 états, 10000 pas P=genmarkov(N,0);//une seule classe récurrente, pas d’états transients x=grand(n,’markov’,P,1); t=tabul(x);//fréquences de passage 61

eigenmarkov(P)//loi stationnaire t($:-1:1,2)’/n ans = 0.1305591 0.3130950 0.1635297 ans = 0.1301 0.3088 0.1623 0.1997

0.1950212

0.1977949

0.1991

On peut vérifier également que, dans le cas d’une chaîne irréductble apériodique d’espace d’états fini, la matrice P n tend très vite vers la matrice de rang 1 dont toutes les lignes sont égales à la probabilité stationnaire : N=3;P=genmarkov(N,0);P^100,eigenmarkov(P) ans = 0.3159087 0.2556059 0.4284854 0.3159087 0.2556059 0.4284854 0.3159087 0.2556059 0.4284854 ans = 0.3159087 0.2556059 0.4284854 Exercice 5.1. Générer une matrice de transition aléatoire P pour une chaîne ayant 2 classes récurrentes de cardinaux 1 et 3 et une classe transiente de cardinal 4. Étudier la convergence de P n quand n tend vers l’infini et comparer la limite à la matrice QM , où M et Q sont obtenues par la commande eigenmarkov. Que peut-on dire de la matrice QM ?

5.1.2

Chaînes absorbantes

Si une chaîne de Markov (Xn )n≥0 possède r états absorbants et s états transients, la matrice de   Ir 0 transition de cette chaîne peut s’écrire, quitte à renuméroter les états, sous la forme P = R Q   Ir 0 n n , où Q est une matrice sous-stochastique d’ordre s. La matrice P s’écrit alors P = Rn Q n où Rn = (Ir + Q + · · · + Qn−1 )R. La matrice Qn tend vers 0 quand n tend vers l’infini, puisque Qn (i, j) = P(Xn = j | X0 = i) tend vers 0 pour tout état transient j. On en déduit que la n−1 ∞ X X Qk = Is − Qn tend Qk puisque (Is − Q) matrice Is − Q est inversible d’inverse N = k=0

k=0

vers Is . La matrice N est parfois appelée matrice fondamentale de la chaîne. Elle permet en particulier de calculer les temps et les probabilités d’absorption. En effet pour tout couple (i, j) ∞ X P k (i, j) est l’espérance du nombre total de visites en j pour la chaîne issue d’états, U (i, j) = k=0

de i. Ce nombre est fini si j est transient et la somme

r+s X

U (i, j) de ces espérances sur tous

j=r+1

les états transients représente le temps moyen de séjour dans l’ensemble des états transients, i.e. l’espérance du temps T d’atteinte de l’ensemble des états absorbants pour la chaîne issue de i. La matrice N Js , où Js est la matrice colonne d’ordre s dont tous les coefficients valent 1, a donc pour coefficients ces espérances. La loi du temps d’absorption s’obtient en remarquant que Pi (T = n) =

r X j=1

(P n (i, j) − P n−1 (i, j)) .

Soit f une fonction définie sur l’ensemble {1, . . . , r} des états absorbants et g la fonction définie sur l’ensemble des états transients par g(i) = Ei (f (XT )) pour tout i = r + 1, . . . , r + s. La 62

relation g = Rf + Qg s’écrit encore (Is − Q)g = Rf , ou g = N Rf . En particulier si f est la fonction indicatrice d’un état absorbant particulier j0 , la matrice N Rf a pour coefficients les probabilités Pi (XT = j0 ), i parcourant l’ensemble des états transients. La commande genmarkov(ones(1,r),s) fournit une matrice de transition aléatoire pour une chaîne de Markov comportant r états absorbants et s états transients. Elle permet de tester facilement les résultats précédents. r=2;//nombre d’états absorbants s=3;//nombre d’états transients P=genmarkov(ones(1,r),s); Q=P(r+1:r+s,r+1:r+s); N=inv(eye(Q)-Q); t=sum(N*ones(s,1),’c’) R=P(r+1:r+s,1:r); N*R//espérance du temps d’absorption nbsimul=10000; x=grand(50,’markov’,P,(r+s)*ones(1,nbsimul)); //simulation de la chaîne issue de r+s for k=1:r p(k)=sum(x(:,$)==k)/nbsimul; end; p//fréquences d’absorption temps=sum(x>r,’c’)+1; mean(temps)//temps moyen d’absorption en partant de r+s tmax=max(temps); histplot(0:tmax,temps)//histogramme du temps d’absorption tempstheorique=zeros(1,tmax); M=P-eye(P); for k=1:tmax tempstheorique(k)=sum(M(r+s,1:r)); M=P*M; end; plot2d2(0:tmax-1,tempstheorique,style=5);

5.1.3

Estimation de la probabilité de transition

Soit (Xn )n≥0 une chaîne de Markov d’espace d’états fini E et de matrice de transition P . Supposons que l’on sache simuler cette chaîne sans connaître la valeur de P . L’estimateur du maximum de vraisemblance de P est alors donné par : N (i, j) Pˆ (i, j) = N (i)

pour tout (i, j) ∈ E × E tel que N (i) > 0 ,

où N (i, j) est le nombre de transitions de i à j observées et N (i) =

X

N (i, j) le nombre de

j∈E

passages en i observés. Cet estimateur est convergent, i.e. Pˆ (i, j) converge vers P (i, j) quand le nombre de pas observés tend vers l’infini. Exemple Reprenons l’exemple et les notations de la section 5.1.2. Soit j0 un état absorbant, et h la fonction définie sur l’espace d’états par h(i) = Pi (XT = j0 ). On peut montrer que la 63

chaîne conditionnée à être absorbée en j0 est une chaîne de Markov de probabilité de transition Ph définie par P (i, j)h(j) Ph (i, j) = h(i) pour tout état transient i. On souhaite vérifier ce résultat par la simulation. r=2;//nombre d’états absorbants s=3;//nombre d’états transients P=genmarkov(ones(1,r),s); Q=P(r+1:$,r+1:$); R=P(r+1:$,1:r); h=[1;0;(eye(Q)-Q)\(R*[1;0])]; Ph=P; for i=r+1:r+s for j=1:r+s Ph(i,j)=Ph(i,j)*h(j)/h(i); end; end; nbsimul=10000; x=grand(20,’markov’,P,(r+s)*ones(1,nbsimul)); ind1=find(x(:,$)==1); x1=x(ind1,:); i=r+1; ni=sum(x1(:,1:$-1)==i); ni1=sum(x1(:,1:$-1)==i&x1(:,2:$)==1); ni1/ni Ph(i,1) Exercice 5.2. Retournement du temps. Générer une matrice de transition aléatoire P pour une chaîne de Markov Xk irréductible d’espace d’états à 5 éléments. Simuler un nombre n suffisant de pas de cette ˜ chaîne de Markov. Estimer, P Pn pour tout couple (i, j) d’états la fréquence Q(i, j) = N (i, j)/N (i) (où N (i) = n 1 , N (i, j) = 1 ) du nombre de passages de i en j du processus retourné Xn−k k=2 Xk =i k=2 Xk =i,Xk−1 =j ˜ à la matrice Q de terme général Q(i, j) = P (j, i)π(i) , où π (k = 0, . . . , n − 1). Comparer la matrice Q π(j) est la loi stationnaire de la chaîne initiale. Montrer que Q est la matrice de transition d’une chaîne de Markov irréductible. Déterminer la loi stationnaire de cette chaîne de Markov.

5.2

Exemples

Dans beaucoup de cas, le mécanisme de transition d’une chaîne de Markov permet de simuler directement cette chaîne sans avoir à expliciter sa matrice de transition, ce qui permet en particulier de simuler des chaînes d’espace d’états dénombrable.

5.2.1

Le modèle d’urne d’Ehrenfest

Les lois de la mécanique classique sont réversibles : un système confiné finira toujours par revenir à un état proche de son état initial. Or la thermodynamique des particules semble montrer un phénomène diamétralement opposé : un système tend toujours de manière irréversible vers un état d’équilibre. Pour tenter d’expliquer cet apparent paradoxe, les physiciens Paul et Tatiana Ehrenfest ont introduit un modèle d’urne très simple qui porte leur nom. Le modèle physique est le suivant : on considère une enceinte confinée séparée en deux compartiments et contenant N = 2L particules. A l’instant initial, toutes les particules sont dans l’un des compartiments. 64

Elles diffusent ensuite à travers la paroi séparant les compartiments de manière à se répartir entre les deux. Le modèle d’urne associé consiste en deux urnes contenant N boules. A l’instant initial, toutes les boules se trouvent dans l’une des urnes. A chaque unité de temps, on tire au hasard une des N boules et on la change d’urne. 5.2.1.1

Le modèle microscopique

Dans cette description, on considère que toutes les particules (ou les boules) sont discernables. Le système est alors représenté par l’espace d’états E = (Z/2Z)N , où la k-ième coordonnée représente la position de la k-ième particule, ¯0 représentant un des compartiments et ¯1 l’autre. Changer la k-ième particule de compartiment consiste à ajouter à l’état Xn du système à l’instant 1 est situé à la k-ième position. Tirer une particule au hasard 1, . . . , 0), où ¯ n le vecteur (0, . . . , ¯ avec équiprobabilité et la changer d’urne revient donc à ajouter à Xn une variable aléatoire de loi uniforme sur l’ensemble E1 des vecteurs ayant exactement une coordonnée non nulle. La suite (Xn )n∈N n’est autre qu’une marche aléatoire sur E, la loi de chaque pas étant la loi uniforme sur E1 . On peut aussi représenter les éléments de E comme les sommets d’un graphe, deux points étant voisins sur ce graphe si et seulement si ils diffèrent en exactement une coordonnée. La chaîne est alors la marche aléatoire simple sur ce graphe. 5.2.1.2

Le modèle macroscopique

On suppose cette fois les particules indiscernables. L’état du système est alors représenté par le nombre de particules dans chacun des deux compartiments. On choisit donc cette fois pour E l’intervalle d’entiers {0, 1, . . . , N }, l’état Yn du système à l’instant n étant le nombre de particules dans le compartiment initialement vide. La matrice de transition est cette fois donnée par P (i, i− i N −i 1) = , P (i, i + 1) = pour tout i ∈ {0, 1, . . . , N }. Cette chaîne de Markov est récurrente : N N elle revient indéfiniment à son état initial, mais l’espérance du temps de retour est telle que ce retour est physiquement inobservable. En pratique, le système se rapproche très vite de l’équilibre, et semble ensuite osciller très peu autour de sa position d’équilibre. 5.2.1.3

Simulations

On commence par représenter graphiquement pour diverses valeurs de N (par exemple N = 20, 50, 1000) une trajectoire du nombre Yn de particules dans le compartiment initialement vide en utilisant le modèle microscopique. N=50;n=1000; x=zeros(1,N); y=zeros(1,n); for k=1:n-1 i=ceil(N*rand()); x(i)=1-x(i); y(k+1)=y(k)+2*x(i)-1; end; plot(y) On constate que le nombre de particules dans le compartiment initialement vide commence par croître, puis se met à osciller autour de la valeur moyenne N/2. On peut également utiliser ce modèle pour simuler la loi du temps d’atteinte de cette valeur moyenne (N/2 particules dans chaque compartiment) et évaluer l’espérance de ce temps : nbsimul=10000;t=zeros(1,nbsimul); for j=1:nbsimul, 65

x=zeros(1:N); k=0;y=0; while y1&x0&z($)0&z0 then z=(0:length(loi)-1)*grand(1,’mul’,z,loi(1:$-1)); trajectoires(k,n+1)=z/m^n; else break; end; end; end; plot2d(0:nmax,[zeros(1,nbsimul);trajectoires’])

14

12

10

8

6

4

2

0 0

10

20

30

40

50

60

70

80

90

100

Exercice 5.5. Population totale d’un processus de Galton-Watson. T −1 ∞ X X Zn la population totale d’un processus de Galton-Watson et h sa fonction Zn = Soit Y = n=0

n=0

70

génératrice. La variable aléatoire Y est finie si et seulement si T l’est et son espérance est, si m < 1, ∞ X 1 la somme E(Zn ). La fonction génératrice h(s) = E(sY ) de Y vérifie, pour tout de la série 1−m n=0 s ∈ [0, 1], h(s) = sg(h(s)) (conditionner par rapport à la taille Z1 de la génération à l’instant 1). C’est s donc la fonction réciproque de la fonction s → . g(s) 1) Expliciter cette solution dans le cas où p0 + p2 = 1. En déduire dans ce cas la loi de Y . Montrer que cette loi est celle du temps d’atteinte de 1 par la marche aléatoire simple sur Z de paramètre p = p0 . Vérifier ce résultat par la simulation. 2) Dans le cas où la loi du nombre de descendants est la loi de Poisson de paramètre θ < 1, on montre k k−1 pour k ≥ 1. Vérifier ce que la loi de Y est la loi de Borel de paramètre θ sur N∗ : P(Y = k) = e−kθ k! résultat par simulation. 3) Dans le cas où le nombre de descendants est borné, déterminer numériquement la loi de la population totale. Vérifier ce calcul par simulation.

5.2.4

L’urne de Polya

Une urne contient des boules noires et des boules blanches. On effectue une suite de tirages dans cette urne de la façon suivante : à chaque tirage, on tire une boule avec équiprobabilité, on regarde sa couleur, on la remet dans l’urne et on y rajoute une boule de la même couleur. On note Nk (resp. Bk ) le nombre de boules noires (resp. blanches) dans l’urne après k tirages, et Bk la proportion de boules blanches après ces k tirages. Xk = Bk + N k La loi conditionnelle de (Bk+1 , Nk+1 ) sachant (Bk , Nk ) est donnée par : b b+n n . = Nk + 1 | Bk = b, Nk = n) = b+n

P(Bk+1 = Bk + 1, Nk+1 = Nk | Bk = b, Nk = n) = P(Bk+1 = Bk , Nk+1

Il en résulte que (Xk )k∈N est une martingale positive, qui converge donc presque sûrement. La loi de la limite sous les conditions initiales B0 = i, N0 = j est  la loi bêta B(i, j).  En particulier 1 k+1 pour B0 = N0 = 1, Xk suit pour tout k l’équiprobabilité sur ,..., ; sa limite suit k+2 k+2 donc la loi uniforme sur [0, 1]. On peut vérifier ces résultats par la simulation. Commençons par représenter quelques trajectoires :

nbsimul=10; nbpas=100; for k=1:nbsimul b=ones(1,nbpas); for i=1:nbpas-1 if rand() 0 la distance de l’origine à D. On suppose que les points (p, θ) associés à la famille de droites aléatoires constituent une réalisation d’un processus de Poisson d’intensité constante λ sur [0, +∞[×[0, 2π[. 1) Représenter l’intersection du carré [−A, +A]2 , où A est un réel donné, avec les droites de ce processus. 2) On peut montrer que la loi de cette famille de droites est invariante par toutes les isométries du plan. Vérifier que les distances d’un point fixé du plan à cette famille de droites constituent bien une réalisation d’un processus de Poisson sur [0, +∞[ et préciser l’intensité de ce processus.

76

6.2 6.2.1

Processus markoviens de sauts Définition et propriétés

Un processus à temps continu (Xt )t≥0 à valeurs dans un espace fini ou dénombrable E est un processus de sauts s’il existe une suite strictement croissante (Tn )n≥1 tendant vers l’infini d’instants aléatoires (les instants de sauts) tels que Xt soit constant sur chaque intervalle [Tn , Tn+1 [ et vérifie XTn+1 6= XTn pour tout n ≥ 0 (en posant T0 = 0). Un processus de sauts est markovien si, pour tout t ≥ 0, la loi conditionnelle du futur (Xs )s≥t du processus sachant tout son passé (Xs )0≤s≤t est égale à la loi conditionnelle du futur (Xs )s≥t sachant Xt . Un processus markovien de sauts peut se décrire de la façon suivante : si à l’issue du saut intervenu à l’instant Tn , le processus se trouve en un état x de E, il reste en x pendant un temps aléatoire Tn+1 − Tn suivant une loi exponentielle de paramètre λ(x) (dépendant de x) et indépendant de son passé ; à l’instant Tn+1 , il saute de l’état x en un état y avec une probabilité p(x, y) indépendante de tout son passé (y compris la durée de séjour Tn+1 − Tn en x). La matrice P est donc la matrice de transition d’une chaîne de Markov à temps discret d’espace d’états E de diagonale nulle. La chaîne de Markov (XTn )n≥0 est appelée chaîne incluse du processus (Xt )t≥0 . Les probabilités de transition du processus (Xt )t≥0 sont définies par : Pt (x, y) = P(Xt = y | X0 = x) = P(Xs+t = y | Xs = x) pour tout (x, y) ∈ E × E et tout (s, t) ∈ [0, +∞[2 . Ces probabilités de transition forment un semi-groupe : Pt+s = Pt Ps pour tout (s, t) ∈ [0, +∞[2 et les fonctions t 7→ Pt (x, y) sont dérivables à droite en tout point. La matrice Q dérivée à droite en 0 de Pt , de coefficients : ( λ(x)p(x, y) si x 6= y Pt (x, y) − δx,y q(x, y) = lim = t→0+ t −λ(x) si x = y est appelée générateur du processus. Tous les coefficients hors de la diagonale de la matrice Q sont positifs ou nuls, et la somme des coefficients d’une ligne est toujours nulle. Les coefficients q(x, y) représentent les intensités de saut du processus : P(Xt = y | X0 = x) = q(x, y)t + o(t)

pour tout y 6= x

et : P(Xt = x | X0 = x) = 1 + q(x, x)t + o(t) = 1 − λ(x)t + o(t) .

Le semi-groupe (Pt )t≥0 vérifie les équations de Kolmogorov : dPt = Pt Q = QPt dt

pour tout t ≥ 0 ,

dPt désigne la dérivée à droite de Pt au point t. dt En particulier, si E est fini, ces équations s’intègrent : Pt = etQ .

où

6.2.2

Lois stationnaires

Une loi de probabilité π sur E est dite stationnaire (ou invariante) si elle vérifie πPt = π pour tout t ≥ 0, ou encore πQ = 0. Si X0 a pour loi une loi stationnaire π, la loi de Xt est égale à π pour tout t ≥ 0. Il n’existe pas toujours de loi stationnaire (le processus de Poisson fournit un exemple élémentaire), mais on montre que s’il existe une et si le processus est irréductible (tous les états communiquent), alors : 77

– cette probabilité invariante est unique ; – Pt (x, y) tend vers π(y) pour tout (x, y) ∈ E 2 (où π est la probabilité invariante) quand t tend vers Z l’infini ; 1 t – 1Xs =y ds tend presque sûrement vers π(y) pour tout y ∈ E quand t tend vers l’infini, et t 0 ce quelle que soit la loi de X0 (théorème ergodique).

6.2.3

Simulation par variables exponentielles

Une interprétation possible de l’évolution du processus est la suivante : quand le processus arrive dans l’état x, un saut potentiel vers l’état y a lieu au bout d’un temps aléatoire de loi exponentielle de paramètre q(x, y) (et donc d’espérance 1/q(x, y)), tous ces temps étant indépendants ; c’est le premier de ces sauts qui se produit effectivement. La loi du temps de séjour en x est donc la loi du minimum d’une famille de variables aléatoires exponentielles X indépendantes de paramètres q(x, y). q(x, y) (y 6= x), i.e. la loi exponentielle de paramètre λ(x) = y6=x

On peut remarquer que c’est ainsi que se présentent naturellement certains processus markoviens de sauts (le processus de Poisson ou les files d’attente M/M/s). Le programme suivant utilise cette représentation pour simuler une trajectoire d’un processus markovien de sauts de générateur donné à valeurs dans un espace d’états fini : function [etats,temps]=markov1(n,Q,x0) //simulation de n sauts d’un processus de générateur Q //état initial x0 //etats: les états visités (y compris l’état initial) //temps: les temps de séjour dans ces états etats=zeros(1,n+1); temps=zeros(1,n); m=size(Q,’c’); etats(1)=x0; ieee(2);//pour autoriser les divisions par 0 P=Q-diag(diag(Q)); for k=1:n t=grand(1,m,’exp’,1)./P(etats(k),:); [temps(k),etats(k+1)]=min(t); end; etats=etats(1:$-1); ieee(0); endfunction; Cette méthode de simulation n’est en général pas la plus efficace du point de vue du temps de calcul.

6.2.4

Simulation par la chaîne incluse

La simulation par la chaîne incluse se base sur la représentation suivante d’un processus markovien de sauts : si (Xn )n≥0 est une chaîne de Markov à temps discret de matrice de transition P , et (Vn )n≥0 une suite i.i.d. de variables aléatoires exponentielles de paramètre 1, la suite des temps n X V (Xk ) Tn = λ(Xk ) k=1

78

est la suite des instants de sauts d’un processus markovien de sauts visitant successivement les états Xk . Le programme suivant utilise cette représentation : function [etats,temps]=markov2(n,Q,x0) //simulation d’une trajectoire de longueur n issue de x0 //d’un processus markovien de sauts de générateur Q //etats: les états visités, temps: les temps de séjour lambda=-diag(Q); P=Q+diag(lambda); P=P./(lambda*ones(lambda’));//matrice de transition de la chaine incluse etats=[x0,grand(n,’markov’,P,x0)]; temps=(grand(n+1,1,’exp’,1)./lambda(etats))’; endfunction;

6.2.5

Simulation par la chaîne harmonisée

Une autre méthode de simulation consiste à utiliser la chaîne de Markov à temps discret de 1 matrice de transition R = I + Q, où Λ est un majorant de {λ(x) | x ∈ E} si λ est majorée Λ (ce qui est toujours le cas si E est fini). Cette matrice est bien la matrice de transition d’une chaîne de Markov à temps discret d’espace d’états E (tous ses coefficients sont positifs et la somme des coefficients de chaque ligne est égale à 1). On montre alors que si (Xn )n≥0 est une chaîne de Markov à temps discret de matrice de transition R, (Vn )n≥0 une suite i.i.d. de variables n X Vk aléatoires exponentielles de paramètre 1, et Tn = , le processus à temps continu égal à Xn Λ k=1 sur l’intervalle [Tn , Tn+1 [ est un processus markovien de sauts de générateur Q. Le programme suivant utilise ce résultat pour simuler une trajectoire de ce processus : function [etats,temps]=markov3(n,Q,x0) //simulation d’une trajectoire de longueur n issue de x0 //d’un processus markovien de sauts de générateur Q //etats: les états visités, temps: les temps de séjour lambda=-diag(Q); lambdamax=max(lambda); R=eye(Q)+Q/lambdamax; etats=[x0,grand(n,’markov’,R,x0)]; temps=grand(1,n+1,’exp’,1)/lambdamax; endfunction; Il faut remarquer que l’on n’obtient pas ainsi n sauts du processus, certains sauts de la chaîne harmonisée étant fictifs : si l’on veut vraiment obtenir n sauts du processus à temps continu, il faut simuler davantage de pas de la chaîne harmonisée. Cette méthode peut néanmoins se révéler plus efficace numériquement que la précédente. Un des avantages de la chaîne harmonisée est que sa loi stationnaire est aussi la loi stationnaire du processus de sauts (ce qui n’est pas le cas pour la chaîne incluse, sauf si les intensités de sauts λ(x) ne dépendent pas de x). La fonction suivante utilise cette remarque pour calculer la loi stationnaire : function pi=eigen(Q) //loi stationnaire d’un processus markovien de saut de générateur Q lambda=-diag(Q); lambdamax=max(lambda); 79

P=eye(Q)+Q/lambdamax; pi=eigenmarkov(P); endfunction; Exercice 6.13. Écrire une autre fonction (utilisant les fonctions d’algèbre linéaire de Scilab) pour calculer la loi stationnaire d’un processus markovien de sauts de générateur donné. Exercice 6.14. Tester les trois méthodes de simulation proposées pour un processus markovien de sauts à deux états. Vérifier dans ce cas le théorème ergodique. Exercice 6.15. Un système est constitué de trois composants A, B, C dont les durées de vie sont des variables aléatoires X, Y , Z indépendantes de lois exponentielles de paramètres respectifs λ, µ, ν. Á l’instant initial, les trois composants sont en état de marche. Une panne de C ou une panne simultanée de A et B entraîne l’arrêt du système. Proposer une modélisation du sytème par un processus de Markov homogène (on distinguera 4 états pour le système, dont l’un absorbant). Écrire le générateur infinitésimal de ce processus. Écrire, puis résoudre les équations de Kolmogorov associées. Simuler le fonctionnement d’un tel système et comparer les probabilités de fonctionnement empiriques aux probabilités de fonctionnement calculées.

6.3

Files d’attente

Une file d’attente est constituée d’un ou plusieurs serveurs dans lesquels arrivent des clients qui sont servis suivant certaines règles ou disciplines (le plus souvent : premier arrivé premier servi, en anglais FIFO : first in first out, ou dernier arrivé premier servi, en anglais LIFO : last in first out, mais il peut y en avoir d’autres...). Le flot d’arrivée des clients constitue un processus de renouvellement à temps continu et les temps de service sont des variables aléatoires indépendantes équidistribuées, indépendantes du processus des arrivées. Nous considérerons d’abord des files d’attente à un seul serveur, où le premier arrivé est le premier servi. Une telle file se note traditionnellement G/G/1, en utilisant les notations de Kendall. Une file d’attente est représentée, dans ce système, par une suite de symboles A/S/P/..., où A représente le type du processus d’arrivées, S la loi du temps de service, P le nombre de serveurs et les points de suspension d’autres paramètres éventuels dont nous ne parlerons pas ; A et S peuvent prendre par exemple les valeurs G (loi générale), D (loi déterministe, pour des temps qui ne dépendent pas du hasard), M (pour Markov : loi exponentielle, ou sans mémoire). La chaîne M/M/1 correspond par exemple à des temps inter-arrivées et de services exponentiels et à un seul serveur.

6.3.1

La file d’attente G/G/1

On considère ici une file d’attente à un serveur. On note An (n ≥ 1) les instants d’arrivée des clients et Yn = An − An−1 les temps inter-arrivées (en posant A0 = 0). Les variables aléatoires Yn sont supposées indépendantes équidistribuées intégrables et on note 1/λ leur espérance commune. Le temps de service du n-ième client est noté Sn . Les variables aléatoires Sn sont également indépendantes équidistribuées, intégrables, indépendantes des instants d’arrivées, d’espérance commune 1/µ. Ces notations s’expliquent : si les arrivées constituent un processus de Poisson, λ E(S1 ) λ en est le paramètre et représente l’intensité du flot d’arrivées. Le quotient ρ = = µ E(Y1 ) s’appelle l’intensité de trafic. On note Nt le nombre de clients dans le système à l’instant t (c’està-dire le nombre de clients en attente ou en train d’être servis). Le comportement asymptotique de la file dépend fortement de la valeur de ρ : si ρ > 1, il arrive en moyenne plus de clients que l’on ne peut en servir ; le serveur va donc finir par se congestionner. Au contraire, si ρ < 1, la file va presque sûrement finir par être vide à certains instants, comme le montre la proposition suivante. 80

Proposition : Si l’intensité de trafic ρ est strictement plus petite que 1, la file se vide presque sûrement une infinité de fois. La fonction suivante prend en entrée les instants d’arrivées des clients et les durées de service d’une file G/G/1 et retourne les instants où un événement (arrivée ou départ) se produit, ainsi que le nombre de clients présents dans la file après chaque événement : function [e,d,n]=GG1(a,s) //file d’attente générale FIFO à un serveur //a: vecteur ligne des instants d’arrivée //s: vecteur ligne des temps de service //(deux vecteurs de même longueur m) //e: instants des événements (arrivées ou départs) //d: vecteur ligne des instants de départs //n: nombre de clients dans la file après chaque événement d=zeros(a);m=length(a); dn=ones(1,2*m);//variation du nombre de clients dans le système: +1 ou -1 d(1)=a(1)+s(1);//premier client for k=1:m-1 d(k+1)=max(a(k+1),d(k))+s(k+1); end; [e,ind]=gsort([a,d],’g’,’i’); dn(ind>m)=-1;//departs n=cumsum(dn); endfunction; Exercice 6.16. Ecrire une fonction retournant le temps d’attente moyen d’un client (temps séparant son arrivée du début de son service), le temps total moyen passé par un client dans le système (temps de réponse = temps d’attente + temps de service), ainsi que la longueur moyenne de la file. Exercice 6.17. Soit R le temps total moyen qu’un client d’une file G/G/1 passe dans le système : n 1X Rk , où Rk est le temps passé par le k-ième client dans le système, et N le nombre R = lim n→+∞ n k=1 Z 1 t moyen de clients présents : N = lim Ns ds. On peut montrer que N = λR (formule de Little). t→+∞ t 0 Vérifier ce résultat par la simulation.

6.3.2

Le cas markovien

Dans le cas des files d’attente M/M/p, où les temps inter-arrivées et les temps de service suivent tous des lois exponentielles et p est un entier ≥ 1 ou +∞, le nombre Nt de clients présents dans le système à l’instant t est un processus markovien de sauts de générateur Q donné par : q(n, n + 1) = λ pour n ≥ 1

q(n, n − 1) = µ min(n, p)

pour m 6∈ {n − 1, n, n + 1}.

q(n, m) = 0

6.3.2.1

La file d’attente M/M/1

Le processus d’arrivées est dans ce cas un processus de Poisson d’intensité λ et les temps de service i.i.d. de loi exponentielle de paramètre µ. Le processus Nt admet une probabilité invariante et une seule si λ < µ. Cette probabilité est alors la loi géométrique sur N de paramètre λ/µ. Le système tend dans ce cas vers un régime stationnaire, le nombre moyen de clients présents dans 81

λ et le facteur d’utilisation du serveur (pourcentage de temps où le serveur est µ−λ occupé, ou probabilité qu’à un instant donné il y ait au moins un client présent dans le système) est λ/µ en régime stationnaire. Si λ > µ, la longueur de la file tend vers l’infini avec le temps. la file est

Exercice 6.18. Simuler en utilisant la fonction GG1 une file d’attente M/M/1 pour différentes valeurs des paramètres λ et µ. Représenter graphiquement l’évolution de la longueur de la file. Vérifier que si ρ < 1 la file évolue vers un régime stationnaire, i.e. Nt converge en loi quand t tend vers l’infini. Identifier la loi limite. Déterminer la longueur moyenne de la file en régime stationnaire. Vérifier que le temps total passé par un client dans le système (temps d’attente + temps de service) suit en régime stationnaire la loi exponentielle de paramètre µ − λ. Démontrer cette dernière propriété. Exercice 6.19. Proposer une autre modélisation de la file M/M/1 basée sur les deux propriétés suivantes : 1. l’absence de mémoire de la loi exponentielle ; 2. le fait que le minimum de deux variables aléatoires exponentielles indépendantes de paramètres λ et µ suit la loi exponentielle de paramètre λ + µ. (En appelant événement un départ ou une arrivée dans la file, on remarquera que le temps séparant deux événements est le minimum de deux variables aléatoires exponentielles indépendantes.)

6.3.2.2

La file d’attente M/M/∞

Dans ce cas, il y a une infinité de serveurs : le temps d’attente est donc nul quelle que soit l’intensité du flot d’arrivées. Le processus Nt admet comme unique probabilité invariante la loi de Poisson de paramètre λ/µ. Le nombre moyen de serveurs occupés est donc λ/µ en régime stationnaire. Exercice 6.20. Simuler une file d’attente M/M/∞ sur un temps suffisamment long. Représenter graphiquement une trajectoire du processus Nt . Vérifier le théorème ergodique et étudier la convergence de Nt vers la loi stationnaire.

6.3.3

Files d’attente à plusieurs serveurs

On peut modifier la fonction GG1 pour gérer une file d’attente LIFO à p serveurs, où p est un entier ≥ 1 : function [e,d,n]=GGp(a,s,p) //file d’attente générale FIFO à p serveurs //a: vecteur ligne des instants d’arrivée //s: vecteur ligne des temps de service //(deux vecteurs de même longueur m) //e: instants des événements (arrivées ou départs) //d: vecteur ligne des instants de départs d=zeros(a);m=length(a); fds=zeros(1,p);//fins de service des différents serveurs dn=ones(1,2*m);//variation du nombre de clients: +1 ou -1 for k=1:m [fdsmin,servmin]=min(fds); serv=min(servmin);//premier serveur libre fds(serv)=max(a(k),fds(serv))+s(k); d(k)=fds(serv); end; [e,ind]=gsort([a,d],’g’,’i’); dn(ind>m)=-1;//départs n=cumsum(dn); endfunction; 82

Dans le cas particulier d’une file M/M/p, on peut montrer que le processus Nt admet une λ probabilité invariante si et seulement si ρ = < 1. La file évolue donc dans ce cas vers un pµ régime stationnaire. Exercice 6.21. On peut montrer qu’en régime stationnaire le nombre moyen de serveurs occupés est égal à λ/µ (comme dans le cas p = ∞). Vérifier ce résultat par la simulation.

Exercice 6.22. Vérifier par la simulation que, dans le cas non saturé (i.e. λ < pµ) le flot des sorties d’une file M/M/p, où p est un entier ≥ 1 ou ∞, est en régime stationnaire un processus de Poisson de même paramètre que le processus de Poisson des arrivées (théorème de Burke).

6.4

Exercices

Exercice 6.23. Processus de renouvellement alterné On veut modéliser le fonctionnement d’une machine qui est alternativement dans deux états : en marche ou en panne. Pour cela, on introduit deux suites (Un )n∈N∗ et (Vn )n∈N∗ de variables aléatoires réelles positives : Un représente la durée de fonctionnement de la machine, Vn le temps qu’il faut pour la réparer. Les variables aléatoires Wn = (Un , Vn ) sont supposées indépendantes et de même loi (mais on ne suppose pas Un indépendant de Vn ). La durée totale du n-ième cycle fonctionnement+réparation est donc Yn = Un + Vn . On voudrait connaître la proportion de temps pendant lequel la machine est en marche. On introduit pour cela un processus (Xt )t≥0 où la variable aléatoire Xt vaut 1 si la machine est en marche Z 1 t Xs ds. Le à l’instant t et 0 sinon. Le but est alors d’étudier la limite quand t tend vers l’infini de t 0 Pn processus (Tn )n∈N , où Tn = k=1 Yk est un processus de renouvellement et il est intuitivement clair (c’est E(U1 ) une conséquence de la loi des grands nombres) que la limite cherchée existe et est égale à E(U1 ) + E(V1 ) si les Un et les Vn sont intégrables. Simuler un tel processus et vérifier cette propriété (on pourra commencer par représenter quelques trajectoires en prenant par exemple pour Un des variables aléatoires exponentielles et pour Vn des variables aléatoires uniformes sur un intervalle compact). Vérifier également que la probabilité que la machine soit E(U1 ) en service à l’instant t tend vers quand t tend vers l’infini. E(U1 ) + E(V1 ) Exercice 6.24. Coalescent de Kingman On reprend l’étude du processus généalogique dans le modèle de Wright-Fisher (cf. exercice 5.3) en supposant que la taille N de la population totale est très grande. On s’intéresse à la généalogie d’un échantillon de taille n fixée de cette population en remontant dans le temps. Si en remontant jusqu’à la k-ième génération, les n individus de l’échantillon ont i ancêtres distints, la probabilité qu’à  la génération   1 1 i +O précédente (i.e. la k + 1-ième, puisqu’on remonte dans le temps) ils en aient i − 1 est N 2 N2   1 et celle qu’ils en aient j est O pour tout j < i − 1. Si maintenant on fait tendre N vers l’infini en N2 renormalisant le temps en posant k = N t, où t est un réel positif, on voit que le nombre Xt d’ancêtres de l’échantillon à l’instant t constitue  un processus markovien de sauts à temps continu de générateur i infinitésimal Q donné par q(i, i − 1) = = −q(i, i) pour tout i = 2, . . . , n. 2 Simuler ce processus et estimer la loi et l’espérance du temps de coalescence, i.e. le temps d’apparition de l’ancêtre commun de l’échantillon le plus proche dans le temps (on remarquera que la chaîne incluse de ce processus est triviale, ce qui en rend la simulation aisée). On peut raffiner le modèle en ne s’intéressant pas seulement au nombre Xt d’ancêtres de l’échantillon à l’instant t, mais à la partition Pt de l’échantillon dont les blocs sont constitués des individus ayant un même ancêtre en remontant de t dans le temps. Le processus Pt est aussi une chaîne de Markov à temps continu d’espace d’états l’ensemble des partitions de {1, . . . , n} (en supposant qu’on ait numéroté les individus de 1 à n), d’état initial la partition constituée de tous les singletons, et de générateur infinitésimal Q donné par q(α, β) = 1 silapartition β est obtenue à partir de α en regroupant exactement i deux classes en une seule, q(α, α) = − si i est le nombre de blocs de la partition α. Autrement dit, 2 deux blocs quelconques fusionnent à un taux constant 1. Le temps de coalescence T est le premier instant

83

où Pt est la partition triviale constituée d’un seul bloc. Simuler cette version du processus, en remarquant par exemple que pour la chaîne incluse la probabilité de transition p(α, β) est uniforme sur l’ensemble des partitions obtenues en regroupant deux blocs de la partition α. Exercice 6.25. Évolution d’une population de bactéries (urne de Polya en temps continu) Une population est constituée de deux types de bactéries, A et B. Chaque bactérie de type A se reproduit à un taux λ et chaque bactérie de type B à un taux µ, indépendamment les unes des autres, et les bactéries ne sont pas supposées mourir, de sorte que le nombre Xt de bactéries de type A et le nombre Yt de bactéries de type B à l’instant t constituent des processus markoviens de saut de générateurs respectifs qA (n, n + 1) = nλ et qB (n, n + 1) = nµ. Ces processus explosent en un temps fini. Simuler sur un temps suffisamment long l’évolution de cette population de bactéries pour pouvoir observer ce phénomène. Montrer que si λ = µ, la chaîne incluse dans la chaîne à temps continu (Xt , Yt ) est une urne de Polya. Xt Etudier en fonction de a = X0 et b = Y0 la loi limite de Zt = quand t tend vers le temps Xt + Y t d’explosion de la population.

84

Chapitre 7

Statistique 7.1 7.1.1

Régions et intervalles de confiance Régions et intervalles de confiance exacts

Si X1 , . . . , Xn est un échantillon de taille n d’une loi normale de moyenne inconnue m et de variance connue σ 2 , l’estimateur du maximum de vraisemblance de m est la moyenne empirique X1 + · · · + Xn Xn = de l’échantillon. De plus X n suit la loi normale de moyenne m et de n 2 σ variance . Il en résulte que n P(X n − a ≤ m ≤ X n + b) = P(m − b ≤ X n ≤ m + a) = P(−b ≤ Z ≤ a) pour tout couple (a, b) de réels, où Z est une variable aléatoire réelle de loi normale de moyenne σ2 nulle et de variance . Tout intervalle [−b, a] vérifiant P(−b ≤ Z ≤ a) = α est donc un intervalle n de confiance exact pour m au niveau α. Le choix le plus naturel consiste à prendre un intervalle 1−α de confiance symétrique, i.e. vérifiant a = b. On a alors P(Z ≤ −a) = et la fonction 2 cdfnor permet de calculer a en fonction de n, α et σ. Le programme suivant calcule un intervalle de confiance au niveau 0.95 pour un échantillon de taille 100 d’une loi normale d’écart-type 3. Il vérifie ensuite ce calcul en simulant 10000 fois un tel échantillon : on constate bien que dans environ 95% des cas la vraie valeur du paramètre appartient à l’intervalle de confiance obtenu. alpha=0.95;n=100;sigma=3; a=-cdfnor(’X’,0,sigma/sqrt(n),(1-alpha)/2,(1+alpha)/2) //vérification m=2;nbsimul=10000; x=grand(nbsimul,n,’nor’,m,sigma); mx=mean(x,’c’); sum(abs(mx-m)