Volatilità

Volatilità e Moto browniano frazionario

Il moto browniano standard (BM) descrive un processo stocastico con incrementi indipendenti e stazionari: ciò che accade in un intervallo di tempo non influenza ciò che accade nel successivo. È il fondamento dei classici modelli di finanza (Black-Scholes, ecc...).

 
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

def BM(T=50, dt=1.0):
    """
    W(t) = Σ ε_i * √(dt)
    Parametri:
        n_steps: numero di passi
        dt: intervallo temporale (default: 1.0)
        seed: seme per riproducibilità
    Calcola:
        Dataframe con colonne W e dW.
    """
    df = pd.DataFrame(index=np.linspace(0, T, int(T/dt)), columns=['W'])
    dW = np.random.normal(0, np.sqrt(dt), int(T/dt))
    df.W = np.insert(np.cumsum(dW), 0, 0)[0:-1] 
    return df

BM(T=1.0, dt=0.01).W.plot(figsize=(10,5))
plt.title("Moto Browniano")
plt.xlabel("t")
plt.ylabel("W(t)")

Tuttavia i mercati reali mostrano memoria, autocorrelazioni persistenti, cluster di volatilità che il BM classico non cattura.

Il Moto Browniano Frazionario (fBM), introdotto da Andrej Kolmogorov e formalizzato da Benoît Mandelbrot e John Van Ness (1968), è una generalizzazione che introduce dipendenze a lungo raggio tra gli incrementi. È un processo Gaussiano \(B^H(t)\) con:

\(B^H(0) = 0;\)
Media zero: \(\mathbb{E}[B^H(t)] = 0;\)
Covarianza: \(\mathbb{E}[B^H(t)\, B^H(s)] = \tfrac{1}{2}\bigl(|t|^{2H} + |s|^{2H} - |t-s|^{2H}\bigr);\)

dove \(H\), l'indice di Hurst, è il parametro chiave del modello, un numero in \((0, 1)\) che controlla la memoria del processo:

Valore di \(H\)	Regime	Significato
\(H > 0.5\)	Persistenza	Una salita tende a essere seguita da un'altra salita ("trend following")
\(H = 0.5\)	Moto browniano classico	Nessuna memoria, incrementi indipendenti
\(H < 0.5\)	Anti-persistenza	Una salita tende a essere seguita da una discesa (mean-reverting)

 
def fBM(T=50, dt=1.0, H=0.7):
    """
    Genera un fractional Brownian motion B_H(t) su [0,T] usando (metodo preciso
    ma lento) la decomposizione di Cholesky della matrice di covarianza.
    """
    # griglia temporale
    N = int(T / dt)
    t = np.linspace(0, T, N)

    # matrice di covarianza del fBM
    C = np.zeros((N, N))
    for i in range(N):
        for j in range(N):
            C[i, j] = 0.5 * (t[i]**(2*H) + t[j]**(2*H) - abs(t[i] - t[j])**(2*H))

    # decomposizione di Cholesky
    L = np.linalg.cholesky(C + 1e-10*np.eye(N))  # stabilizzazione numerica

    # vettore gaussiano standard
    z = np.random.normal(size=N)

    # fractional Brownian motion
    df = pd.DataFrame(index=t, columns=['B_H'])
    df.B_H = L @ z
    return df

H = 0.3

fBM(T=1.0, dt=0.01, H=H).B_H.plot(figsize=(10,5))
plt.title(f"Fractional Brownian Motion con H = {H}")
plt.xlabel("t")
plt.ylabel("B_H(t)")

Più \(H\) si avvicina a 1, più il processo è "regolare" e con memoria lunga. Più si avvicina a 0, più è irregolare e oscillante.

 
T, dt = 1, 0.01
H_val=[0.3, 0.5, 0.7, 0.9]
df = BM(T, dt)
for  H in H_val:    
    df['B_'+str(H)] = fBM(T, dt, H).B_H
    
df.plot(figsize=(10,5))
plt.title('Confronto: Moto Browniano vs Moto Browniano Frazionale')

In finanza, il fBM viene usato soprattutto per modelli della volatilità stocastica, non direttamente il prezzo.
I modelli più importanti sono:

Rough Volatility
L'intuizione per i modelli di volatilità rough nasce da un'osservazione empirica di Gatheral, Jaisson e Rosenbaum in Volatility is rough (2018): la volatilità realizzata, analizzata su dati ad alta frequenza, si comporta come un fBM con \(H \approx 0.1\) molto piccolo, quindi ha andamento molto irregolare, "rough", molto più del moto browniano standard.
Il modello Rough Bergomi (rBergomi) ne è l'esempio principe: \[\log \sigma_t = \xi_0(t) \cdot \mathcal{E}\!\left(\eta \, \widetilde{W}^H_t\right)\] dove \(\widetilde{W}^H\) è un fBM con \(H < 0.5.\)
Ornstein-Uhlenbeck frazionario (fOU)
Generalizza il classico processo mean-reverting usando un fBM come rumore, per catturare la memoria lunga della volatilità.

I modelli rough replicano meglio il sorriso di volatilità implicita nelle opzioni e permettono di stimare empiricamente \(H\) dai dati (tipicamente si trova \(H \in [0.05, 0.15]\) per la volatilità realizzata).
Tuttavia il fBM non è una semimartingala per \(H \neq 0.5,\) il che rompe le fondamenta dell'arbitraggio classico. Richiede strumenti di calcolo stocastico più sofisticati (calcolo di Malliavin, integrazione di Russo-Vallois) e complica enormemente la calibrazione e il pricing.

