1. LEARNING OBJECTIVES

By the end of this lesson, you will be able to:

  • Understand the limitations of standard stochastic calculus (Brownian Motion, Ito Calculus).

  • Define the Malliavin derivative and its properties.

  • Apply Malliavin calculus to compute Greeks (sensitivities) in Monte Carlo simulations.

  • Understand the concept of rough paths and why they are needed for rough volatility models.

  • Define the p-variation and roughness of a path.

  • Apply the rough volatility framework to model volatility surfaces.

  • Understand the fractional Brownian Motion (fBM) and its properties.

  • Apply the fractional Black-Scholes model to option pricing.

2. LIMITATIONS OF STANDARD STOCHASTIC CALCULUS

2.1 What Standard Calculus Captures

Standard stochastic calculus (Ito calculus) is built on Brownian Motion. It captures:

  • Continuous paths.

  • Independent increments.

  • Normally distributed increments.

  • Quadratic variation that is deterministic (dt).

2.2 What Standard Calculus Does Not Capture

  1. Jumps: Brownian Motion has continuous paths. Real financial markets have jumps (crashes, spikes).

  2. Rough Volatility: Volatility itself is rough (Hurst exponent H < 0.5). Standard models assume H = 0.5.

  3. Long Memory: Financial time series exhibit long memory (autocorrelation decays slowly).

  4. Non-Markovian Dynamics: Many financial processes are non-Markovian (the future depends on more than just the present).

2.3 The Need for Advanced Calculus

  • Malliavin calculus extends stochastic calculus to compute derivatives of functionals of stochastic processes.

  • Rough path theory extends stochastic calculus to handle paths that are rougher than Brownian Motion.

3. MALLIAVIN CALCULUS

3.1 The Malliavin Derivative

The Malliavin derivative D_t F is the derivative of a functional F of a stochastic process with respect to the underlying Brownian Motion at time t.

For a functional F = f(W_{t_1}, …, W_{t_n}), the Malliavin derivative is:

D_t F = Σ_{i=1}^n ∂f/∂x_i * 1_{t ≤ t_i}

3.2 The Clark-Ocone Formula

The Clark-Ocone formula expresses a random variable F as the expectation plus a stochastic integral:

F = E[F] + ∫_0^T E[ D_t F | F_t ] dW_t

3.3 The Malliavin Derivative of an Ito Process

For X_t = ∫_0^t μ_s ds + ∫_0^t σ_s dW_s:

D_s X_t = σ_s 1_{s ≤ t}

3.4 The Malliavin Derivative of the Payoff

For a European option with payoff H = h(S_T):

D_t H = h'(S_T) * D_t S_T = h'(S_T) * σ S_T

3.5 Computing Greeks (Sensitivities)

Delta (∂V/∂S):
Using the Malliavin derivative:

Delta = E^Q[ H * (1 / (S_T σ_T)) * (∂S_T/∂S_0) ]

Gamma (∂²V/∂S²):

Gamma = E^Q[ H * (1 / (S_T² σ_T²)) * ( (∂S_T/∂S_0)² – S_T (∂²S_T/∂S_0²) ) ]

Vega (∂V/∂σ):

Vega = E^Q[ H * (1 / (σ_T)) * (∂σ_T/∂σ_0) ]

3.6 Advantage of Malliavin Greeks

  • Standard finite difference methods require re-running the simulation.

  • Malliavin Greeks are computed from the same simulation paths.

  • This reduces variance and computation time.

4. ROUGH PATH THEORY

4.1 The Problem with Rough Paths

When a path is very rough (H < 0.5), the standard Riemann-Stieltjes integral does not converge. We need rough path theory.

4.2 The p-Variation

The p-variation of a path X over [0, T] is:

V_p(X, [0, T]) = sup_{partition} (Σ |X_{t_i} – X_{t_{i-1}}|^p)^{1/p}

  • A path has finite 1-variation if it is of bounded variation (e.g., differentiable paths).

  • Brownian Motion has finite p-variation for any p > 2.

  • Rough paths have finite p-variation for p < 2.

4.3 The Roughness of Financial Data

Financial data (returns, volatility) exhibit roughness:

  • The Hurst exponent H is often less than 0.5 for volatility.

  • This means volatility paths are rougher than Brownian Motion.

4.4 The Rough Path Integral

For a rough path X, the integral ∫ Y dX is defined using the Young integral (if p + q < 1).

For paths that are very rough (H < 0.25), we need the full rough path theory (using the signature).

5. FRACTIONAL BROWNIAN MOTION (FBM)

5.1 Definition

