Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Exotic Options and Complex Derivatives › Path-Dependent Options

Michael BrenndoerferDecember 5, 202527 min read

Quantitative FinanceAll chapters

Part 6 of 15Numerical Methods for Derivative Pricing

Chapter 37Exotic Options and Complex Derivatives › Path-Dependent Options

Reading section 2 of 10 · Path-Dependent Options · 27 minSection 2 of 10 · 27 min

Section 2 of 10 · 27 min read

Exotic Options and Complex Derivatives › Path-Dependent OptionsOne section · Sections in this chapter2 / 10 ↓

Sections in this chapter10

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

Path-dependent options have payoffs determined by the entire trajectory of prices over the option's life rather than the final price alone. 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 $100 to$ 110, while the second spiked to $150 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. Sensitivity to both the path and destination defines path-dependent options and creates their value and pricing complexity.

Asian OptionsLink Copied

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 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(A - K, 0)$ where $A$ is the average price.
Average strike options: The average replaces the strike price. A call pays $\max(S_T - A, 0)$ .

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

\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:

$S_{t_i}$ : asset price at monitoring time $t_i$
$n$ : number of monitoring points
$A_{\text{arithmetic}}$ : arithmetic mean of prices
$A_{\text{geometric}}$ : geometric mean of prices

The distinction between arithmetic and geometric averages changes how each option can be priced. 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 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

Line chart showing five colored price paths (dashed) and their running averages (solid) over one year. The running averages converge toward the center of the price range, visibly less volatile than the underlying paths. A horizontal dotted line marks the initial price of $100. — Price paths and running averages over one year for five sample scenarios. Solid lines show running averages, which evolve more smoothly than the corresponding dashed price paths because each new observation receives only a fraction of the average''s total weight. The simulated examples also show that averaging dampens, rather than eliminates, path dispersion: a path that trends persistently upward can still finish with a substantially higher average.

Pricing Asian OptionsLink Copied

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(A_{\text{geometric}}) \sim N\left(\hat{\mu}, \hat{\sigma}^2\right)

where:

$A_{\text{geometric}}$ : geometric mean of prices
$\hat{\mu}$ : adjusted mean of the logarithmic distribution
$\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:

C_{\text{geometric}} = e^{-rT}\left[e^{\hat{\mu} + \frac{\hat{\sigma}^2}{2}} N(d_1) - K N(d_2)\right]

where:

$S_0$ : current stock price
$K$ : strike price
$r$ : risk-free rate
$T$ : time to maturity
$\sigma$ : volatility
$q$ : dividend yield
$\hat{\mu} = \ln(S_0) + (r - q - \sigma^2/2)\frac{T}{2}$ : adjusted mean for the average
$\hat{\sigma}^2 = \frac{\sigma^2 T}{3}$ : adjusted variance for the average
$d_1 = \frac{\hat{\mu} + \hat{\sigma}^2 - \ln(K)}{\hat{\sigma}}$ : standardized distance measure
$d_2 = d_1 - \hat{\sigma}$ : risk-adjusted distance measure
$N(\cdot)$ : cumulative standard normal distribution

