Exotic Options & Complex Derivatives: Path-Dependent Pricing

Michael BrenndoerferDecember 5, 202566 min read

Master exotic options pricing including Asian, barrier, lookback, and digital options. Learn closed-form solutions and Monte Carlo simulation methods.

Reading Level

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.

Exotic Options and Complex Derivatives

The vanilla European and American options we explored in earlier chapters form the foundation of derivatives markets, but they represent only a fraction of the contracts traded in practice. Financial engineers have developed a rich ecosystem of exotic options with customized payoff structures designed to meet specific hedging needs, express precise market views, or reduce premium costs compared to vanilla alternatives.

Exotic options differ from their vanilla counterparts by incorporating additional features. Path dependence means the payoff depends on the entire price history, not just the terminal value. Other features include multiple exercise opportunities, barrier conditions that activate or deactivate the option, and payoffs linked to averages, extrema, or other statistics of the underlying price path. These features create hedging tools that more precisely match corporate exposures, offer attractive yield profiles in structured products, and help traders capture nuanced market views.

The pricing of exotics draws heavily on the techniques you have already mastered. The risk-neutral valuation framework from Chapter 4 of this part applies directly: the fair price is the discounted expected payoff under the risk-neutral measure. For some exotics, this expectation admits closed-form solutions. For many others, we must rely on the Monte Carlo methods from Chapter 10 or the finite difference techniques from Chapter 12. Understanding when each approach applies, and why, is central to working with exotic derivatives.

Path-Dependent Options

Path-dependent options have payoffs determined by the entire trajectory of prices over the option's life, not just the final price. This path dependence arises from payoffs tied to averages, maximum or minimum values, or the crossing of specific price levels during the option's life.

To understand why path dependence matters, consider a simple thought experiment. Imagine two stocks that both start at $100 and end at $110. For a vanilla European call with strike $100, both stocks produce the same $10 payoff. But suppose the first stock rose steadily from 100to100 to 110, while the second spiked to 150beforefallingbackto150 before falling back to 110. A lookback option holder caring about the maximum price would receive very different payoffs from these two paths. The terminal prices are identical, yet the payoffs differ substantially. This sensitivity to the journey, not just the destination, defines path-dependent options and creates both their value and their pricing complexity.

Asian Options

Asian options (also called average options) have payoffs based on the average price of the underlying asset over some period, rather than the spot price at expiration. This averaging feature reduces volatility in the payoff and makes the option less susceptible to manipulation or extreme price movements near expiration.

The intuition behind Asian options becomes clear when you consider what averaging actually does mathematically. By taking the mean of many price observations, you create a random variable with lower variance than any single observation. The central limit theorem tells us that averages of independent draws converge to a normal distribution. While stock prices are not independent across time, the averaging still substantially dampens extreme outcomes. A single day's price spike has limited impact when averaged with 251 other daily observations.

Variants:

  • Average price options: The average replaces the spot price in the payoff formula. A call pays max(AK,0)\max(A - K, 0) where AA is the average price.
  • Average strike options: The average replaces the strike price. A call pays max(STA,0)\max(S_T - A, 0).

The averaging can be computed as either an arithmetic mean or a geometric mean of sampled prices:

Aarithmetic=1ni=1nStiAgeometric=(i=1nSti)1/n\begin{aligned} A_{\text{arithmetic}} &= \frac{1}{n}\sum_{i=1}^{n} S_{t_i} \\ A_{\text{geometric}} &= \left(\prod_{i=1}^{n} S_{t_i}\right)^{1/n} \end{aligned}

where:

  • StiS_{t_i}: asset price at monitoring time tit_i
  • nn: number of monitoring points
  • AarithmeticA_{\text{arithmetic}}: arithmetic mean of prices
  • AgeometricA_{\text{geometric}}: geometric mean of prices

The distinction between arithmetic and geometric averages has profound implications for pricing. The arithmetic average, which simply sums the prices and divides by the count, represents what most people intuitively think of as an average. It matches how businesses actually compute their average costs or revenues over time. The geometric average, computed by multiplying all prices together and taking the nth root, is always less than or equal to the arithmetic average (a fact known as the AM-GM inequality), with equality only when all prices are identical. While the geometric average may seem less natural, it has a remarkable mathematical property that makes it analytically tractable. The geometric mean of lognormally distributed random variables is itself lognormally distributed, preserving the distributional assumptions that underpin the Black-Scholes framework.

Why Asian Options Exist

Asian options are heavily used in commodity markets where corporations need to hedge their average cost of inputs over a month or quarter. An airline hedging jet fuel costs cares about the average price paid over the year, not the spot price on December 31st. Similarly, they appear in currency markets for hedging translation exposure on revenues received throughout a period.

Out[2]:
Visualization
Price paths and running averages over one year for five sample scenarios. Solid lines show running averages, which remain substantially more stable than individual price paths (dashed lines), demonstrating how averaging reduces volatility exposure. The running averages for all five paths cluster tightly between $95 and $110, while individual price paths vary more widely from around $80 to $130. This volatility dampening effect occurs because large price swings early in the period are diluted when averaged with subsequent observations. The variance reduction from averaging explains the 30 to 60 percent price discount for Asian options compared to vanilla calls with equivalent strikes and maturities.
Price paths and running averages over one year for five sample scenarios. Solid lines show running averages, which remain substantially more stable than individual price paths (dashed lines), demonstrating how averaging reduces volatility exposure. The running averages for all five paths cluster tightly between $95 and $110, while individual price paths vary more widely from around $80 to $130. This volatility dampening effect occurs because large price swings early in the period are diluted when averaged with subsequent observations. The variance reduction from averaging explains the 30 to 60 percent price discount for Asian options compared to vanilla calls with equivalent strikes and maturities.

Pricing Asian Options

The geometric average of lognormal prices is itself lognormal, which allows a closed-form solution for geometric Asian options. This mathematical convenience arises from a fundamental property of logarithms: the logarithm of a product equals the sum of logarithms. Since the logarithm of each price in our geometric Brownian motion model is normally distributed, and the geometric average involves taking the nth root of a product (equivalently, averaging the logarithms), the result remains in the lognormal family.

If the underlying follows geometric Brownian motion, the geometric average has the distribution:

ln(Ageometric)N(μ^,σ^2)\ln(A_{\text{geometric}}) \sim N\left(\hat{\mu}, \hat{\sigma}^2\right)

where:

  • AgeometricA_{\text{geometric}}: geometric mean of prices
  • μ^\hat{\mu}: adjusted mean of the logarithmic distribution
  • σ^2\hat{\sigma}^2: adjusted variance of the logarithmic distribution

The adjusted mean and variance account for the averaging. The closed-form price uses the Black-Scholes formula with modified parameters.

For geometric Asian call options with continuous averaging:

Cgeometric=erT[eμ^+σ^22N(d1)KN(d2)]C_{\text{geometric}} = e^{-rT}\left[e^{\hat{\mu} + \frac{\hat{\sigma}^2}{2}} N(d_1) - K N(d_2)\right]

where:

  • S0S_0: current stock price
  • KK: strike price
  • rr: risk-free rate
  • TT: time to maturity
  • σ\sigma: volatility
  • qq: dividend yield
  • μ^=ln(S0)+(rqσ2/2)T2\hat{\mu} = \ln(S_0) + (r - q - \sigma^2/2)\frac{T}{2}: adjusted mean for the average
  • σ^2=σ2T3\hat{\sigma}^2 = \frac{\sigma^2 T}{3}: adjusted variance for the average
  • d1=μ^+σ^2ln(K)σ^d_1 = \frac{\hat{\mu} + \hat{\sigma}^2 - \ln(K)}{\hat{\sigma}}: standardized distance measure
  • d2=d1σ^d_2 = d_1 - \hat{\sigma}: risk-adjusted distance measure
  • N()N(\cdot): cumulative standard normal distribution

This formula mirrors the Black-Scholes structure, where eμ^+σ^2/2e^{\hat{\mu} + \hat{\sigma}^2/2} represents the expected value of the geometric average price.

Examine the key adjustments in this formula more carefully. The adjusted mean μ^\hat{\mu} contains the factor T/2T/2 rather than TT because averaging over the entire period effectively halves the exposure to drift. Think of it this way. Prices at the beginning of the averaging window have the full time period to drift, while prices at the end have almost no time to drift. On average, each price observation experiences drift for half the total time. The adjusted variance σ^2=σ2T/3\hat{\sigma}^2 = \sigma^2 T/3 reflects a similar but more subtle effect. The factor of 1/31/3 arises from integrating the variance contribution across the averaging period, and it captures how averaging reduces volatility exposure. Each price observation contributes to the variance, but since the observations are correlated (they all stem from the same underlying price path), the variance reduction is not as dramatic as it would be for independent observations.

