body {
  background-color: #C1E0F9;
}

Exercice 1 : Simulation d’une loi discrète

Question 1 : Expression de X pour une loi binomiale La variable aléatoire X suivant une loi binomiale \(B(p, n)\) peut être exprimée comme la somme de \(n\) variables aléatoires indépendantes \(U_1, U_2, \ldots, U_n\), où chaque \(U_i\) suit une loi de Bernoulli.

Question 2 : Fonction bin(p, n) La fonction bin ici, va permettre de simuler la loi binomiale en effectuant une somme des simulations de la loi uniforme (Bernoulli):

bin <- function(p, n) {
  sum(runif(n) < p)
}

Question 3 : Fonction histobin(s, p, n)

La fonction histobin effectue des simulations d’une distribution binomiale, puis trace un histogramme de ces échantillons :

histobin <- function(s, p, n) {
  samples <- replicate(s, bin(p, n))
  hist(samples, probability = TRUE, main = paste("Histogramme de la distribution binomiale avec n =", n, "and p =", p))
  curve(dbinom(x, n, p), add = TRUE)
}

Question 4 : Loi géométrique

Pour la loi géométrique, adaptez les fonctions en conséquence pour simuler cette loi. D’accord, voici le code R pour générer un histogramme pour la question 7 de l’exercice 2, qui concerne la simulation de la loi exponentielle à partir de la fonction runif :

Question 5 : Fonction uniforme_discret(n)

Ici, on construit la fonction uniforme_discret(n) nous permettant de simuler la loi uniforme sur l’intervalle {1….n}.

La fonction floor est ici utilisée pour nous donner seulement la partie entière du résultat : Exemple : floor(8.9) = 8

n <- 50

uniforme_discret <- function(n) {
  floor(runif(1) * n) + 1
}
# Illustration graphique
samples <- replicate(10000, uniforme_discret(n))
hist(samples, breaks = n, main = "Histogramme de la loi uniforme discrète")

Exercice 2 : Simulation via la fonction de répartition

Pour répondre à l’Exercice 2 sur la simulation via la fonction de répartition (méthode d’inversion) :

Question 6 : Loi exponentielle

Pour montrer que \(X = -\frac{1}{\lambda} \ln |1 - U|\) suit une loi exponentielle, on utilise la propriété de la fonction de répartition. On calcule \(P(X \leq x)\) pour obtenir la fonction de répartition de X, qui correspond à celle d’une loi exponentielle. La fonction de répartition (CDF) d’une variable aléatoire continue \(X\) est définie comme suit :

\[F_X(x) = P(X \leq x)\]

Dans ce cas, nous avons \(X = -\frac{1}{\lambda} \ln |1 - U|\). Pour calculer la fonction de répartition \(F_X(x)\) de \(X\), nous devons trouver la probabilité que \(X\) soit inférieur ou égal à \(x\).

\[ F_X(x) = P\left(-\frac{1}{\lambda} \ln |1 - U| \leq x\right) \] Ensuite on a :

\[ -\ln |1 - U| \leq \lambda x \] Puis :

\[ |1 - U| \geq e^{-\lambda x} \]

Nous pouvons exprimer la probabilité en termes de la variable aléatoire \(U\) :

\[ P\left(|1 - U| \geq e^{-\lambda x}\right) = 1 - P\left(1 - e^{-\lambda x} \leq U \leq 1 + e^{-\lambda x}\right) \]

Nous pouvons maintenant calculer la probabilité en intégrant la densité de probabilité de \(U\) sur cet intervalle :

\[ P\left(1 - e^{-\lambda x} \leq U \leq 1 + e^{-\lambda x}\right) = \int_{1 - e^{-\lambda x}}^{1 + e^{-\lambda x}} du \]

Une fois que nous aurons effectué cette intégrale, nous obtiendrons la fonction de répartition de \(X\) :

\[ F_X(x) = 1 - 2e^{-\lambda x} \]

Cette fonction de répartition sera celle d’une variable aléatoire exponentielle de paramètre \(\lambda\).

Question 7 : Fonction expo(λ)

La fonction expo va nous permettre ici de simuler la loi exponentielle de paramètre \(\lambda\).

expo <- function(lambda) {
  -log(runif(1)) / lambda
}

Question 8 : Fonction histoexpo(s, λ)

A l’image de l’exercice 1, nous utilisons cette fois la fonction histoexpo pour effectuer la distribution avec s et exponentielle de \(\lambda\).

histoexpo <- function(s, lambda) {
  samples <- replicate(s, expo(lambda))
  hist(samples, probability = TRUE, main = paste("Histogramme de distribution exponentielle de parametre lambda =", lambda))
  curve(dexp(x, lambda), add = TRUE)
}