Formalmente, la "roughness" si misura dall'esponente di regolarità Hölder, che quantifica quanto rapidamente il valore di una funzione possa cambiare in un punto rispetto alla distanza geometrica dal punto stesso: un fBM con indice \(H\) ha traiettorie Hölder-continue di esponente \(H - \varepsilon,\) per ogni \(\varepsilon > 0.\)
Il modello Rough Bergomi (rBergomi), proposto da Bayer, Friz e Gatheral in Pricing Under Rough Volatility (2016), è il modello rough più usato in pratica. La dinamica è: \[\frac{dS_t}{S_t} = \sqrt{V_t}\, dW_t\] \[V_t = \xi_0(t) \cdot \exp\!\left(\eta \,\widetilde{W}^H_t - \frac{\eta^2}{2} t^{2H}\right)\] dove:

\(\xi_0(t)\) è la curva di varianza forward iniziale (input di calibrazione),
\(\eta > 0\) è il vol-of-vol (volatilità della volatilità),
\(\widetilde{W}^H_t\) è un fBM con indice \(H\) correlato con \(W_t\) tramite \(\rho\),
Il termine \(-\frac{\eta^2}{2}t^{2H}\) è una correzione di martingala.

I parametri liberi sono soltanto \(H, \eta, \rho.\)
Il fBM \(\widetilde{W}^H\) è costruito come integrale di Volterra del moto browniano: \[\widetilde{W}^H_t = \sqrt{2H} \int_0^t (t-s)^{H - \frac{1}{2}} dW^\perp_s\] con \(W^\perp\) correlato a \(W\) tramite \(\rho.\) Questo cattura la leva finanziaria (correlazione negativa prezzo-volatilità).

Il modello Rough Heston è dovuto a El Euch e Rosenbaum in Roughening Heston (2019) che hanno formulato una versione rough del classico modello di Heston, dove la varianza istantanea segue un'equazione di Volterra frazionaria, cioè con l'operatore di integrazione che è di ordine frazionario: \[V_t = V_0 + \frac{1}{\Gamma(H + \frac{1}{2})} \int_0^t (t-s)^{H - \frac{1}{2}} \kappa(\theta - V_s)\, ds + \frac{\xi}{\Gamma(H + \frac{1}{2})} \int_0^t (t-s)^{H - \frac{1}{2}} \sqrt{V_s}\, dW_s\] Questa è un'equazione integrale di Volterra stocastica, generalizzazione dell'SDE classica di Heston ottenuta sostituendo la derivata ordinaria con una derivata frazionaria.
Il vantaggio cruciale del Rough Heston è che ammette una formula semi-analitica per la funzione caratteristica (tramite equazioni di Riccati frazionarie, generalizzazione delle equazioni di Riccati classiche dove la derivata prima ordinaria è sostituita da una derivata di ordine frazionario, il che lo rende calibrabile efficientemente a differenza del rBergomi che richiede simulazione Monte Carlo.

Questi modelli replicano bene

il sorriso di volatilità implicita a breve scadenza;
mentre i modelli classici (Heston, SABR) faticano a riprodurre l'esplosione dello skew per opzioni a scadenza molto breve, i modelli rough lo catturano naturalmente dato che il parametro \(H\) controlla la velocità con cui lo skew cresce al diminuire della maturity \(T:\) \[\text{Skew} \sim T^{H - \frac{1}{2}} \quad \text{per } T \to 0;\] con \(H < 0.5\) questo diverge esattamente come si osserva empiricamente;
la term structure della volatilità di volatilità;
il vol-of-vol implicito scala come \(T^H\), ciò che si osserva ancora nei dati reali, impossibile da ottenere con modelli Markoviani classici.

La difficoltà fondamentale è che il fBM non è Markoviano: lo stato del sistema non è riassumibile in un vettore finito-dimensionale. Questo ha conseguenze pesanti:

nessuna equazione di Kolmogorov standard, il PDE classico non si scrive;
nessuna ricombinazione in alberi trinomiali, metodi ad albero inutilizzabili;
simulazione Monte Carlo costosa, si devono simulare interi path di Volterra;
hedging dinamico complesso, la delta non è ben definita in senso classico.

Per aggirare il problema si usano approssimazioni Markoviane tramite somme di processi esponenziali: \[\widetilde{W}^H_t \approx \sum_{i=1}^n c_i \int_0^t e^{-\lambda_i(t-s)} dW_s.\] Scegliendo opportunamente i pesi \(c_i\) e i rate \(\lambda_i,\) si approssima il kernel di Volterra con una somma di esponenziali rendendo il sistema finito-dimensionale e Markoviano (modelli "Markov lifting").

Attuali sono le seguenti metodologie.

Neural SDE e rough volatility: reti neurali usate per apprendere il kernel di Volterra direttamente dai prezzi di opzioni.
Rough PDEs e calcolo di Malliavin: per il calcolo delle greche (delta, vega) si usano tecniche di differenziazione stocastica nel senso di Malliavin, evitando la differenza finita Monte Carlo.
Modelli "quasi-rough": modelli come il modello di volatilità esponenziale frazionaria (RFSV) che interpolano tra rough e classico, permettendo \(H\) variabile nel tempo.

Alcuni autori hanno contestato la robustezza statistica della stima di \(H\) suggerendo che potrebbe non essere identificabile in modo affidabile dai dati.