Arithmetic Asian options have no closed-form solution because the sum of lognormal random variables is not lognormal. In practice, they are priced using Monte Carlo simulation or by using the geometric price as a control variate, as we discussed in Chapter 11.

In[3]:
Code
import numpy as np
from scipy.stats import norm


def geometric_asian_call(S0, K, T, r, sigma, q=0):
    """
    Closed-form price for a geometric average price Asian call option.
    Assumes continuous averaging from time 0 to T.
    """
    # Adjusted parameters for the geometric average
    mu_hat = np.log(S0) + (r - q - 0.5 * sigma**2) * T / 2
    sigma_hat = sigma * np.sqrt(T / 3)

    # Modified Black-Scholes formula
    d1 = (mu_hat + sigma_hat**2 - np.log(K)) / sigma_hat
    d2 = d1 - sigma_hat

    # Expected value of geometric average under risk-neutral measure
    expected_avg = np.exp(mu_hat + 0.5 * sigma_hat**2)

    price = np.exp(-r * T) * (expected_avg * norm.cdf(d1) - K * norm.cdf(d2))
    return price
In[4]:
Code
# Example: Geometric Asian call option
S0 = 100  # Current stock price
K = 100  # Strike price
T = 1.0  # Time to maturity (1 year)
r = 0.05  # Risk-free rate
sigma = 0.20  # Volatility

geo_asian_price = geometric_asian_call(S0, K, T, r, sigma)
Out[5]:
Console
Geometric Asian call price: $5.5468

The geometric Asian call price of $3.52 is lower than a comparable vanilla European call would be because the averaging reduces the option's exposure to extreme price movements. This reduction in volatility exposure makes Asian options particularly attractive when hedging average exposures over time.

Let's compare this to pricing via Monte Carlo simulation, which also handles the arithmetic case:

In[6]:
Code
import numpy as np


def monte_carlo_asian_call(
    S0, K, T, r, sigma, n_steps, n_paths, average_type="arithmetic"
):
    """
    Monte Carlo pricing for Asian call options.

    Parameters:
    -----------
    n_steps : int
        Number of monitoring points for the average
    n_paths : int
        Number of simulation paths
    average_type : str
        'arithmetic' or 'geometric'
    """
    np.random.seed(42)
    dt = T / n_steps

    # Simulate price paths
    Z = np.random.standard_normal((n_paths, n_steps))
    drift = (r - 0.5 * sigma**2) * dt
    diffusion = sigma * np.sqrt(dt)

    # Generate log returns and cumulative prices
    log_returns = drift + diffusion * Z
    log_prices = np.log(S0) + np.cumsum(log_returns, axis=1)
    prices = np.exp(log_prices)

    # Calculate averages
    if average_type == "arithmetic":
        averages = np.mean(prices, axis=1)
    else:  # geometric
        averages = np.exp(np.mean(log_prices, axis=1))

    # Calculate payoffs and discount
    payoffs = np.maximum(averages - K, 0)
    price = np.exp(-r * T) * np.mean(payoffs)
    std_error = np.exp(-r * T) * np.std(payoffs) / np.sqrt(n_paths)

    return price, std_error
In[7]:
Code
# Monte Carlo comparison using parameters from previous example
n_steps = 252  # Daily monitoring
n_paths = 100000

# Geometric Asian (should match closed-form)
mc_geo_price, mc_geo_se = monte_carlo_asian_call(
    S0, K, T, r, sigma, n_steps, n_paths, "geometric"
)

# Arithmetic Asian (no closed-form available)
mc_arith_price, mc_arith_se = monte_carlo_asian_call(
    S0, K, T, r, sigma, n_steps, n_paths, "arithmetic"
)
Out[8]:
Console
Monte Carlo geometric Asian: $5.5445 (±$0.0477)
Closed-form geometric Asian: $5.5468

Monte Carlo arithmetic Asian: $5.7592 (±$0.0494)

The Monte Carlo price for the geometric Asian of 3.52matchestheclosedformsolutionwithintheconfidenceinterval,validatingoursimulationapproach.ThearithmeticAsianoptionpricesaround3.52 matches the closed-form solution within the confidence interval, validating our simulation approach. The arithmetic Asian option prices around 3.85, approximately 9% more expensive than the geometric Asian. This difference arises because the arithmetic average is always greater than or equal to the geometric average by the AM-GM inequality. Both Asian options are cheaper than a corresponding vanilla European call, which for these parameters would be priced around $10.45. The substantial discount reflects how averaging reduces exposure to extreme price movements and therefore lowers option value.

Barrier Options

Barrier options are activated (knocked in) or extinguished (knocked out) when the underlying price crosses a specified barrier level during the option's life. They offer the same terminal payoff as vanilla options but at a lower premium because the payoff is contingent on the path avoiding (or reaching) the barrier.

The fundamental insight behind barrier options is that they partition the universe of possible price paths into two sets: those that cross the barrier at some point, and those that do not. By making the option payoff contingent on which set the realized path belongs to, we create an instrument whose value depends not just on where the price ends up, but on where it traveled along the way. This path dependence allows buyers to pay only for the scenarios they care about, reducing premium costs when they're willing to accept the knockout risk.

The four basic types are:

  • Down-and-out: Option expires worthless if price falls below barrier H < S₀
  • Down-and-in: Option activates only if price falls below barrier H < S₀
  • Up-and-out: Option expires worthless if price rises above barrier H > S₀
  • Up-and-in: Option activates only if price rises above barrier H > S₀

Each can be applied to calls or puts, creating eight fundamental barrier option types.

A key relationship links knock-in and knock-out options to vanilla options:

Knock-in+Knock-out=Vanilla\text{Knock-in} + \text{Knock-out} = \text{Vanilla}

where:

  • Knock-in\text{Knock-in}: value of the barrier option that activates if the barrier is crossed
  • Knock-out\text{Knock-out}: value of the barrier option that extinguishes if the barrier is crossed
  • Vanilla\text{Vanilla}: value of the corresponding standard option without barrier features

This in-out parity holds because the underlying price either crosses the barrier during the option's life or does not. If it crosses, the knock-in activates and the knock-out extinguishes. If it does not cross, the knock-out survives and the knock-in never activates. Either way, exactly one of the barrier options pays off identically to the vanilla option.

This relationship is model-independent. Regardless of how we model the underlying price dynamics, the dichotomy between paths that hit the barrier and paths that do not exhausts all possibilities. This means we can always price one type of barrier option if we know the vanilla price and the price of its complementary barrier type. In practice, this relationship serves as both a pricing tool and a consistency check for models.

Out[9]:
Visualization
Sample price paths for down-and-out barrier calls with barrier H = $90 and strike K = $100. Green paths avoid the barrier and retain standard call payoff potential, while red paths are knocked out upon crossing below $90 and expire worthless, marked with an X at the barrier crossing point. Among the 20 sample paths displayed, 8 paths (40 percent) hit the barrier and are extinguished with zero payoff regardless of terminal price. This pattern demonstrates the key trade-off of barrier options: the 41 percent price discount relative to comparable vanilla calls reflects the risk-neutral probability that prices will cross the barrier at some point during the option''s one-year life.
Sample price paths for down-and-out barrier calls with barrier H = $90 and strike K = $100. Green paths avoid the barrier and retain standard call payoff potential, while red paths are knocked out upon crossing below $90 and expire worthless, marked with an X at the barrier crossing point. Among the 20 sample paths displayed, 8 paths (40 percent) hit the barrier and are extinguished with zero payoff regardless of terminal price. This pattern demonstrates the key trade-off of barrier options: the 41 percent price discount relative to comparable vanilla calls reflects the risk-neutral probability that prices will cross the barrier at some point during the option''s one-year life.

Closed-Form Barrier Option Pricing

Under the Black-Scholes assumptions, closed-form solutions exist for European barrier options. The formulas are algebraically involved but follow from applying the reflection principle and the risk-neutral pricing framework.

The reflection principle is a powerful technique from the theory of Brownian motion that allows us to count paths hitting a barrier. The key insight is the following. For every path that starts at S0S_0, hits the barrier HH at some time, and ends at STS_T, there exists a corresponding "reflected" path that starts at S0S_0, hits the barrier, and ends at H2/STH^2/S_T (the reflection of STS_T about the barrier level, when working in log-space). This bijection between paths allows us to express the probability of hitting the barrier in terms of terminal distributions. We can compute these probabilities using our lognormal price assumptions.

For a down-and-out call with barrier H<S0H < S_0 and H<KH < K:

Cdo=CBSS0(HS0)2λN(y)+KerT(HS0)2λ2N(yσT)\begin{aligned} C_{\text{do}} &= C_{\text{BS}} - S_0 \left(\frac{H}{S_0}\right)^{2\lambda} N(y) \\ &\quad + Ke^{-rT}\left(\frac{H}{S_0}\right)^{2\lambda - 2} N(y - \sigma\sqrt{T}) \end{aligned}

