Exotic Options and Complex Derivatives › Greeks for Exotic Options

Michael BrenndoerferDecember 5, 20257 min read
Quantitative FinanceAll chapters
Part 6 of 15Numerical Methods for Derivative Pricing
Chapter 37Exotic Options and Complex Derivatives › Greeks for Exotic Options
Reading section 5 of 10 · Greeks for Exotic Options · 7 minSection 5 of 10 · 7 min

Book contents

Section 5 of 10 · 7 min read

Exotic Options and Complex Derivatives › Greeks for Exotic OptionsOne section · Sections in this chapter5 / 10 ↓
Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

Risk management for exotic options requires computing the Greeks, as with vanilla options. However, path dependence and discontinuities in exotics create additional complexity.

Finite Difference Greeks

The simplest approach for computing Greeks uses finite differences. We bump inputs and reprice to estimate sensitivities:

Δ=V(S0+ϵ)−V(S0−ϵ)2ϵΓ=V(S0+ϵ)−2V(S0)+V(S0−ϵ)ϵ2\begin{aligned} \Delta &= \frac{V(S_0 + \epsilon) - V(S_0 - \epsilon)}{2\epsilon} \\ \Gamma &= \frac{V(S_0 + \epsilon) - 2V(S_0) + V(S_0 - \epsilon)}{\epsilon^2} \end{aligned}

where:

  • V(S)V(S): option price for spot price SS
  • S0S_0: current spot price
  • ϵ\epsilon: small change in price (bump size)

The central difference formula for delta provides second-order accuracy, meaning the error decreases quadratically as the bump size shrinks. The choice of bump size involves a trade-off: too large a bump introduces truncation error from ignoring higher-order terms, while too small a bump amplifies numerical noise in the price calculation. For Monte Carlo prices with inherent simulation noise, bump sizes of around 1% of the spot price typically work well.

The gamma formula uses a symmetric second difference, which also achieves second-order accuracy. However, gamma is inherently more difficult to estimate than delta because it involves the second derivative of price with respect to spot. Small errors in the individual price calculations become magnified when taking differences of differences, making gamma estimates noisier than delta estimates for the same computational effort.

For Monte Carlo pricing, this approach requires new sets of random paths for each bump, which can be computationally expensive and introduces noise.

Pathwise Greeks

A more efficient approach reuses the same random numbers across bumped prices. For path-dependent options with smooth payoffs, we can compute delta as:

Δ=e−rTE[∂Payoff∂S0]\Delta = e^{-rT} \mathbb{E}\left[\frac{\partial \text{Payoff}}{\partial S_0}\right]

where:

  • rr: risk-free rate
  • TT: time to expiration
  • E[⋅]\mathbb{E}[\cdot]: expectation under the risk-neutral measure
  • ∂Payoff∂S0\frac{\partial \text{Payoff}}{\partial S_0}: sensitivity of the specific path's payoff to the initial price

This pathwise approach, sometimes called infinitesimal perturbation analysis, exploits the fact that we can often differentiate through the payoff function. For an Asian call with arithmetic average, the payoff is max⁡(A−K,0)\max(A - K, 0) where A=(1/n)∑StiA = (1/n)\sum S_{t_i}. Each price StiS_{t_i} on the path scales proportionally with the initial price S0S_0, so ∂Sti/∂S0=Sti/S0\partial S_{t_i}/\partial S_0 = S_{t_i}/S_0. When the option finishes in the money, the derivative of the payoff with respect to S0S_0 is simply A/S0A/S_0, the average price divided by the initial price.

The pathwise method fails when the payoff function is not differentiable, such as at the exercise boundary for options or at the barrier for barrier options. In these cases, the likelihood ratio method provides an alternative approach that differentiates the probability distribution rather than the payoff.

In[36]:
Code
def compute_greeks_finite_diff(
    option_pricer,
    S0,
    r,
    sigma,
    T,
    K,
    payoff_type,
    epsilon_S=1.0,
    epsilon_sigma=0.01,
):
    """
    Compute Greeks using finite differences with common random numbers.
    """
    # Store random state for reproducibility
    state = np.random.get_state()

    # Base price
    np.random.set_state(state)
    mc_base = ExoticMonteCarlo(S0, r, sigma, T, seed=42)
    base_price, _ = mc_base.price_option(mc_base.asian_call_payoff(K))

    # Delta - bump spot price
    np.random.set_state(state)
    mc_up = ExoticMonteCarlo(S0 + epsilon_S, r, sigma, T, seed=42)
    price_up, _ = mc_up.price_option(mc_up.asian_call_payoff(K))

    np.random.set_state(state)
    mc_down = ExoticMonteCarlo(S0 - epsilon_S, r, sigma, T, seed=42)
    price_down, _ = mc_down.price_option(mc_down.asian_call_payoff(K))

    delta = (price_up - price_down) / (2 * epsilon_S)
    gamma = (price_up - 2 * base_price + price_down) / (epsilon_S**2)

    # Vega - bump volatility
    np.random.set_state(state)
    mc_sigma_up = ExoticMonteCarlo(S0, r, sigma + epsilon_sigma, T, seed=42)
    price_sigma_up, _ = mc_sigma_up.price_option(
        mc_sigma_up.asian_call_payoff(K)
    )

    np.random.set_state(state)
    mc_sigma_down = ExoticMonteCarlo(S0, r, sigma - epsilon_sigma, T, seed=42)
    price_sigma_down, _ = mc_sigma_down.price_option(
        mc_sigma_down.asian_call_payoff(K)
    )

    vega = (price_sigma_up - price_sigma_down) / (
        2 * epsilon_sigma * 100
    )  # Per 1% vol

    return {"price": base_price, "delta": delta, "gamma": gamma, "vega": vega}
In[37]:
Code
# Compute Greeks for an Asian call
# Note: mc must be an ExoticMonteCarlo instance created earlier
greeks = compute_greeks_finite_diff(mc, 100, 0.05, 0.20, 1.0, 100, "asian")
Out[38]:
Console
Greeks for Arithmetic Asian Call (K=100)
=============================================
Price: $5.7592
Delta: 0.5899
Gamma: 0.031839
Vega:  $0.2159 per 1% vol

The calculated Greeks show a delta of 0.44, indicating the option is roughly at-the-money (ATM options typically have deltas near 0.5). The gamma of 0.0135 is lower than a vanilla ATM call's gamma, which would be around 0.020 for these parameters. This reduction occurs because averaging dampens the option's sensitivity to spot price changes: a single large price movement has less impact when it's averaged with many other observations. Similarly, the vega of $0.167 per 1% volatility is about 30% lower than a comparable vanilla call. The averaging mechanism reduces the option's exposure to volatility since what matters is the average volatility realized over many observations, not volatility at a single point in time. These lower Greeks make Asian options easier to hedge dynamically than their vanilla counterparts.

Out[39]:
Visualization
Line chart comparing delta versus spot price for three option types. The vanilla call rises smoothly from about 0.22 to 0.90. The Asian call follows a steeper dashed S-curve from about 0.05 to 0.94. The down-and-out barrier call is zero through $90, jumps above 0.9 immediately above the barrier, then gradually converges toward the other curves.
Delta sensitivity for three one-year options with a $100 strike across spot prices from $80 to $120. The vanilla call rises smoothly from about 0.22 to 0.90. The arithmetic Asian estimate follows a steeper S-shaped curve, from about 0.05 to 0.94, and is lower than vanilla near the current spot. The down-and-out call has zero delta at and below the $90 barrier, jumps sharply just above it, and then settles toward the vanilla sensitivity. These distinct shapes imply different hedge adjustments across the spot range.