Fractional Brownian Motion (fBM) is a generalization of Brownian Motion with Hurst exponent H ∈ (0, 1).

Properties:

  1. Mean: E[B_t^H] = 0.

  2. Variance: Var(B_t^H) = t^{2H}.

  3. Covariance: For s ≤ t:

    Cov(B_s^H, B_t^H) = (1/2) (t^{2H} + s^{2H} – (t – s)^{2H})

  4. Self-Similarity: B_{ct}^H = c^H B_t^H (in distribution).

  5. Stationary Increments: B_{t+s}^H – B_s^H has the same distribution as B_t^H.

5.2 Cases

  • H = 0.5: Standard Brownian Motion (independent increments).

  • H > 0.5: Long memory (positively correlated increments). The process is smoother.

  • H < 0.5: Anti-persistence (negatively correlated increments). The process is rougher.

5.3 Rough Volatility

Empirical studies show that volatility has H ≈ 0.1 to 0.3. This is “rough volatility.”

5.4 The Fractional Black-Scholes Model

The fractional Black-Scholes model replaces Brownian Motion with fBM:

dS_t = μ S_t dt + σ S_t dB_t^H

5.5 Pricing Under fBM

Under fBM, the market is not complete (there is arbitrage if H ≠ 0.5). This is because fBM is not a semimartingale.

Therefore, the fractional Black-Scholes model is not suitable for arbitrage-free pricing. Instead, we use:

  • Rough Volatility Models: Volatility is driven by fBM with H < 0.5, but the asset price is driven by standard Brownian Motion.

  • The RFSV (Rough Fractional Stochastic Volatility) Model.

6. THE ROUGH VOLATILITY FRAMEWORK

6.1 The RFSV Model

The RFSV (Rough Fractional Stochastic Volatility) model:

dS_t = σ_t S_t (√(1 – ρ²) dW_t^1 + ρ dW_t^2)
σ_t = σ_0 * exp( X_t )
dX_t = θ (μ – X_t) dt + η dB_t^H

Where:

  • X_t is the log-volatility.

  • B_t^H is fractional Brownian Motion with H < 0.5.

  • W_t^1 and W_t^2 are standard Brownian Motions.

  • ρ is the correlation between asset returns and volatility.

6.2 The Rough Bergomi Model

The Rough Bergomi model is a simpler version:

σ_t = σ_0 * exp( η ∫_0^t (t – s)^{H – 1/2} dW_s – (1/2) η² t^{2H} )

Where the integral is a fractional Brownian Motion.

6.3 Implications for Option Pricing

  • The RFSV model generates realistic implied volatility surfaces.

  • The skew (volatility smile) is more pronounced for short maturities.

  • The term structure of volatility is consistent with empirical observations.

6.4 Pricing in Rough Volatility Models

Since the volatility is driven by fBM, the market is not complete. However, we can use:

  1. Numerical Methods: Monte Carlo simulation with fBM.

  2. Forward Variance Models: The RFSV model can be rewritten in terms of forward variance.

  3. Fourier Methods: Characteristic functions can be derived for some rough volatility models.

7. THE SIGNATURE METHOD

7.1 Definition

The signature of a path X over [0, T] is the collection of all iterated integrals:

S(X){0,T} = (1, ∫ dX_t, ∫∫ dX{t_1} dX_{t_2}, …)

7.2 Properties of the Signature

  1. Universality: Any continuous functional of the path can be approximated by a linear combination of the signature.

  2. Invariance: The signature is invariant under time-reparametrization.

  3. Uniqueness: The signature determines the path up to tree-like equivalence.

7.3 Application to Finance

The signature method can be used for:

  1. Volatility Forecasting: Use the signature of past returns to forecast future volatility.

  2. Option Pricing: Use the signature to price options with machine learning.

  3. High-Frequency Trading: Use the signature to detect patterns in tick-by-tick data.

7.4 The Signature as a Feature Engineering Tool

In machine learning for finance, the signature provides a rich set of features:

  • Cross-sectional features (correlations between assets).

  • Path-dependent features (maximum, minimum, variation).

  • Non-linear features (iterated integrals).

8. PRACTICAL IMPLEMENTATION

A. Generating Fractional Brownian Motion:

python
import numpy as np
import matplotlib.pyplot as plt

def generate_fbm(H, T, n_steps):
    """Generate fractional Brownian Motion using the Cholesky method."""
    dt = T / n_steps
    t = np.linspace(0, T, n_steps + 1)

    # Covariance matrix
    cov = np.zeros((n_steps + 1, n_steps + 1))
    for i in range(n_steps + 1):
        for j in range(n_steps + 1):
            cov[i, j] = 0.5 * (t[i]**(2*H) + t[j]**(2*H) - abs(t[i] - t[j])**(2*H))

    # Cholesky decomposition
    L = np.linalg.cholesky(cov)

    # Generate Brownian Motion increments
    Z = np.random.normal(0, 1, n_steps + 1)
    B = L @ Z

    return t, B