Question 9 : Histogramme pour la loi exponentielle

expo <- function(valeur_lambda, size=1000) {
  -log(runif(size)) / valeur_lambda
}

valeur_lambda <- 1.5

samples <- expo(valeur_lambda)

# Tracer l'histogramme
hist(samples, probability = TRUE, main = paste("Histogramme de la distribution exponentielle avec lambda =", valeur_lambda), xlab = "Valeur", ylab = "Densité")
curve(dexp(x, valeur_lambda), add = TRUE, col = "red", lwd = 2)

Question 10 : Histogramme pour la loi de Cauchy

La loi de Cauchy est utilisée en statistique et probabilité. Elle est caractérisée par une fonction de densité définie telle que :

\[f(x) = \frac{1}{\pi(1 + x^2)}\]

avec x: la variable aléatoire continue

Pour la loi de Cauchy standard, la fonction de répartition inverse est: \[F^{-1}(u) = \tan(\pi(u - 0.5))\]

# Fonction de la loi de Cauchy
cauchy_sim <- function(size=1000) {
  tan(pi * (runif(size) - 0.5))
}

# échantillon
samples <- cauchy_sim()


hist(samples, probability = TRUE, main = "Histogramme de la distribution de Cauchy", xlab = "Valeur", ylab = "Densité", xlim = c(-25, 25), breaks = 50)

# Courbe de densité
curve(dcauchy(x), add = TRUE, col = "red", lwd = 2)

La fonction curve permet de tracer la courbe et add pour l’ajouter à notre graphique déjà present.

Exercice 3: Marches aléatoires

Question 11 : Que vaut A0 et quelle est sa loi de probabilité ?

A0 représente la position initiale du marcheur. Dans cet exemple, le marcheur commence à la position x = 0. Donc, nous avons:

A0 <- 0

La position initiale A0 est une constante (0 dans ce cas).Par conséquent, elle a une probabilité de 1 (ou 100%) d’être égale à 0. En termes de probabilité, cela s’exprime de cette manière:

P_A0 <- 1  # P(A0 = 0) = 1

Question 12 :

set.seed(123)  # Cette fonction permet d'obtenir les mêmes résultats à chaque fois qu'on execute le code
n_simulations <- 10000  # Nombre de simulations

simulation_marche_aleatoire <- function(steps) { # Cette fonction simule la marche aléatoire à un nombre d'étapes.
  sum(sample(c(-1, 1), steps, replace = TRUE))
}
# ces fonctions permettent d'effectuer les simulations 
A1 <- replicate(n_simulations, simulation_marche_aleatoire(1))
A2 <- replicate(n_simulations, simulation_marche_aleatoire(2))
A3 <- replicate(n_simulations, simulation_marche_aleatoire(3))
A4 <- replicate(n_simulations, simulation_marche_aleatoire(4))
A5 <- replicate(n_simulations, simulation_marche_aleatoire(5))

# Ces fonctions vont calculer puis afficher les résultats des simulations
table(A1) / n_simulations
## A1
##     -1      1 
## 0.5017 0.4983
table(A2) / n_simulations
## A2
##     -2      0      2 
## 0.2529 0.4997 0.2474
table(A3) / n_simulations
## A3
##     -3     -1      1      3 
## 0.1266 0.3741 0.3737 0.1256
table(A4) / n_simulations
## A4
##     -4     -2      0      2      4 
## 0.0613 0.2537 0.3747 0.2515 0.0588
table(A5) / n_simulations
## A5
##     -5     -3     -1      1      3      5 
## 0.0292 0.1551 0.3180 0.3153 0.1496 0.0328

Question 13 :

La position moyenne \(\mathbb{E}[A_N]\) après \(N\) pas dans une marche aléatoire à une dimension avec des pas de longueur 1 peut être déterminée en considérant la nature des pas et leur distribution de probabilité.

Chaque pas a deux issues possibles : un pas en avant (+1) ou un pas en arrière (-1), avec une probabilité de 0.5 pour chacune. Le résultat attendu pour un seul pas est donc \(0.5 \times 1 + 0.5 \times (-1) = 0\). Comme les pas sont indépendants, la position moyenne après \(N\) pas est simplement la somme des résultats attendus pour chaque pas.

Formule de la Position Moyenne

Pour \(N\) pas, la position moyenne \(\mathbb{E}[A_N]\) est :

\[ \mathbb{E}[A_N] = N \times \mathbb{E}[pas] = N \times 0 = 0 \]

