Master Modélisation Aléatoire Paris VII, Cours Méthodes de Monte

Master Modélisation Aléatoire Paris VII,
Cours Méthodes de Monte Carlo en nance et C++,
TP n◦ 2.
Techniques de correction pour les options barrières
25 janvier 2007
Exercice à rendre individuellement lors du cours du 9 Février 2007.
A joindre :
- la rédaction de la partie mathématique ainsi que la justication des techniques employées pour la
simulation.
- les valeurs numériques obtenues et vos commentaires.
- le listing du programme de simulation.
1 Partie mathématique
(Ω, F, (Ft )t≥0 , P) un espace de probabilité ltré muni
d-dimensionnel W . On considère un processus de dynamique
Soit
d'un mouvement Brownien standard
Xt = x + bt + σWt , b ∈ Rd , σ ∈ Rd ⊗ Rd ,
σσ ∗ symétrique dénie positive. Introduisons le demi-espace D := {y ∈ Rd : n · y + m > 0}, n ∈
Rd , m ∈ R, et τ := inf{s ≥ 0 : Xs 6∈ D}. Pour x ∈ D, T > 0 déterministe, et une fonction de pay-o
g donnés, on s'intéresse à l'approximation numérique de la quantité Ex [g(XT )Iτ >T ] associée au prix
avec
d'une option à barrières.
On a ici aaire à une option
processus. On dénit pour
path dependent,
N ∈ N∗ , h := T /N
et
et il va donc falloir tenir compte de la trajectoire du
τ N := inf{ti := ih, i ∈ N : Xti 6∈ D}.
On va tout d'abord dans cette partie prouver une majoration de l'erreur faible :
Err(x, T, g, h) = Ex [g(XT )(Iτ N >T − Iτ >T )]
à l'aide de techniques de calcul stochastique.
1.1
Résultats préliminaires
Considérons d'abord le cas
1. Soit
d = 1 = σ, b = 0
x ∈ D, A ∈ B(R+ ),
et
D = R+∗ .
tribu borélienne de
R+ .
A l'aide du principe de réexion pour le
mouvement Brownien donner l'expression explicite de
Px [Xt ∈ A, τ > t]
en terme de noyaux
Gaussiens dont on précisera moyenne et variance.
2. Pour
(t, x) ∈ [0, T ] × D̄
et
g
Préciser l'EDP satisfaite par
à croissance exponentielle, on dénit
v(t, x) := Ex [g(XT −t )Iτ >T −t ].
v.
v ∈ C 1,2 ([0, T ) × D). Donner une condition sur g pour que v ∈ C 0 ([0, T ] × D̄), puis
2,4 ([0, T ] × D̄). On entend par là que l'on peut prolonger de façon régulière les
pour que v ∈ C
dérivées sur un voisinage de D̄ .
3. Montrer que
1
v ∈ Cb2,4 ([0, T ] × D̄),
4. Même question pour obtenir
i.e. la fonction ainsi que ses dérivées jusqu'à
l'ordre indiqué sont bornées.
Reprendre les questions précédentes dans le cas plus général introduit ci-avant.
1.2
Analyse de l'erreur
1. Montrer que
Err(x, t, g, h) =
N
−1
X
E[Iτ N >ti (v(ti+1 , ΠD̄ (Xti+1 )) − v(ti , Xti ))]
où
ΠD̄
désigne la pro-
i=0
jection sur l'adhérence de
D.
2. En supposant désormais que les hypothèses garantissant que
v ∈ Cb2,4 ([0, T ] × D̄)
sont vériées,
déduire de l'application d'une formule de Taylor à l'ordre 3
Err(x, t, g, h) =
N
−1
X
Ex [Iτ N >ti ∇v(ti , Xti ) · nF − (Xti+1 ) + O(F − (Xti+1 )|Xti+1 − Xti |)
i=0
+O((F (Xti+1 ) ) + O(h ) ].
−
2
2
(1)
F (x) = d(x, ∂D)Ix∈D − d(x, ∂D)Ix6∈D est la distance signée au bord du domaine. On pourra
−
utiliser que ΠD̄ (Xti+1 ) = Xti+1 + nF (Xti+1 ).
En notant τti := inf{s ≥ ti : Xs 6∈ D}, établir ∃C > 0, P[τti < ti+1 |Fti ] ≤ CP[Xti+1 6∈ D|Fti ].
A l'aide de contrôles usuels sur le Brownien déduire du résultat précédent que |Err(x, t, g, h)| ≤
√
C h.
où
3.
4.
Il existe en fait, sous de bonnes hypothèses, un développement de l'erreur de la forme
√
√
Err(x, t, g, h) = C h + o( h), C = C0 kσ ∗ nkE[Iτ <T ∇v(τ, Xτ ) · n], C0 = .5823.
On peut renvoyer aux travaux de Siegmund, [Sie79], pour des précisions sur la nature de la constante
C0 kσ ∗ nk. Il s'agit de l'espérance de l'overshoot
√ normalisé, i.e. distance à la frontière lorsque le processus
sort du domaine à temps discret divisé par
h.
Le développement d'erreur précédent justie l'utilisation d'une méthode d'extrapolation de type
Romberg pour améliorer la convergence.
La connaissance explicite de
C0 permet par ailleurs de proposer une méthode alternative basée sur la
correction de domaine. Précisément, on va restreindre le domaine de sorte à compenser la surestimation
due au temps discret. Introduisons
DN }.
√
N := inf{t : X N 6∈
DN := {y ∈ Rd : y · n + m > C0 hkσ ∗ nk}, τD
i
ti
N
On a en fait le résultat suivant :
√
− Iτ >T )] = o( h).
E[g(XT )(Iτ N
DN >T
(2)
Dans un contexte d'application nancière, cette identité est présentée dans [BGK97].
Dans la suite du TP on s'attachera à mettre en oeuvre les diérentes techniques de simulation suggérées par ces résultats : simulation naive, simulation par ponts browniens, extrapolation de Romberg,
technique de correction dérivant de (2).
2 Partie mise en oeuvre en C++
On va ici compléter les classes introduites lors du TP précédent pour évaluer des quantités de
2
QT = Ex [f (ST )Iτ >T ] où St = S0 exp(σWt + (r − σ2 )t),
monodimensionnel, τ := inf{t ≥ 0 : St ∈
6 D}, D ouvert connexe
type
croissance polynomiale.
On rappelle que l'on a ici aaire à une option
avec
de
R.
(Wt )t≥0
mouvement Brownien
La fonction
f
sera supposée à
path dependent. Il va donc falloir tenir compte de la
trajectoire de l'actif. A ce propos on va introduire un ensemble de classes pour simuler des processus
stochastiques à valeurs réelles.
2
2.1
Classes associées à des processus aléatoires
On va tout d'abord créer une classe abstraite
Process
dérivant de
Loi_Proba
et de prototype
class Process: public Loi_Proba{
protected:
int N;
double T,DT;
public:
Process(double Ti=1,double DTi=.01);
virtual double getIncrement() const=0;
virtual double getFinalValue() const=0;
double Simule() const{return getFinalValue();}
};
où
T>0
désigne le temps terminal jusqu'auquel on souhaite observer le processus en partant de 0,
est le pas de discrétisation et
N
getIncrement() renverra pour un processus X donné une réalisation de Xti+1 − Xti
La méthode getFinalValue() renverra une réalisation de XT .
Question 1. Ecrire les constructeurs de la classe
Question 2. Faire dériver de
DT
le nombre de pas de discrétisation sur l'intervalle [0,T]. La méthode
pour
i ∈ [[0, N − 1]].
Process.
Process une classe Brownian. On suggère d'utiliser le prototype suivant :
class Brownian: public Process{
Normale No;
public:
Brownian(double Ti=1,double DTi=.01);
double getIncrement() const;
double getFinalValue() const;
};
Implémenter les méthodes de la partie publique de cette classe.
Question 3. Faire dériver de
Process
une classe
Geometric_Brownian,
de prototype :
class Geometric_Brownian: public Process{
Brownian B;
double sigma, r, S0;
public:
Geometric_Brownian(double S0i=100,double sigmai=.15, double r=.02,
double Ti=1, double DTi=.01);
double getIncrement() const;
double getFinalValue() const;
};
Implémenter les méthodes de cette classe.
2.2
Options et héritage
Nous allons dans cette partie décrire et implémenter un ensemble de classes pour estimer des prix
d'options par méthode de Monte Carlo dans un modèle de Black et Scholes.
La classe de base pour cela sera
3
OptionBS:public Loi_Proba{
protected:
double r,T; // On peut considérer que le taux d'actualisation et la maturité
// sont des données de l'option.
Geometric_Brownian GB;
PayOff & PO;
public:
OptionBS(PayOff & POi,double S0i=100,double sigmai=.15,
double ri=.02, double Ti=1, double DTi=.01);
};
C'est là une classe abstraite, i.e. on n'y implémente pas la méthode
OptionBS
dériver de
dérive. A titre indicatif, la classe
OptionBS.
Question 1. On va écrire une classe
VanillaOptionBS
BarrierOptionBS
Simule de Loi_Proba dont la classe
du TP précédent devrait maintenant
dérivant de
OptionBS
de prototype
class BarrierOptionBS:public OptionBS{
double borne_gauche, borne_droite;
public:
BarrierOptionBS(double bg, double bd, PayOff & POi, double SOi=100,
double sigmai=.15, double r=.02, double Ti=1, double DT=.01);
double Simule() const;
};
où
D = (borne_gauche,borne_droite). Implémenter les méthodes précédentes. On utilisera pour cela
la discrétisation naïve du temps de sortie qui consiste à observer si la trajectoire est hors du domaine
à un des instants de discrétisation.
Question 2. A l'aide de la procédure de simulation élémentaire précédente, mettre en évidence numé-
riquement l'identité
où
√
√
E[f (ST )Iτ N >T ] − E[f (ST )Iτ >T ] = C DT + o( DT)
τ N := inf{ti = ih : Sti 6∈ D},
pour
f (x) = (x − K)+ , D = (0, B), K < B .
On pourra utiliser que
l'expression explicite du prix, cf. [MR97], est dans ce cas donnée par
E[f (ST )Iτ >T ] = S0 exp(rT ) N (d1 (K, S0 , σ, r, T )) − N (d1 (B, S0 , σ, r, T ))
2r
B σ2 +1
ˆ
ˆ
ˆ
+
N (2d2 (B, S0 , σ, r, T ) − d2 (K, S0 , σ, r, T )) − N (d2 (B, S0 , σ, r, T ))
S0
−K N (d2 (K, S0 , σ, r, T )) − N (d2 (B, S0 , σ, r, T ))
+
B
S0
2r2 −1
σ
N (2dˆ1 (B, S0 , σ, r, T ) − dˆ1 (K, S0 , σ, r, T )) − N (dˆ1 (B, S0 , σ, r, T ))
√
√
N (x) = P[N (0, 1) ≤ x], d1 (x, S0 , σ, r, T ) = log(S0/x)+rT
+ 12 σ T , dˆ1 (x, S0 , σ, r, T ) = d1 (x, S0 , σ, r, T )−
σ
T
√
√
√
2r
T , et d2 (x, S0 , σ, r, T ) = d1 (x, S0 , σ, r, T ) − σ T , dˆ2 (x, S0 , σ, r, T ) = d2 (x, S0 , σ, r, T ) − 2r
T.
σ
σ
où
On prendra
S0 = 100, B = 130, K = 90, σ = .15, r = .02.
On fera varier le nombre
N
de pas de
discrétisation en faisant bien attention à équilibrer erreur statistique associée à la méthode de
Monte Carlo, dirigée par le théorème central limite, et erreur de discrétisation que l'on cherche à
mettre en évidence.
4
Question 3. Implémenter la méthode de simulation qui utilise la probabilité qu'un pont Brownien ait
dépassé un certain seuil entre deux instants de discrétisation. On suggère pour cela d'ajouter dans la
partie publique de la classe
Brownian
une fonction de prototype
static double ProbBrownBridgeBigger(double B, double xi, double xip1, double h) ;
P[sups∈[0,h] Ws ≥ B|W0 = xi, Wh = xip1]. Ecrire une fonction double SimuleBB() const
BarrierOptionBS utilisant cette probabilité dans les cas où D = (0, B)
D = (B, +∞). Etudier l'impact de la discrétisation en temps par cette technique. Estimer le gain
qui renvoie
dans la partie publique de
ou
associé en terme de vitesse de convergence.
Question 4. Implémenter les méthodes d'extrapolation de Romberg et de correction de domaine in-
troduites en Section 1. Commenter les résultats.
Question 5. An de permettre à l'utilisateur de choisir entre les diérentes méthodes de simulation
on va utiliser des pointeurs sur fonctions et surcharger les constructeurs.
double (BarrierOptionBS::*PTR_Simule) () const ; dans la partie privée
BarrierOptionBS. La variable PTR_Simule est un pointeur de fonction. Il ne peut pointer que
des fonctions const de la classe BarrierOptionBS n'ayant pas d'arguments, et renvoyant un double.
1. Introduire une variable
de
L'aectation de ce type de variables se fait de la façon suivante :
PTR_Simule=& BarrierOptionBS::SimuleBB ;
2. Modier les constructeurs de cette classe en ajoutant un champ
int FLAG,
qui prendra les valeurs
0,1,2,3 en fonction de la technique retenue par l'utilisateur.
- 0 : simulation naive.
- 1 : simulation par ponts Browniens.
- 2 : extrapolation de Romberg.
- 3 : correction de domaine.
3. Modier la fonction
Simule
qui devient
double BarrierOptionBS::Simule() const
{
return (this->*PTR_Simule)();
}
Mettre enn les diérentes méthodes de simulation dans la partie privée de la classe. Ces dernières ne
sont ainsi plus directement accessibles à l'utilisateur.
Références
[BGK97] M. Broadie, P. Glasserman, and S. Kou. A continuity correction for discrete barrier options.
[MR97]
Mathematical Finance, 7 :325349, 1997.
M. Musiela and M. Rutkowski. Martingale methods in nancial modelling.
[Sie79]
D. Siegmund. Corrected diusion approximations in certain random walk problems.
Appl. Probab., 11(4) :701719, 1979.
5
Springer, 1997.
Adv. in