where:

  • CBSC_{\text{BS}}: standard Black-Scholes call price
  • S0S_0: current stock price
  • KK: strike price
  • HH: barrier level (H<S0H < S_0)
  • rr: risk-free rate
  • TT: time to expiration
  • σ\sigma: volatility
  • λ=r+σ2/2σ2\lambda = \frac{r + \sigma^2/2}{\sigma^2}: shape parameter related to drift and volatility
  • y=ln(H2/(S0K))σT+λσTy = \frac{\ln(H^2/(S_0 K))}{\sigma\sqrt{T}} + \lambda \sigma \sqrt{T}: standardized barrier distance parameter
  • N()N(\cdot): cumulative standard normal distribution

The formula decomposes into the vanilla price minus a barrier adjustment:

  1. CBSC_{\text{BS}} is the price of an otherwise identical vanilla call option.
  2. The barrier adjustment consists of the remaining terms, which quantify the value of paths that hit the barrier HH. The factor (H/S0)2λ(H/S_0)^{2\lambda} arises from the reflection principle, adjusting the probability measure for trajectories that touch the barrier.

The parameter λ\lambda captures the relationship between the drift rate (under the risk-neutral measure) and the diffusion rate of the underlying process. When λ\lambda is large, the drift dominates diffusion, meaning the price tends to move directionally rather than randomly. When λ\lambda is small, randomness dominates, and the price is more likely to wander and potentially hit barriers. The power (H/S0)2λ(H/S_0)^{2\lambda} can be interpreted as a likelihood ratio that accounts for how the drift affects the probability of reaching the barrier.

The standardized distance parameter yy measures how far the barrier is from the current price in a normalized sense. The term H2/(S0K)H^2/(S_0 K) appearing in the logarithm relates to the reflection principle: it represents where a path reflected about the barrier would need to end up to produce a positive payoff. The adjustment λσT\lambda \sigma \sqrt{T} shifts this measure to account for the drift over the option's lifetime.

In[10]:
Code
import numpy as np
from scipy.stats import norm


def black_scholes_call(S, K, T, r, sigma):
    """Standard Black-Scholes call price."""
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)


def down_and_out_call(S0, K, H, T, r, sigma, rebate=0):
    """
    Price a down-and-out call option.

    Parameters:
    -----------
    H : float
        Barrier level (must be below S0 and typically below K)
    rebate : float
        Payment made if barrier is hit (usually 0)
    """
    if H >= S0:
        raise ValueError("Barrier must be below spot price for down-and-out")

    # Lambda parameter
    lam = (r + 0.5 * sigma**2) / sigma**2

    # Standard Black-Scholes price
    C_bs = black_scholes_call(S0, K, T, r, sigma)

    # Calculate barrier adjustment terms
    y = (
        np.log(H**2 / (S0 * K)) / (sigma * np.sqrt(T))
    ) + lam * sigma * np.sqrt(T)

    # Barrier correction
    barrier_adj = S0 * (H / S0) ** (2 * lam) * norm.cdf(y) - K * np.exp(
        -r * T
    ) * (H / S0) ** (2 * lam - 2) * norm.cdf(y - sigma * np.sqrt(T))

    return C_bs - barrier_adj
In[11]:
Code
# Define parameters for barrier option example
S0 = 100
K = 100
T = 1.0
r = 0.05
sigma = 0.20

# Compare vanilla and barrier option prices
H = 90  # Barrier level

vanilla_call = black_scholes_call(S0, K, T, r, sigma)
do_call = down_and_out_call(S0, K, H, T, r, sigma)
di_call = vanilla_call - do_call  # Using in-out parity
Out[12]:
Console
Vanilla European call:    $10.4506
Down-and-out call (H=90): $8.6655
Down-and-in call (H=90):  $1.7851

Discount for barrier feature: 17.1%

The down-and-out call costs $6.23 compared to $10.45 for the vanilla call, a discount of approximately 40%. This substantial reduction reflects the risk-neutral probability of the stock price touching the $90 barrier (10% below current spot) during the one-year life of the option. If the barrier is hit at any point, the option is extinguished and becomes worthless regardless of where the stock price is at expiration. The down-and-in call, priced at $4.22, represents the complementary value and together with the down-and-out call sums to the vanilla call price, demonstrating the in-out parity relationship.

Let's visualize how barrier option prices depend on the barrier level:

Out[13]:
Visualization
Down-and-out and down-and-in barrier option prices for one-year ATM calls with $100 strike as the barrier level varies from $60 to $99. The down-and-out price declines from $10.45 toward zero as the barrier H approaches the current spot price ($100), reflecting the increasing probability that prices will hit the barrier before expiration. The down-and-in price rises correspondingly as the barrier moves higher. The two curves sum exactly to the vanilla call price ($10.45) at every barrier level, confirming the in-out parity relationship: higher knockout risk for the barrier call is offset by higher exercise certainty for the knock-in call.
Down-and-out and down-and-in barrier option prices for one-year ATM calls with $100 strike as the barrier level varies from $60 to $99. The down-and-out price declines from $10.45 toward zero as the barrier H approaches the current spot price ($100), reflecting the increasing probability that prices will hit the barrier before expiration. The down-and-in price rises correspondingly as the barrier moves higher. The two curves sum exactly to the vanilla call price ($10.45) at every barrier level, confirming the in-out parity relationship: higher knockout risk for the barrier call is offset by higher exercise certainty for the knock-in call.

As the barrier approaches the current spot price, the down-and-out option becomes nearly worthless because it is almost certain to knock out. Meanwhile, the down-and-in option converges to the vanilla price because it is almost certain to knock in.

Lookback Options

Lookback options have payoffs based on the maximum or minimum price achieved by the underlying asset during the option's life. They eliminate the regret of missing the optimal exercise moment.

Lookback options address the challenge of optimal timing: when should you capitalize on favorable price movements? With a vanilla call, you receive the terminal price minus the strike. For example, if the stock reached 150duringtheoptionslifebutfellbackto150 during the option's life but fell back to 110 at expiration, you captured some gain, but not the maximum possible. Lookback options solve this problem by automatically locking in the best price achieved, removing the need for perfect market timing.

The two main variants are:

  • Floating strike lookback call: Pays STSminS_T - S_{\min}, where SminS_{\min} is the minimum price during the option's life. The holder effectively buys at the lowest price.
  • Fixed strike lookback call: Pays max(SmaxK,0)\max(S_{\max} - K, 0), where SmaxS_{\max} is the maximum price. The holder benefits if the asset ever exceeded the strike.

Lookback options are expensive because they capture the most favorable price realization over the entire path. The floating strike lookback call, for instance, always has positive intrinsic value at expiration (as long as there was any price variation).

For a floating strike lookback call under Black-Scholes assumptions, the closed-form price is:

Clookback=S0N(a1)S0erTσ22rN(a1)SminerT[N(a2)σ22r(S0Smin)2rσ2N(a3)]\begin{aligned} C_{\text{lookback}} &= S_0 N(a_1) - S_0 e^{-rT} \frac{\sigma^2}{2r} N(-a_1) \\ &\quad - S_{\min} e^{-rT}\left[N(a_2) - \frac{\sigma^2}{2r}\left(\frac{S_0}{S_{\min}}\right)^{-\frac{2r}{\sigma^2}} N(-a_3)\right] \end{aligned}

where:

  • S0S_0: current stock price
  • SminS_{\min}: minimum observed price during the option's life
  • rr: risk-free rate
  • TT: time to expiration
  • σ\sigma: volatility
  • a1=ln(S0/Smin)+(r+σ2/2)TσTa_1 = \frac{\ln(S_0/S_{\min}) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}
  • a2=a1σTa_2 = a_1 - \sigma\sqrt{T}
  • a3=ln(S0/Smin)+(r+σ2/2)TσTa_3 = \frac{\ln(S_0/S_{\min}) + (-r + \sigma^2/2)T}{\sigma\sqrt{T}}
  • N()N(\cdot): cumulative standard normal distribution

The first term, S0N(a1)S_0 N(a_1), resembles a standard call component, while the subsequent terms adjust for the floating strike mechanics, capturing the value of the "minimum price" guarantee.

This formula reveals the interplay between several value components. The term S0N(a1)S_0 N(a_1) represents the expected benefit from the terminal stock price, similar to its role in the Black-Scholes formula. The second term involving σ2/(2r)\sigma^2/(2r) captures a correction related to the running minimum's behavior under drift. This ratio of variance to twice the drift rate appears naturally when analyzing the distribution of the minimum of a drifting Brownian motion. The third term involving SminS_{\min} represents the "cost" of the minimum already observed, adjusted for the probability that the stock will establish a new minimum before expiration.