# Generate fBM for different H
H_values = [0.1, 0.3, 0.5, 0.7]
T = 1.0
n_steps = 500

plt.figure(figsize=(12, 8))
for H in H_values:
    t, B = generate_fbm(H, T, n_steps)
    plt.plot(t, B, label=f'H = {H}')

plt.xlabel('Time')
plt.ylabel('B_t^H')
plt.title('Fractional Brownian Motion for Different Hurst Exponents')
plt.legend()
plt.show()

B. Computing Roughness (Hurst Exponent Estimation):

python
def compute_hurst(returns, max_lag=100):
    """Estimate the Hurst exponent using the rescaled range (R/S) method."""
    lags = range(2, max_lag)
    tau = []
    for lag in lags:
        # Rescaled range
        X = np.cumsum(returns[:lag] - np.mean(returns[:lag]))
        R = np.max(X) - np.min(X)
        S = np.std(returns[:lag])
        if S > 0:
            tau.append(np.log(R / S))
        else:
            tau.append(0)

    # Regression: log(R/S) = H * log(n)
    log_lags = np.log(lags)
    H = np.polyfit(log_lags[:len(tau)], tau, 1)[0]
    return H

# Generate fBM and estimate H
H_true = 0.2
t, B = generate_fbm(H_true, T, 1000)
returns = np.diff(B)

H_estimated = compute_hurst(returns)
print(f"True H: {H_true:.4f}")
print(f"Estimated H: {H_estimated:.4f}")

C. Computing Malliavin Greeks:

python
def malliavin_delta(S0, K, T, r, sigma, n_paths, n_steps):
    dt = T / n_steps
    S = np.zeros((n_paths, n_steps + 1))
    S[:, 0] = S0

    # Store Brownian increments
    dW = np.zeros((n_paths, n_steps))

    for i in range(n_steps):
        dW[:, i] = np.random.normal(0, np.sqrt(dt), n_paths)
        S[:, i+1] = S[:, i] + r * S[:, i] * dt + sigma * S[:, i] * dW[:, i]

    # Payoff
    payoffs = np.maximum(S[:, -1] - K, 0)

    # Malliavin derivative
    # D_t H = h'(S_T) * σ S_T
    # For call option: h'(S_T) = 1_{S_T > K}
    indicator = (S[:, -1] > K).astype(float)

    # Delta = E^Q[ H * (1 / (S_T σ_T)) * (∂S_T/∂S_0) ]
    # For GBM: ∂S_T/∂S_0 = S_T / S_0
    delta_malliavin = np.mean(payoffs * indicator / (S[:, -1] * sigma * T) * (S[:, -1] / S0))

    # Standard finite difference delta
    eps = 0.01
    S_up = S0 + eps
    price_up = monte_carlo_euro_call(S_up, K, T, r, sigma, n_paths, n_steps)
    S_down = S0 - eps
    price_down = monte_carlo_euro_call(S_down, K, T, r, sigma, n_paths, n_steps)
    delta_fd = (price_up - price_down) / (2 * eps)

    return delta_malliavin, delta_fd

# Example
delta_malliavin, delta_fd = malliavin_delta(S0, K, T, r, sigma, 10000, 50)
print(f"Malliavin Delta: {delta_malliavin:.4f}")
print(f"Finite Difference Delta: {delta_fd:.4f}")

9. SUMMARY FOR THE FINANCE PRACTITIONER

  • Risk-Neutral Pricing is the foundation of derivative pricing. The risk-neutral measure Q ensures that discounted asset prices are martingales.

  • Girsanov’s Theorem allows us to change from the real-world measure P to the risk-neutral measure Q by adjusting the drift.

  • The Market Price of Risk λ = (μ – r) / σ is the compensation required for bearing risk.

  • Malliavin Calculus extends stochastic calculus to compute derivatives of functionals of stochastic processes. It is used to compute Greeks efficiently.

  • Rough Path Theory extends stochastic calculus to handle paths that are rougher than Brownian Motion. Volatility exhibits roughness (H < 0.5).

  • Fractional Brownian Motion generalizes Brownian Motion with Hurst exponent H. Volatility models with H < 0.5 are called rough volatility models.

  • The Signature Method uses iterated integrals to provide a rich set of features for machine learning in finance.

 
 
PreviousNext