This formula mirrors the Black-Scholes structure, where $e^{\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/2$ rather than $T$ 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 $\hat{\sigma}^2 = \sigma^2 T/3$ reflects a similar but more subtle effect. The factor of $1/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 $5.5468 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 geometric Asian price of $5.5445 matches the $5.5468 closed-form value within the simulation's 95% confidence interval, validating the path simulation. The arithmetic Asian price is $5.7592, about 3.9% higher than the geometric estimate. 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 remain cheaper than the corresponding vanilla European call, which is priced at about $10.45 for these parameters. Averaging reduces exposure to extreme price movements and therefore lowers option value.

Barrier OptionsLink Copied

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 on where the price ends up and 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:

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

where:

$\text{Knock-in}$ : value of the barrier option that activates if the barrier is crossed
$\text{Knock-out}$ : value of the barrier option that extinguishes if the barrier is crossed
$\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 is both a pricing tool and a consistency check for models.

Out[9]:

Visualization

Chart of 20 simulated price paths over one year. Teal surviving paths remain above the coral dashed barrier at $90. Coral knocked-out paths stop at an X marker where they first cross the barrier. Horizontal lines mark the $90 barrier and $100 strike. Annotated counts show 9 knocked-out and 11 surviving paths. — Sample price paths for down-and-out barrier calls with barrier H = $90 and strike K = $100. Teal paths avoid the barrier and retain standard call payoff potential, while coral paths stop when they first cross below $90, with the crossing marked by an X. In this seeded sample, 9 of 20 paths are knocked out. The sample illustrates why the barrier feature lowers the option''s premium: some otherwise valuable terminal outcomes are removed when a path touches the barrier earlier in its life.

Closed-Form Barrier Option PricingLink Copied

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 $S_0$ , hits the barrier $H$ at some time, and ends at $S_T$ , there exists a corresponding "reflected" path that starts at $S_0$ , hits the barrier, and ends at $H^2/S_T$ (the reflection of $S_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 < S_0$ and $H < K$ :

\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:

$C_{\text{BS}}$ : standard Black-Scholes call price
$S_0$ : current stock price
$K$ : strike price
$H$ : barrier level ( $H < S_0$ )
$r$ : risk-free rate
$T$ : time to expiration
$\sigma$ : volatility
$\lambda = \frac{r + \sigma^2/2}{\sigma^2}$ : shape parameter related to drift and volatility
$y = \frac{\ln(H^2/(S_0 K))}{\sigma\sqrt{T}} + \lambda \sigma \sqrt{T}$ : standardized barrier distance parameter
$N(\cdot)$ : cumulative standard normal distribution

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

$C_{\text{BS}}$ is the price of an otherwise identical vanilla call option.
The barrier adjustment consists of the remaining terms, which quantify the value of paths that hit the barrier $H$ . The factor $(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/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 $y$ measures how far the barrier is from the current price in a normalized sense. The term $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 $\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, showing the in-out parity relationship.

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

Out[13]:

Visualization

Line chart with barrier level on the x-axis ($60 to $99) and option price on the y-axis. The down-and-out call (solid) declines toward zero as the barrier approaches $100. The down-and-in call (dashed) rises correspondingly. A horizontal dotted line shows the constant vanilla call price. The two curves sum to the vanilla price at every point. — 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), which reflects 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 OptionsLink Copied

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 $150 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 $S_T - S_{\min}$ , where $S_{\min}$ is the minimum price during the option's life. The holder effectively buys at the lowest price.
Fixed strike lookback call: Pays $\max(S_{\max} - K, 0)$ , where $S_{\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:

\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:

$S_0$ : current stock price
$S_{\min}$ : minimum observed price during the option's life
$r$ : risk-free rate
$T$ : time to expiration
$\sigma$ : volatility
$a_1 = \frac{\ln(S_0/S_{\min}) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}$
$a_2 = a_1 - \sigma\sqrt{T}$
$a_3 = \frac{\ln(S_0/S_{\min}) + (-r + \sigma^2/2)T}{\sigma\sqrt{T}}$
$N(\cdot)$ : cumulative standard normal distribution

The first term, $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 $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 $\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 $S_{\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 $a_1$ measures how far the current price is above the observed minimum in standardized units, adjusted for the expected drift. When $S_0$ is much larger than $S_{\min}$ (meaning the stock has already risen substantially from its low), $a_1$ becomes large and $N(a_1)$ approaches 1, indicating high probability of finishing above the current minimum. The parameter $a_3$ differs from $a_2$ in that it uses $-r$ rather than $+r$ in the drift adjustment, which reflects the need to consider the dynamics under the "stock measure" where the stock itself is numeraire.

For newly issued lookback options $S_{\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