Cela signifie que, en moyenne, le point noir reviendra à sa position de départ après un grand nombre de répétitions, indépendamment du nombre de pas \(N\).

Simulation avec R

Nous pouvons simuler ce processus avec R pour vérifier que la position moyenne après \(N\) pas tend vers 0.

set.seed(123)  
n_simulations <- 10000  
N <- 10  # Nombre de pas

simulation_marche_aleatoire <- function(steps) {
  sum(sample(c(-1, 1), steps, replace = TRUE))
}

positions <- replicate(n_simulations, simulation_marche_aleatoire(N))

# Fonction afin de calculer la position moyenne
mean_position <- mean(positions)

mean_position
## [1] -0.0322

Question 14 :

La loi de \(A_N\), correspondant à la position après “\(N\) pas” dans une marche aléatoire à une dimension, est une distribution binomiale centrée. Chacun des pas est considéré comme une variable aléatoire indépendante ( Bernoulli ) ayant pour valeurs +1 ou -1. La probabilité est de 0.5 à chaque cas.

Lorsque l’on additionne \(N\) variables aléatoires indépendantes et identiquement distribuées (comme c’est le cas ici avec chaque pas étant soit +1, soit -1), le résultat tend vers une distribution normale

Propriétés de \(A_N\)

  1. Espérance (\(\mathbb{E}[A_N]\)) : Comme déjà mentionné, l’espérance de \(A_N\) est 0.
  2. Variance : La variance de \(A_N\) est \(N \times \text{variance d'un pas}\). Comme la variance d’un pas (qui peut être soit +1, soit -1) est 1, la variance de \(A_N\) est \(N\).
  3. Distribution : Pour des valeurs de \(N\) relativement élevées, la distribution de \(A_N\) s’approche d’une distribution normale avec une moyenne de 0 et une variance de \(N\).

Simulation avec R

On peut désormais effectuer une simulation avec R de nombreuses marches aléatoires pour observer la position finale de nos variables. :

set.seed(123)  # Pour la reproductibilité
n_simulations <- 10000  # Nombre de simulations
N <- 50  # Nombre de pas pour illustrer une grande valeur de N

simulation_marche_aleatoire <- function(steps) {
  sum(sample(c(-1, 1), steps, replace = TRUE))
}

positions <- replicate(n_simulations, simulation_marche_aleatoire(N))

# Histogramme des positions finales
hist(positions, breaks = 50, main = "Distribution des positions finales après N pas", xlab = "Position finale", ylab = "Fréquence")

Question 15 :

Pour calculer l’espérance de \(\mathbb{E}[A_N^2]\) dans une marche aléatoire unidimensionnelle, nous devons considérer la nature des pas et comment ils s’additionnent. Chaque pas peut être +1 ou -1, et la position après N pas est la somme de ces pas individuels.

L’espérance du carré de la position après N pas, \(\mathbb{E}[A_N^2]\), est en fait la variance de la position après N pas, car l’espérance de la position elle-même (\(\mathbb{E}[A_N]\)) est 0.

Dans une marche aléatoire simple, chaque pas est indépendant et a une variance de 1 (puisque les valeurs possibles sont +1 et -1, toutes deux ayant une probabilité de 0.5, la variance de chaque pas est \(1^2 \times 0.5 + (-1)^2 \times 0.5 = 1\)).

Comme les pas sont indépendants, la variance totale, est simplement N fois la variance d’un seul pas, donc \(\mathbb{E}[A_N^2] = N\).

Pour calculer la distance moyenne parcourue, nous considérons la racine carrée de cette espérance. Ainsi,

\[\mathbb{E}[A_N^2]^{1/2} = \sqrt{N}\]

Cela signifie que la distance moyenne parcourue après N pas dans une marche aléatoire unidimensionnelle est proportionnelle à la racine carrée du nombre de pas.

De ce fait, on peut tenter de simuler à l’aide d’un code R ce calcul, en effectuant la racine carrée de la moyenne des carrés des positions finales :

set.seed(123) 
N = 100 
repetitions = 10000 

positions_finale = replicate(repetitions, sum(sample(c(-1, 1), N, replace = TRUE))^2)

mean_square_position = mean(positions_finale)
sqrt_mean_square_position = sqrt(mean_square_position)
print(sqrt_mean_square_position)
## [1] 10.06713

Question 16 :

Dans une marche aléatoire à deux dimensions, les principes sont similaires à ceux de la marche aléatoire unidimensionnelle, mais avec une extension aux deux dimensions(suivant x et y).

Définition de Bₙ : Bₙ est la position du marcheur dans le plan après le N-ème pas. Chaque pas qᵢ est un vecteur dans le plan, et peut être représenté par (xᵢ, yᵢ), où xᵢ et yᵢ peuvent prendre les valeurs +1 ou -1 indépendamment, représentant un pas soit vers l’avant ou l’arrière (pour xᵢ) et soit vers le haut ou le bas (pour yᵢ).

QValeur de B₀ et sa loi de probabilité :

  • Valeur de B₀ : B₀ représente la position initiale du marcheur avant de commencer la marche. Dans notre exemple, (x,y) = (0,0). Donc, B₀ = (0,0).

  • Loi de probabilité de B₀ : Comme B₀ est simplement la position de départ et n’est pas le résultat d’un mouvement aléatoire, sa loi de probabilité est déterministe plutôt qu’aléatoire. Cela signifie que B₀ est toujours (0,0), sans variation ni distribution aléatoire.

Dans la marche aléatoire bidimensionnelle, la position du marcheur après N pas sera le résultat de l’addition de N pas indépendants C’est d’un coté la somme par rapport à x en fonction des valeurs {-1;1} et de même pour y. Ce sont donc deux marches aléatoires unidimentionnelles.

Question 17 :

Pour analyser les lois de probabilité des variables aléatoires B1 et B2 dans une marche aléatoire bidimensionnelle, voici notre démarche :

  1. Définitions de B1 et B2 :
    • B1 et B2 représentent les positions du marcheur après 1 et 2 pas respectivement.
    • Chaque pas est un vecteur de longueur 1. Les pas possibles sont (1, 0), (-1, 0), (0, 1), et (0, -1), correspondant aux directions avant, arrière, haut, et bas.
  2. Loi de probabilité pour B1 :
    • Il y a quatre issues possibles pour le premier pas, chacune ayant une probabilité de 1/4.
    • Donc, B1 peut être (1, 0), (-1, 0), (0, 1), ou (0, -1) avec une probabilité égale de 1/4.
  3. Loi de probabilité pour B2 :
    • Pour B2, nous avons deux pas indépendants. Chaque pas a 4 issues possibles, donc il y a 4 x 4 = 16 combinaisons possibles pour B2.
    • Chaque combinaison a une probabilité de (1/4) x (1/4) = 1/16.
    • Les positions possibles pour B2 sont le résultat de l’addition vectorielle des deux pas. Par exemple, si les deux pas sont (1, 0) et (0, 1), alors B2 sera (1, 1).

Voici un exemple de code R simulant B1 et B2 :

set.seed(123) 

simuler_marche <- function(N) {
  pas_possibles <- matrix(c(1, 0, -1, 0, 0, 1, 0, -1), ncol = 2, byrow = TRUE)
  position <- matrix(c(0, 0), ncol = 2)
  for (i in 1:N) {
    pas <- pas_possibles[sample(1:4, 1), ]
    position <- position + pas
  }
  return(position)
}

# Simuler B1 et B2
set.seed(123)
B1 <- simuler_marche(1)
B2 <- simuler_marche(2)

print("Position après 1 pas (B1):")
## [1] "Position après 1 pas (B1):"
print(B1)
##      [,1] [,2]
## [1,]    0    1
print("Position après 2 pas (B2):")
## [1] "Position après 2 pas (B2):"
print(B2)
##      [,1] [,2]
## [1,]    0    2

Question 18 :

Dans une marche aléatoire bidimensionnelle, où chaque pas est de longueur 1 et se fait soit vers l’avant, l’arrière, le haut, ou le bas avec une probabilité égale, la position moyenne après N pas peut être calculée. Comme chaque direction a la même probabilité, la marche est symétrique.

Pour Bₙ, qui est la position du marcheur après N pas :

  1. Espérance de la position (𝔼[Bₙ]) :
    • Chaque composant de chaque pas (en x et en y) a une espérance de 0, car les mouvements dans les directions positives et négatives se compensent mutuellement.
    • Par conséquent, l’espérance de la position moyenne 𝔼[Bₙ] après N pas est également (0, 0), quel que soit N.

Voici un exemple de code R pour effectuer cette simulation :

set.seed(123) 

simuler_marche_2d <- function(N) {
  pas_possibles <- matrix(c(1, 0, -1, 0, 0, 1, 0, -1), ncol = 2, byrow = TRUE)
  position <- matrix(c(0, 0), ncol = 2)
  for (i in 1:N) {
    pas <- pas_possibles[sample(1:4, 1), ]
    position <- position + pas
  }
  return(position)
}

# Nombre de répétitions et de pas
repetitions <- 10000
N <- 100

# Calcul de la position moyenne
positions_finale <- matrix(c(0, 0), ncol = 2)
for (i in 1:repetitions) {
  positions_finale <- positions_finale + simuler_marche_2d(N)
}
position_moyenne <- positions_finale / repetitions

print("Position moyenne après N pas :")
## [1] "Position moyenne après N pas :"
print(position_moyenne)
##       [,1]   [,2]
## [1,] 0.038 0.0228

Ce script effectue 10 000 simulations d’une marche aléatoire de 100 pas chacune, et calcule la position moyenne après ces 100 pas. Théoriquement, cette position moyenne devrait être très proche de (0, 0).

Question 19 :

Pour trouver la loi de BN pour N=10 et N=25 dans une marche aléatoire bidimensionnelle et la représenter graphiquement, on va effectuer une simulation sur R en s’aidant notamment de la librairie (ggplot2) :

library(ggplot2)

simuler_marche_2d <- function(N) {
  pas_possibles <- matrix(c(1, 0, -1, 0, 0, 1, 0, -1), ncol = 2, byrow = TRUE)
  position <- matrix(c(0, 0), ncol = 2)
  for (i in 1:N) {
    pas <- pas_possibles[sample(1:4, 1), ]
    position <- position + pas
  }
  return(position) # on reprend notre script précedent pour faire une simulation bidimentionnelle
}

effectuer_simulations <- function(N, repetitions) {
  positions <- matrix(nrow = repetitions, ncol = 2)
  for (i in 1:repetitions) {
    positions[i, ] <- simuler_marche_2d(N)
  }
  return(as.data.frame(positions))
} # cette fonction permet de stocker les positions finales après chaque simulation

set.seed(123)
repetitions <- 10000
resultats_10 <- effectuer_simulations(10, repetitions)# on effectue 10 fois la simulation
resultats_25 <- effectuer_simulations(25, repetitions) # on effectue 25 fois la simulation

# Graphique pour N=10
ggplot(resultats_10, aes(V1, V2)) +
  geom_point(alpha = 0.3) +
  ggtitle("Distribution des positions après 10 pas") +
  xlab("Position X") +
  ylab("Position Y")

# Graphique pour N=25
ggplot(resultats_25, aes(V1, V2)) +
  geom_point(alpha = 0.3) +
  ggtitle("Distribution des positions après 25 pas") +
  xlab("Position X") +
  ylab("Position Y")

Les graphiques sont générés avec ggplot2 pour visualiser la distribution des positions finales. On voit que les points sont répartis autour de l’origine (0,0), mais avec une dispersion plus grande pour N=25 par rapport à N=10.

Question 20 :

En marche aléatoire bidimensionnelle, chaque pas est indépendant et a une longueur de 1. La contribution de chaque pas à la distance au carré totale est donc de 1 (car la longueur du pas est 1). Si les pas sont indépendants, alors l’espérance de la somme est la somme des espérances. Par conséquent, après N pas, \(\mathbb{E}[||B_N||^2] = N\).

Pour la distance moyenne, nous calculons la racine carrée de cette espérance :

\[\sqrt{\mathbb{E}[||B_N||^2]} = \sqrt{N}\]

Pour N=25 pas, la distance moyenne que nous nous attendons à ce que le point noir ait parcourue est \(\sqrt{25} = 5\).

Nous allons tenter de confirmer cela à l’aide d’une simulation sur R. On calcule la distance finale moyenne après 25 pas pour un grand nombre de simulations.

simuler_marche_2d <- function(N) {
  pas_possibles <- matrix(c(1, 0, -1, 0, 0, 1, 0, -1), ncol = 2, byrow = TRUE)
  position <- matrix(c(0, 0), ncol = 2)
  for (i in 1:N) {
    pas <- pas_possibles[sample(1:4, 1), ]
    position <- position + pas
  }
  return(position)
}

effectuer_simulations_distance <- function(N, repetitions) {
  distances <- numeric(repetitions) # variable qui stocke la distance entre l'origine et la position finale
  for (i in 1:repetitions) {
    position_finale <- simuler_marche_2d(N)
    distances[i] <- sqrt(sum(position_finale^2)) # calcul pour retrouver la distance finale
  }
  return(distances) 
}

set.seed(123)
N <- 25
repetitions <- 10000
distances_finale <- effectuer_simulations_distance(N, repetitions)

distance_moyenne <- mean(distances_finale)
print(distance_moyenne)
## [1] 4.438763

On voit ainsi qu’on tend vers 5.

Travail réalisé par DROUAUD Victor et BERACHE Lakhdar