Simulation numérique du mouvement Brownien

L'idée pour simuler une trajectoire de mouvement Brownien standrad à différents temps $t_j = j h$ (pour $j\in\{0,\dots,n\}$) est d'utiliser la relation:

$$ W_{jh} = W_{jh} - W_{(j-1)h} + W_{(j-1)h} - W_{(j-2)h} + \dots + W_{h}-W_{0}+W_{0},$$

où $W_0 = 0$, et par définition du mouvement Brownien

$$ (W_{nh} - W_{(n-1)h}, W_{(n-1)h} - W_{(n-2)h},\dots,W_{2h} - W_{h}, W_{h} - W_{0}), $$

sont des variables aléatoires i.i.d de loi $N(0,h)$. Cette remarque rend très simple la simulation d'un tel processus.

En dimension 1

Pour un pas de $h=0.01$ et $n=1000$ (ce qui nous donne un temps final $T=nh=10$), on simule 10 trajectoires (discrétisées) du mouvement Brownien.

Pour cela, on va avoir besoin des librairies suivantes

# importation des librairies nécessaires

import numpy as np              
import numpy.random as npr      # pour la simulation de nombre aléatoire de loi N(0,1)
import matplotlib.pyplot as plt # pour faire des graphiques

N = 10              # nombre de trajectoire brownienne

h = 0.01            # pas de temps
n = 1000            # nombre de pas de temps, temps total T = nh

for _ in range(N):  # on répète N fois la construction d'une trajectoire  

    V = npr.normal(0, 1, n)
    # contient n nombres aléatoires tirés indépendamment de loi N(0,1) 
    
    W = np.sqrt(h)*np.cumsum(V)  # on rappelle que sqrt(h)*V correspond à un échantillon de la loi N(0,h).
    # retourne un vecteur de taille n contennant
    # les sommes cumulées des nombres contenus dans V multiplié par \sqrt{h}   
    
    W = np.append(0, W)
    # on ajoute le point de départ 0 au début de chaque trajectoire 
    
    plt.plot(np.arange(0,(n+1)*h,h),W)
    # dessine la trajectoire qu'on vient de calculer
    
plt.xlabel(r'$t$', fontsize =15)
plt.ylabel(r'$W_t$', fontsize =15)
plt.title('Illustration de 10 trajectoires de mouvement Brownien')
plt.show()

En dimension 2

N = 4                # nombre de trajectoire brownienne

h = 0.01             # pas de temps
n = 1000             # nombre de pas de temps, temps total T = nh

for _ in range(N):   # on répète N fois la construction d'une trajectoire

    V = npr.normal(0, 1, (2,n))
    # contient n vecteurs de taille 2 indépendents de loi N(0,I_2)
    # V à 2 lignes et n colonnes
    # chaque ligne représente une coordonnée d'espace  
    
    W = np.sqrt(h)*np.cumsum(V, axis=1)
    # retourne une matrice de taille (2,n) contennant pour chaque ligne
    # les sommes cumulées des lignes de V (axis=1), 
    # c'est-à-dire par rapport à chaque dimension d'espace, multiplié par \sqrt{h}
        
    W = np.c_[np.array([[0],[0]]), W]
    # on ajoute le point de départ (0,0) au début de chaque trajectoire 
    
    plt.plot(W[0,:],W[1,:])
    # dessine la trajectoire qu'on vient de calculer
    
plt.xlabel(r'$W^{(1)}_t$', fontsize =15)
plt.ylabel(r'$W^{(2)}_t$', fontsize =15)
plt.title('Illustration de 4 trajectoires de mouvement Brownien 2D')
plt.show()