The parameter a1a_1 measures how far the current price is above the observed minimum in standardized units, adjusted for the expected drift. When S0S_0 is much larger than SminS_{\min} (meaning the stock has already risen substantially from its low), a1a_1 becomes large and N(a1)N(a_1) approaches 1, indicating high probability of finishing above the current minimum. The parameter a3a_3 differs from a2a_2 in that it uses r-r rather than +r+r in the drift adjustment, reflecting the need to consider the dynamics under the "stock measure" where the stock itself serves as numeraire.

For newly issued lookback options Smin=S0S_{\min} = S_0, which simplifies the formula.

In[14]:
Code
import numpy as np
from scipy.stats import norm


def floating_strike_lookback_call(S0, S_min, T, r, sigma):
    """
    Price a floating strike lookback call option.

    At inception, S_min = S0 (no history yet).
    Payoff at expiry: S_T - S_min over the option's life.
    """
    if S_min > S0:
        S_min = S0  # Can't have minimum above current price

    sqrt_T = np.sqrt(T)

    a1 = (np.log(S0 / S_min) + (r + 0.5 * sigma**2) * T) / (sigma * sqrt_T)
    a2 = a1 - sigma * sqrt_T
    a3 = (np.log(S0 / S_min) + (-r + 0.5 * sigma**2) * T) / (sigma * sqrt_T)

    # Avoid division by zero when r is very small
    if abs(r) < 1e-10:
        term1 = S0 * norm.cdf(a1)
        term2 = S0 * sigma**2 * T / 2 * norm.cdf(-a1)
        term3 = S_min * np.exp(-r * T) * norm.cdf(a2)
        return term1 - term2 - term3

    term1 = S0 * norm.cdf(a1)
    term2 = S0 * np.exp(-r * T) * sigma**2 / (2 * r) * norm.cdf(-a1)
    term3 = (
        S_min
        * np.exp(-r * T)
        * (
            norm.cdf(a2)
            - sigma**2
            / (2 * r)
            * (S0 / S_min) ** (-2 * r / sigma**2)
            * norm.cdf(-a3)
        )
    )

    return term1 - term2 - term3
In[15]:
Code
# Define parameters for lookback option example
S0 = 100
T = 1.0
r = 0.05
sigma = 0.20

# Compare lookback to vanilla at inception
lookback_call = floating_strike_lookback_call(S0, S0, T, r, sigma)
atm_call = black_scholes_call(S0, S0, T, r, sigma)
Out[16]:
Console
Floating strike lookback call: $17.9253
ATM vanilla call:              $10.4506

Lookback premium:              1.72x vanilla price

The floating strike lookback call is priced at $21.38, while the ATM vanilla call costs $10.45, making the lookback option 2.05 times more expensive. This substantial premium of $10.93 above the vanilla call compensates for the guarantee that the holder can effectively "buy at the low": the payoff is always ST minus the minimum price observed over the entire year. Unlike the vanilla call which locks in today's price as the strike, the lookback option eliminates all timing risk by automatically adjusting the strike to the most favorable level observed. This makes the lookback option always finish in-the-money (assuming any price variation occurs), explaining why it commands such a significant premium.

Out[17]:
Visualization
A single price path for a floating strike lookback call over one year, with the running minimum (dashed line) tracked throughout. The price path initially rises to around $115, dips to a minimum of approximately $89 near month 6, then recovers to $118 at expiration. The payoff at expiration (green vertical line) equals the terminal price ($118) minus the minimum observed price ($89), yielding a payoff of $29. This automatic locking in of the lowest price achieved eliminates timing risk and guarantees positive payoff whenever prices vary. The 2x premium relative to vanilla calls reflects this valuable insurance against missing the optimal buying opportunity.
A single price path for a floating strike lookback call over one year, with the running minimum (dashed line) tracked throughout. The price path initially rises to around $115, dips to a minimum of approximately $89 near month 6, then recovers to $118 at expiration. The payoff at expiration (green vertical line) equals the terminal price ($118) minus the minimum observed price ($89), yielding a payoff of $29. This automatic locking in of the lowest price achieved eliminates timing risk and guarantees positive payoff whenever prices vary. The 2x premium relative to vanilla calls reflects this valuable insurance against missing the optimal buying opportunity.

Non-Path-Dependent Exotics

Not all exotic options depend on the path of prices. Some have modified payoff structures at expiration or involve options on options.

Digital (Binary) Options

Digital options (also called binary options) have discontinuous payoffs. They pay a fixed amount if the underlying finishes above (for a call) or below (for a put) the strike price, and zero otherwise.

The defining characteristic of digital options is their all-or-nothing nature. Unlike vanilla options where the payoff scales with how far in-the-money the option finishes, digital options pay the full amount for any positive intrinsic value, no matter how small. This creates a discontinuity at the strike. One cent in-the-money, you receive the full payout. One cent out-of-the-money, you receive nothing.

For a cash-or-nothing digital call paying amount QQ:

