Exotic Options and Complex Derivatives › Greeks for Exotic Options
Quantitative FinanceAll chapters 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:
where:
- : option price for spot price
- : current spot price
- : 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:
where:
- : risk-free rate
- : time to expiration
- : expectation under the risk-neutral measure
- : 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 where . Each price on the path scales proportionally with the initial price , so . When the option finishes in the money, the derivative of the payoff with respect to is simply , 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.
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}# 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")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.