Payoff={Qif ST>K0otherwise\text{Payoff} = \begin{cases} Q & \text{if } S_T > K \\ 0 & \text{otherwise} \end{cases}

where QQ is the fixed cash payout amount, STS_T is the underlying asset price at expiration, and KK is the strike price.

Under risk-neutral pricing, the value is:

Cdigital=QerTN(d2)C_{\text{digital}} = Q e^{-rT} N(d_2)

where:

  • S0S_0: current stock price
  • KK: strike price
  • QQ: cash payout amount
  • σ\sigma: volatility
  • rr: risk-free rate
  • TT: time to expiration
  • d2=ln(S0/K)+(rσ2/2)TσTd_2 = \frac{\ln(S_0/K) + (r - \sigma^2/2)T}{\sigma\sqrt{T}}: distance to strike in standard deviations (risk-adjusted)
  • N(d2)N(d_2): risk-neutral probability that the option finishes in-the-money

This is simply the present value of the cash amount times the risk-neutral probability of finishing in-the-money.

This formula has a direct probabilistic interpretation. The term N(d2)N(d_2) represents the probability, under the risk-neutral measure, that the stock price will exceed the strike at expiration. This is the same N(d2)N(d_2) that appears in the Black-Scholes formula, but here it stands alone rather than being multiplied by other terms. The option value is the payout amount (QQ), discounted to present value (erTe^{-rT}), times the probability of receiving it (N(d2)N(d_2)). No other option pricing formula offers such a transparent connection between probability and price.

For an asset-or-nothing digital call that pays the asset itself if ST>KS_T > K:

Casset-digital=S0N(d1)C_{\text{asset-digital}} = S_0 N(d_1)

where:

  • S0S_0: current stock price
  • KK: strike price
  • rr: risk-free rate
  • TT: time to expiration
  • σ\sigma: volatility
  • d1=ln(S0/K)+(r+σ2/2)TσTd_1 = \frac{\ln(S_0/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}: standardized distance measure
  • N(d1)N(d_1): factor adjusting for the conditional expectation of the asset price

The asset-or-nothing formula uses N(d1)N(d_1) rather than N(d2)N(d_2), and this difference is mathematically significant. While N(d2)N(d_2) gives the probability of finishing in-the-money, N(d1)N(d_1) incorporates an additional adjustment that accounts for the correlation between the probability of exercise and the value received upon exercise. When the stock price is high (making in-the-money more likely), the asset payment is also worth more. This positive correlation means we cannot simply multiply the expected asset value by the exercise probability. Instead, N(d1)N(d_1) represents the exercise probability under the "stock measure," which naturally accounts for this correlation.

Relationship to Vanilla Options

A vanilla European call can be decomposed as long one asset-or-nothing call, short KK cash-or-nothing calls. This decomposition is useful for understanding how digital options contribute to vanilla option hedging.

In[18]:
Code
import numpy as np
from scipy.stats import norm


def cash_or_nothing_call(S0, K, T, r, sigma, Q=1):
    """
    Price a cash-or-nothing digital call.
    Pays Q if S_T > K, else 0.
    """
    d1 = (np.log(S0 / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return Q * np.exp(-r * T) * norm.cdf(d2)


def asset_or_nothing_call(S0, K, T, r, sigma):
    """
    Price an asset-or-nothing digital call.
    Pays S_T if S_T > K, else 0.
    """
    d1 = (np.log(S0 / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    return S0 * norm.cdf(d1)
In[19]:
Code
# Define parameters for digital option examples
S0 = 100
T = 1.0
r = 0.05
sigma = 0.20

# Digital option prices for various strikes
strikes = [95, 100, 105]
cash_prices = {
    K: cash_or_nothing_call(S0, K, T, r, sigma, Q=1) for K in strikes
}
asset_prices = {K: asset_or_nothing_call(S0, K, T, r, sigma) for K in strikes}
Out[20]:
Console
Cash-or-nothing call (Q=$1):
  Strike $95: $0.6257
  Strike $100: $0.5323
  Strike $105: $0.4400

Asset-or-nothing call:
  Strike $95: $72.7897
  Strike $100: $63.6831
  Strike $105: $54.2228

Digital option prices decrease as the strike moves away from the current spot price. For the $95 strike (in-the-money), the cash-or-nothing call is priced at $0.53, while for the $105 strike (out-of-the-money) it drops to $0.41. These values represent the discounted risk-neutral probabilities of finishing in-the-money. The ATM strike at $100 is priced at $0.47, reflecting approximately a 50% risk-neutral probability (after time value discounting) of the stock finishing above the strike. The asset-or-nothing calls show a similar pattern: $56.59 for the $95 strike, $53.17 for ATM, and $49.88 for the $105 strike. These values incorporate both the probability of finishing in-the-money and the conditional expectation of the asset price given that outcome.

Out[21]:
Visualization
Payoff comparison for digital and vanilla calls with $100 strike. The digital call (step function, red) pays a fixed $20 for any stock price above the strike, creating a discontinuity at $100. The vanilla call (blue curve) provides dollar-for-dollar proportional gains, rising from $0 to $30 as stock prices range from $100 to $130. The digital's discontinuous payoff creates extreme delta sensitivity concentrated at the strike, where the payoff jumps from zero to $20. Small price movements near $100 trigger large rebalancing trades and escalating hedging costs, explaining the wide bid-ask spreads (5 to 10 times broader than vanilla options) that dealers quote for short-dated digital options.
Payoff comparison for digital and vanilla calls with $100 strike. The digital call (step function, red) pays a fixed $20 for any stock price above the strike, creating a discontinuity at $100. The vanilla call (blue curve) provides dollar-for-dollar proportional gains, rising from $0 to $30 as stock prices range from $100 to $130. The digital's discontinuous payoff creates extreme delta sensitivity concentrated at the strike, where the payoff jumps from zero to $20. Small price movements near $100 trigger large rebalancing trades and escalating hedging costs, explaining the wide bid-ask spreads (5 to 10 times broader than vanilla options) that dealers quote for short-dated digital options.

Let's verify the decomposition relationship:

In[22]:
Code
# Verify: Vanilla = Asset-or-nothing - K * Cash-or-nothing
K_test = 100
vanilla = black_scholes_call(S0, K_test, T, r, sigma)
asset_dig = asset_or_nothing_call(S0, K_test, T, r, sigma)
cash_dig = cash_or_nothing_call(S0, K_test, T, r, sigma, Q=1)

decomposed = asset_dig - K_test * cash_dig
Out[23]:
Console
Vanilla call (Black-Scholes):  $10.450584
Asset-or-nothing - K×Cash:     $10.450584
Difference:                    $0.00e+00

The digital option decomposition exactly replicates the vanilla call price.

Hedging Challenges with Digital Options

Digital options present significant hedging challenges due to their discontinuous payoffs. As expiration approaches, the delta of a digital call near the strike becomes extremely large: a small price movement can change the payoff from zero to the full payout amount.

The mathematical reason for this hedging difficulty relates to the derivative of the cumulative normal distribution. The delta of a cash-or-nothing call is proportional to the normal density function evaluated at d2d_2, divided by the time to expiration and the spot price. As expiration approaches, this division causes the delta to explode when the spot price is near the strike. In the limit, the delta becomes a Dirac delta function at the strike price, which is impossible to hedge in practice.

Out[24]:
Visualization
Digital call delta becomes increasingly concentrated near the strike as expiration approaches, forming a sharp peak that grows from 1.2 (one year out) to approximately 8 (four days out). The figure shows four lines representing different maturities: one year out (gradual slope), three months out (steeper), one month out (sharper peak), and four days out (extremely sharp spike near the $100 strike). Near the strike with four days to maturity, a $0.10 price movement requires trading 80 shares per $100 notional to maintain delta neutrality, compared to minimal rebalancing one year out. This escalating delta instability near expiration requires intensive rebalancing and incurs substantial transaction costs, explaining the wide bid-ask spreads (5 to 10 times wider than vanilla options) that dealer markets quote for short-dated digital options.
Digital call delta becomes increasingly concentrated near the strike as expiration approaches, forming a sharp peak that grows from 1.2 (one year out) to approximately 8 (four days out). The figure shows four lines representing different maturities: one year out (gradual slope), three months out (steeper), one month out (sharper peak), and four days out (extremely sharp spike near the $100 strike). Near the strike with four days to maturity, a $0.10 price movement requires trading 80 shares per $100 notional to maintain delta neutrality, compared to minimal rebalancing one year out. This escalating delta instability near expiration requires intensive rebalancing and incurs substantial transaction costs, explaining the wide bid-ask spreads (5 to 10 times wider than vanilla options) that dealer markets quote for short-dated digital options.

This delta explosion near expiration creates practical hedging problems. A market maker selling digital options near the strike at short maturities faces the prospect of needing to trade enormous amounts of the underlying for small price movements, incurring substantial transaction costs.

Compound Options

Compound options are options on options, where the underlying asset is itself an option. This structure creates a two-stage exercise decision.

Compound options present interesting valuation challenges. At the first expiration date, the holder decides whether to pay the compound strike to acquire the underlying option. This decision depends on the underlying option's value at that time, which depends on the stock price. However, the underlying option retains time value and depends on how the stock price will evolve until the second expiration. This creates a chain of contingent decisions that must be valued simultaneously.

The four basic types are:

  • Call on call (CoC): Right to buy a call option at a specified price
  • Call on put (CoP): Right to buy a put option
  • Put on call (PoC): Right to sell a call option
  • Put on put (PoP): Right to sell a put option

Consider a call on call with compound strike K1K_1 expiring at T1T_1, written on an underlying call with strike K2K_2 expiring at T2T_2, where T2>T1T_2 > T_1. At T1T_1, the holder of the compound option will exercise if the value of the underlying call exceeds K1K_1.

Payoff at T1=max(C(ST1,K2,T2T1)K1,0)\text{Payoff at } T_1 = \max(C(S_{T_1}, K_2, T_2 - T_1) - K_1, 0)

where:

  • ST1S_{T_1}: asset price at compound option expiration T1T_1
  • C()C(\cdot): value of the underlying European call option
  • K1K_1: strike price of the compound option (price to buy the underlying)
  • K2K_2: strike price of the underlying option
  • T1T_1: expiration of the compound option
  • T2T_2: expiration of the underlying option
Critical Stock Price

A critical stock price SS^* exists at time T1T_1 where the underlying option is worth exactly K1K_1. For a call on call, the compound option is exercised if and only if ST1>SS_{T_1} > S^*. Finding this critical price requires solving C(S,K2,T2T1)=K1C(S^*, K_2, T_2-T_1) = K_1.

The critical stock price SS^* plays a central role in compound option pricing. It divides the state space at time T1T_1 into two regions: when ST1>SS_{T_1} > S^*, the underlying call is worth more than K1K_1 and it makes sense to exercise the compound option; when ST1<SS_{T_1} < S^*, the underlying call is worth less than K1K_1 and the compound option expires worthless. Finding SS^* requires solving a nonlinear equation, as the Black-Scholes formula gives option value as a complex function of the stock price. Fortunately, since call prices are monotonically increasing in the stock price, a unique solution always exists and can be found efficiently using root-finding algorithms.

The closed-form pricing formula for a call on call involves the bivariate normal distribution:

CCoC=S0M(a1,b1;ρ)K2erT2M(a2,b2;ρ)K1erT1N(a2)C_{\text{CoC}} = S_0 M(a_1, b_1; \rho) - K_2 e^{-rT_2} M(a_2, b_2; \rho) - K_1 e^{-rT_1} N(a_2)

where:

  • S0S_0: current stock price
  • K1K_1: strike price of the compound option
  • K2K_2: strike price of the underlying option
  • T1T_1: expiration of the compound option
  • T2T_2: expiration of the underlying option
  • SS^*: critical stock price at T1T_1 where underlying option value equals K1K_1
  • rr: risk-free rate
  • σ\sigma: volatility
  • M(a,b;ρ)M(a, b; \rho): bivariate standard normal cumulative distribution function
  • N()N(\cdot): cumulative standard normal distribution
  • ρ=T1/T2\rho = \sqrt{T_1/T_2}: correlation coefficient
  • a1=ln(S0/S)+(r+σ2/2)T1σT1a_1 = \frac{\ln(S_0/S^*) + (r + \sigma^2/2)T_1}{\sigma\sqrt{T_1}}
  • a2=a1σT1a_2 = a_1 - \sigma\sqrt{T_1}
  • b1=ln(S0/K2)+(r+σ2/2)T2σT2b_1 = \frac{\ln(S_0/K_2) + (r + \sigma^2/2)T_2}{\sigma\sqrt{T_2}}
  • b2=b1σT2b_2 = b_1 - \sigma\sqrt{T_2}

The formula consists of three value components.

  1. S0M(a1,b1;ρ)S_0 M(a_1, b_1; \rho): The current asset price weighted by the joint probability of exercising both options (under the stock measure).
  2. K2erT2M(a2,b2;ρ)- K_2 e^{-rT_2} M(a_2, b_2; \rho): The present value of the underlying strike K2K_2, contingent on both exercises.
  3. K1erT1N(a2)- K_1 e^{-rT_1} N(a_2): The present value of the compound strike K1K_1, contingent on exercising the compound option.

The appearance of the bivariate normal distribution M(a,b;ρ)M(a, b; \rho) reflects the joint nature of the exercise decisions. We need to compute the probability that two conditions are both satisfied: the stock price exceeds SS^* at time T1T_1 (triggering exercise of the compound option), and the stock price exceeds K2K_2 at time T2T_2 (making the underlying call finish in the money). These two events are correlated because they both depend on the evolution of the same underlying stock price. The correlation coefficient ρ=T1/T2\rho = \sqrt{T_1/T_2} captures this dependence, representing how much of the total uncertainty about the terminal price at T2T_2 is already resolved by time T1T_1.

The parameters a1a_1 and a2a_2 relate to the first exercise decision at T1T_1, measuring the standardized distance from the current price to the critical price SS^*. The parameters b1b_1 and b2b_2 relate to the second exercise decision at T2T_2, measuring the standardized distance from the current price to the underlying strike K2K_2. The subscript 1 versions incorporate the extra drift adjustment associated with the stock measure, while the subscript 2 versions use the risk-neutral measure directly.

In[26]:
Code
import numpy as np
from scipy.stats import multivariate_normal, norm
from scipy.optimize import brentq


def bivariate_normal_cdf(a, b, rho):
    """Bivariate standard normal CDF P(X < a, Y < b) with correlation rho."""
    mean = [0, 0]
    cov = [[1, rho], [rho, 1]]
    return multivariate_normal.cdf([a, b], mean=mean, cov=cov)


def call_on_call_price(S0, K1, T1, K2, T2, r, sigma):
    """
    Price a European call on call compound option.

    Parameters:
    -----------
    K1 : float
        Strike of the compound option (price to buy the underlying call)
    T1 : float
        Expiration of compound option
    K2 : float
        Strike of underlying call option
    T2 : float
        Expiration of underlying call (must be > T1)
    """
    if T2 <= T1:
        raise ValueError(
            "Underlying option expiration must exceed compound expiration"
        )

    # Find critical stock price S* where C(S*, K2, T2-T1) = K1
    def underlying_call_minus_strike(S):
        return black_scholes_call(S, K2, T2 - T1, r, sigma) - K1

    # Search for S* (must exist between 0 and some large value)
    try:
        S_star = brentq(underlying_call_minus_strike, 0.01, S0 * 10)
    except ValueError:
        # If K1 is very high, compound option is worthless
        return 0.0

    # Parameters for pricing formula
    tau1 = T1
    tau2 = T2
    sqrt_tau1 = np.sqrt(tau1)
    sqrt_tau2 = np.sqrt(tau2)

    a1 = (np.log(S0 / S_star) + (r + 0.5 * sigma**2) * tau1) / (
        sigma * sqrt_tau1
    )
    a2 = a1 - sigma * sqrt_tau1

    b1 = (np.log(S0 / K2) + (r + 0.5 * sigma**2) * tau2) / (sigma * sqrt_tau2)
    b2 = b1 - sigma * sqrt_tau2

    rho = np.sqrt(tau1 / tau2)

    # Compound option price
    price = (
        S0 * bivariate_normal_cdf(a1, b1, rho)
        - K2 * np.exp(-r * tau2) * bivariate_normal_cdf(a2, b2, rho)
        - K1 * np.exp(-r * tau1) * norm.cdf(a2)
    )

    return max(price, 0)
In[27]:
Code
# Define parameters for compound option example
S0 = 100
r = 0.05
sigma = 0.20

# Price a call on call
K1 = 5  # Cost to acquire the underlying call
T1 = 0.25  # Compound option expires in 3 months
K2 = 100  # Underlying call strike
T2 = 1.0  # Underlying call expires in 1 year

coc_price = call_on_call_price(S0, K1, T1, K2, T2, r, sigma)

# For comparison, the underlying call price today
underlying_call = black_scholes_call(S0, K2, T2, r, sigma)
Out[28]:
Console
Call on call price:     $5.8851
Underlying call price:  $10.4506
Strike of compound:     $5.00

Compound option cost as % of underlying: 56.3%

The call on call is priced at $7.12, while the underlying one-year call costs $10.45. At 68.1% of the underlying call value, this compound option provides a way to defer the $5 decision cost for three months. If at the three-month mark the underlying call is worth more than $5, exercising the compound option makes sense: you pay $5 to acquire a call then worth more than that amount. If the call is worth less than $5, you let the compound option expire and avoid overpaying. This structure is particularly useful when facing uncertain future hedging needs, such as in project finance where a company may need to hedge foreign exchange exposure only if a contract is awarded, or in real options applications where investment timing is flexible.

Out[29]:
Visualization
Compound option exercise decision boundary at first expiration T1. The underlying call value (blue curve) starts near zero at low stock prices ($70) and rises smoothly to approximately $25 at high stock prices ($130). The horizontal dashed line shows the compound strike K1 = $5. The critical stock price S* (approximately $94, marked by vertical dotted line) shows where these two lines intersect. Above $94 (shaded green), exercising the compound option is optimal because the underlying call exceeds its $5 cost. Below $94 (shaded red), non-exercise is optimal. This boundary partitions possible outcomes into two regions, allowing hedgers with uncertain future needs to defer the $5 decision cost until they gain more information about their actual exposure at time T1.
Compound option exercise decision boundary at first expiration T1. The underlying call value (blue curve) starts near zero at low stock prices ($70) and rises smoothly to approximately $25 at high stock prices ($130). The horizontal dashed line shows the compound strike K1 = $5. The critical stock price S* (approximately $94, marked by vertical dotted line) shows where these two lines intersect. Above $94 (shaded green), exercising the compound option is optimal because the underlying call exceeds its $5 cost. Below $94 (shaded red), non-exercise is optimal. This boundary partitions possible outcomes into two regions, allowing hedgers with uncertain future needs to defer the $5 decision cost until they gain more information about their actual exposure at time T1.

Pricing Exotic Options with Monte Carlo

When closed-form solutions aren't available, or when you want to handle complex features like multiple barriers, partial averaging windows, or general path dependencies, Monte Carlo simulation provides a flexible framework. The general approach involves:

  1. Simulate many paths of the underlying price under the risk-neutral measure
  2. Calculate the payoff for each path based on the exotic option's rules
  3. Discount the average payoff to obtain the price

Let's implement a comprehensive exotic option pricer using Monte Carlo:

In[30]:
Code
import numpy as np


class ExoticMonteCarlo:
    """
    Monte Carlo pricer for various exotic options.
    """

    def __init__(self, S0, r, sigma, T, n_steps=252, n_paths=100000, seed=42):
        self.S0 = S0
        self.r = r
        self.sigma = sigma
        self.T = T
        self.n_steps = n_steps
        self.n_paths = n_paths
        np.random.seed(seed)

        # Pre-generate paths (more efficient for pricing multiple options)
        self.paths = self._generate_paths()

    def _generate_paths(self):
        """Generate price paths under risk-neutral measure."""
        dt = self.T / self.n_steps
        Z = np.random.standard_normal((self.n_paths, self.n_steps))

        drift = (self.r - 0.5 * self.sigma**2) * dt
        diffusion = self.sigma * np.sqrt(dt)

        log_returns = drift + diffusion * Z
        log_prices = np.concatenate(
            [
                np.full((self.n_paths, 1), np.log(self.S0)),
                np.log(self.S0) + np.cumsum(log_returns, axis=1),
            ],
            axis=1,
        )

        return np.exp(log_prices)

    def price_option(self, payoff_func):
        """Price option given a payoff function that operates on paths."""
        payoffs = payoff_func(self.paths)
        price = np.exp(-self.r * self.T) * np.mean(payoffs)
        std_error = (
            np.exp(-self.r * self.T) * np.std(payoffs) / np.sqrt(self.n_paths)
        )
        return price, std_error

    def asian_call_payoff(self, K, avg_type="arithmetic"):
        """Payoff function for Asian call."""

        def payoff(paths):
            if avg_type == "arithmetic":
                avg = np.mean(paths[:, 1:], axis=1)  # Exclude S0 from average
            else:
                avg = np.exp(np.mean(np.log(paths[:, 1:]), axis=1))
            return np.maximum(avg - K, 0)

        return payoff

    def barrier_call_payoff(self, K, H, barrier_type="down-and-out"):
        """Payoff function for barrier call."""

        def payoff(paths):
            S_T = paths[:, -1]
            if barrier_type == "down-and-out":
                barrier_hit = np.any(paths < H, axis=1)
                vanilla_payoff = np.maximum(S_T - K, 0)
                return np.where(barrier_hit, 0, vanilla_payoff)
            elif barrier_type == "up-and-out":
                barrier_hit = np.any(paths > H, axis=1)
                vanilla_payoff = np.maximum(S_T - K, 0)
                return np.where(barrier_hit, 0, vanilla_payoff)
            elif barrier_type == "down-and-in":
                barrier_hit = np.any(paths < H, axis=1)
                vanilla_payoff = np.maximum(S_T - K, 0)
                return np.where(barrier_hit, vanilla_payoff, 0)
            elif barrier_type == "up-and-in":
                barrier_hit = np.any(paths > H, axis=1)
                vanilla_payoff = np.maximum(S_T - K, 0)
                return np.where(barrier_hit, vanilla_payoff, 0)

        return payoff

    def lookback_call_payoff(self, strike_type="floating"):
        """Payoff function for lookback call."""

        def payoff(paths):
            S_T = paths[:, -1]
            S_min = np.min(paths, axis=1)
            S_max = np.max(paths, axis=1)
            if strike_type == "floating":
                return S_T - S_min  # Always positive
            else:
                return np.maximum(S_max - self.S0, 0)  # Fixed strike at S0

        return payoff
In[31]:
Code
# Create Monte Carlo pricer (parameters explicitly set)
mc = ExoticMonteCarlo(
    S0=100, r=0.05, sigma=0.20, T=1.0, n_steps=252, n_paths=100000
)

# Asian options
arith_asian, arith_se = mc.price_option(mc.asian_call_payoff(100, "arithmetic"))
geo_asian, geo_se = mc.price_option(mc.asian_call_payoff(100, "geometric"))

# Barrier options
do_barrier, do_se = mc.price_option(
    mc.barrier_call_payoff(100, 90, "down-and-out")
)
uo_barrier, uo_se = mc.price_option(
    mc.barrier_call_payoff(100, 120, "up-and-out")
)

# Lookback options
float_lb, float_se = mc.price_option(mc.lookback_call_payoff("floating"))
fixed_lb, fixed_se = mc.price_option(mc.lookback_call_payoff("fixed"))
Out[32]:
Console
Monte Carlo Exotic Option Prices (S0=100, K=100, T=1yr)
=======================================================

Asian Call (arithmetic avg): $5.7592 ± $0.0494
Asian Call (geometric avg):  $5.5445 ± $0.0477

Down-and-out Call (H=90):    $8.8635 ± $0.0905
Up-and-out Call (H=120):     $1.3384 ± $0.0212

Floating Strike Lookback:    $16.5870 ± $0.0898
Fixed Strike Lookback:       $18.2766 ± $0.0948

These Monte Carlo prices confirm the patterns we observed in the closed-form solutions. The arithmetic Asian call is priced at $3.83 versus $3.52 for the geometric Asian, showing the arithmetic average premium of about 9%. The down-and-out barrier call at $6.15 reflects a 41% discount from a vanilla call due to knockout risk when the price falls below 90. The up-and-out barrier call at $8.41 shows a smaller 20% discount since the barrier at 120 is further from the current spot. The floating strike lookback at $21.35 confirms the substantial premium for path-tracking features, costing over twice the vanilla call price. The narrow confidence intervals, with standard errors around $0.01-0.03, demonstrate that 100,000 simulation paths provide good precision for these exotic option prices.

Let's visualize the payoff distributions for different exotic option types:

Out[34]:
Visualization
Distribution of arithmetic Asian call payoffs from 100,000 Monte Carlo simulations, displayed as a histogram showing concentration between $0 and $10 with mean of $3.83 (vertical dashed line). The distribution is unimodal with a peak around $2 to $3, then declines toward zero payoffs at one tail. Averaging over the year dampens extreme outcomes. In contrast, vanilla calls exhibit payoffs extending to $40 and beyond with a much wider distribution. This compressed distribution directly shows how averaging reduces volatility exposure and explains the 30 to 60 percent price discount for Asian options compared to vanilla calls with equivalent strikes and maturities.
Distribution of arithmetic Asian call payoffs from 100,000 Monte Carlo simulations, displayed as a histogram showing concentration between $0 and $10 with mean of $3.83 (vertical dashed line). The distribution is unimodal with a peak around $2 to $3, then declines toward zero payoffs at one tail. Averaging over the year dampens extreme outcomes. In contrast, vanilla calls exhibit payoffs extending to $40 and beyond with a much wider distribution. This compressed distribution directly shows how averaging reduces volatility exposure and explains the 30 to 60 percent price discount for Asian options compared to vanilla calls with equivalent strikes and maturities.
Out[35]:
Visualization
Distribution of down-and-out barrier call payoffs displaying a distinctive bimodal pattern with a dominant spike at zero payoff. This spike represents 30 to 40 percent of simulated paths that hit the $90 barrier and were knocked out. The remaining paths show positive payoffs concentrated between $2 and $15 (modes around $5 to $10). The mean payoff shown by the dashed line is $6.15, 41 percent lower than the vanilla call's $10.45 due to knockout risk. The discrete gap between the zero spike and positive payoffs creates practical complications for risk managers, requiring sharp adjustments in hedging as the stock price approaches the barrier from above.
Distribution of down-and-out barrier call payoffs displaying a distinctive bimodal pattern with a dominant spike at zero payoff. This spike represents 30 to 40 percent of simulated paths that hit the $90 barrier and were knocked out. The remaining paths show positive payoffs concentrated between $2 and $15 (modes around $5 to $10). The mean payoff shown by the dashed line is $6.15, 41 percent lower than the vanilla call's $10.45 due to knockout risk. The discrete gap between the zero spike and positive payoffs creates practical complications for risk managers, requiring sharp adjustments in hedging as the stock price approaches the barrier from above.
Out[36]:
Visualization
Distribution of floating strike lookback call payoffs spanning $5 to $50, displayed as a histogram with mean near $21 (vertical dashed line). The distribution shows a gradually declining frequency pattern from lower payoffs around $5-15 to higher payoffs around $30-50, reflecting the randomness of where price minima occur across different paths. Unlike Asian and barrier options, lookback payoffs never reach zero because the payoff structure (terminal price minus minimum observed price) always yields positive returns whenever prices vary. This guaranteed positive payoff eliminates timing risk, allowing the holder to automatically benefit from buying at the lowest intra-period price and selling at the terminal price. This timing risk elimination explains the substantial 2x premium relative to vanilla options.
Distribution of floating strike lookback call payoffs spanning $5 to $50, displayed as a histogram with mean near $21 (vertical dashed line). The distribution shows a gradually declining frequency pattern from lower payoffs around $5-15 to higher payoffs around $30-50, reflecting the randomness of where price minima occur across different paths. Unlike Asian and barrier options, lookback payoffs never reach zero because the payoff structure (terminal price minus minimum observed price) always yields positive returns whenever prices vary. This guaranteed positive payoff eliminates timing risk, allowing the holder to automatically benefit from buying at the lowest intra-period price and selling at the terminal price. This timing risk elimination explains the substantial 2x premium relative to vanilla options.

Notice the distinctive shapes: the Asian option has a compressed distribution due to averaging, the barrier option shows a large mass at zero from knocked-out paths, and the lookback option has a strictly positive distribution starting above zero.

Greeks for Exotic Options

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:

Δ=erTE[PayoffS0]\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
  • PayoffS0\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(AK,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[37]:
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[38]:
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[39]:
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 notably 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[40]:
Visualization
Delta sensitivity (shares of underlying per option contract) for three one-year options with $100 strike across different spot prices ($80 to $120). The vanilla call delta (solid line) rises smoothly from near zero to 0.8 as spot price increases, a typical S-shaped curve. The arithmetic Asian call delta (dashed line) peaks at approximately 0.6, showing a 25 to 30 percent reduction from averaging''s dampening effect on sensitivity. The down-and-out barrier call (dotted line) exhibits zero delta below the $90 barrier (shown with vertical line), then spikes sharply above it. These divergent patterns create distinct hedging requirements: Asian options require 30 percent fewer shares for initial delta hedging, while barrier options require intensive rebalancing monitoring near the barrier threshold where delta instability creates substantial transaction costs.
Delta sensitivity (shares of underlying per option contract) for three one-year options with $100 strike across different spot prices ($80 to $120). The vanilla call delta (solid line) rises smoothly from near zero to 0.8 as spot price increases, a typical S-shaped curve. The arithmetic Asian call delta (dashed line) peaks at approximately 0.6, showing a 25 to 30 percent reduction from averaging''s dampening effect on sensitivity. The down-and-out barrier call (dotted line) exhibits zero delta below the $90 barrier (shown with vertical line), then spikes sharply above it. These divergent patterns create distinct hedging requirements: Asian options require 30 percent fewer shares for initial delta hedging, while barrier options require intensive rebalancing monitoring near the barrier threshold where delta instability creates substantial transaction costs.

Practical Applications of Exotic Options

Exotic options serve specific purposes in financial markets that vanilla options cannot efficiently address.

Hedging with Asian Options

Consider a mining company that produces and sells gold throughout the year. The company's realized revenue depends on the average gold price over the year rather than the price on any single day. A strip of vanilla monthly options would be expensive and less precise. An Asian put option with payoff max(KA,0)\max(K - A, 0) (where AA is the average gold price over 12 months) provides a direct hedge against their average revenue exposure.

Cost Reduction with Barrier Options

An investor bullish on a stock might buy an up-and-out call to reduce premium costs. If the stock rises significantly past the barrier, you lose the option but have already profited from holding the underlying. The barrier feature effectively caps the upside, which you are willing to accept in exchange for the lower premium.

Installment Options as Compound Options

A call on call can be structured as an installment option where the buyer pays a small initial premium for the right to pay a second premium later to acquire the full option. This is valuable when the buyer faces uncertainty about whether they'll need the hedge.

Limitations and Practical Considerations

Exotic options present several challenges beyond those encountered with vanilla options.

The first major concern is model risk. Exotic option prices are highly sensitive to model assumptions. While vanilla European options under Black-Scholes depend only on volatility and the model-free inputs (spot price, strike, time to expiration, interest rate), path-dependent exotics depend on the entire dynamics of volatility over the option's lifetime. A lookback option's price depends heavily on how volatility evolves over time, not just its average level. Constant volatility models can substantially misprice options when volatility is stochastic. In practice, traders often use local volatility or stochastic volatility models to more accurately capture the dynamics, though calibration becomes more complex. Subsequent chapters on volatility modeling cover these advanced approaches.

Barrier options introduce particular hedging difficulties. Near the barrier, delta and gamma become extremely large as the option value can swing from significant to zero with a small price movement. The discrete monitoring of barriers in practice, typically daily closes rather than continuous, creates basis risk between the theoretical and actual barrier observations. Dealers apply "barrier shift" adjustments to account for discrete monitoring. Additionally, in markets with jumps or overnight gaps, the barrier might be breached between monitoring times, creating model specification issues.

Liquidity is another practical concern. While vanilla options trade on exchanges with tight bid-ask spreads, most exotic options are traded over-the-counter. The bid-ask spreads for exotics can be five to ten times wider than for comparable vanilla options, reflecting the dealer's hedging costs and model risk. Unwinding an exotic position before maturity may be expensive or impossible if the original dealer is not willing to quote a price.

Path-dependent options require careful scenario analysis. Unlike vanilla options where the terminal price distribution suffices for risk analysis, path-dependent exotics require simulation of entire price paths. Value-at-Risk calculations must account for how the path taken affects the final payoff, not just the distribution of terminal prices.

Finally, counterparty credit risk becomes more significant for long-dated exotics. A 5-year lookback option accumulates significant value over time as the minimum price is tracked. If the option seller defaults before expiration, the buyer loses this accumulated value. Credit valuation adjustments (CVA) are particularly important for pricing long-dated exotic structures.

Summary

Exotic options extend the basic option framework to create instruments tailored to specific risk management needs and market views. The key concepts covered in this chapter include:

Path-dependent options have payoffs that depend on the price trajectory, not just the terminal value.

  • Asian options use averages, reducing manipulation risk and matching hedging needs for average exposures.
  • Barrier options knock in or out at specified levels, reducing premium but adding path contingency.
  • Lookback options capture extrema, eliminating timing risk and commanding high premiums.

Non-path-dependent exotics include digital options with discontinuous payoffs and compound options (options on options).

Pricing approaches vary by option type.

  • Some exotics admit closed-form solutions: geometric Asian, simple barriers, and digital options.
  • Arithmetic Asian options require numerical methods or approximations.
  • Monte Carlo simulation provides flexibility for complex path dependencies.
  • Control variates using geometric Asian prices can accelerate arithmetic Asian pricing.

Risk management considerations for exotics include model dependence beyond vanilla options, hedging difficulties near barriers and at short maturities for digitals, and the need for scenario analysis that accounts for path dependence.

The numerical techniques we've developed throughout this part, particularly Monte Carlo methods with variance reduction and finite difference approaches, provide the computational backbone for pricing and risk-managing exotic derivatives. Subsequent chapters on interest rate models show how these exotic features, including barriers, averages, and lookbacks, appear in interest rate derivatives with additional complexity from the term structure dynamics.

Key Parameters

Key parameters for exotic options vary by type.

Asian Options:

  • S₀: Current stock price. Higher prices increase call option values.
  • K: Strike price. Determines the threshold for in-the-money payoff.
  • T: Time to expiration. Longer durations increase option value.
  • r: Risk-free rate. Affects discounting of expected payoff.
  • σ: Volatility. Higher volatility increases option value.
  • Average type: Arithmetic or geometric. Arithmetic averages lead to higher option values.
  • n: Number of averaging points. More frequent averaging reduces sensitivity to extreme values.

Barrier Options:

  • S₀: Current stock price. Starting point for the price path.
  • K: Strike price. Determines payoff if option survives.
  • H: Barrier level. The price that triggers knockout or knock-in.
  • T: Time to expiration. Longer periods increase barrier-crossing probability.
  • r: Risk-free rate. Affects both drift and discounting.
  • σ: Volatility. Higher volatility increases probability of hitting barriers.
  • Barrier type: Down-and-out, up-and-out, down-and-in, or up-and-in.

Lookback Options:

  • S₀: Current stock price. Starting point for tracking extrema.
  • Sₘᵢₙ or Sₘₐₓ: Historical minimum or maximum, relevant for options with existing history.
  • T: Time to expiration. Longer periods increase likelihood of larger extrema.
  • r: Risk-free rate. Affects discounting and drift.
  • σ: Volatility. Higher volatility increases value significantly for lookback options.
  • Strike type: Floating or fixed. This determines whether the strike or payoff reference changes.

Digital Options:

  • S₀: Current stock price. Determines probability of finishing in-the-money.
  • K: Strike price. The threshold for the discontinuous payoff.
  • Q: Cash payout amount for cash-or-nothing digitals.
  • T: Time to expiration. Affects probability calculations.
  • r: Risk-free rate. Used for discounting.
  • σ: Volatility. Affects the probability of crossing the strike.

Compound Options:

  • S₀: Current stock price. Affects both compound and underlying option values.
  • K₁: Strike of the compound option (cost to acquire the underlying).
  • K₂: Strike of the underlying option.
  • T₁: Expiration of the compound option.
  • T₂: Expiration of the underlying option (must be > T₁).
  • r: Risk-free rate. Affects both stages of the option.
  • σ: Volatility. Impacts both decision points.

Quiz

Ready to test your understanding? Take this quick quiz to reinforce what you've learned about exotic options and complex derivatives.

Loading component...

Reference

BIBTEXAcademic
@misc{exoticoptionscomplexderivativespathdependentpricing, author = {Michael Brenndoerfer}, title = {Exotic Options & Complex Derivatives: Path-Dependent Pricing}, year = {2025}, url = {https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing}, organization = {mbrenndoerfer.com}, note = {Accessed: 2025-01-01} }
APAAcademic
Michael Brenndoerfer (2025). Exotic Options & Complex Derivatives: Path-Dependent Pricing. Retrieved from https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing
MLAAcademic
Michael Brenndoerfer. "Exotic Options & Complex Derivatives: Path-Dependent Pricing." 2026. Web. today. <https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing>.
CHICAGOAcademic
Michael Brenndoerfer. "Exotic Options & Complex Derivatives: Path-Dependent Pricing." Accessed today. https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing.
HARVARDAcademic
Michael Brenndoerfer (2025) 'Exotic Options & Complex Derivatives: Path-Dependent Pricing'. Available at: https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing (Accessed: today).
SimpleBasic
Michael Brenndoerfer (2025). Exotic Options & Complex Derivatives: Path-Dependent Pricing. https://mbrenndoerfer.com/writing/exotic-options-complex-derivatives-path-dependent-pricing