Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Volatility Trading and Arbitrage Strategies › Delta-Hedged Option Strategies

Michael BrenndoerferDecember 30, 202514 min read

Quantitative FinanceAll chapters

Part 11 of 15Quantitative Trading Strategies

Chapter 63Volatility Trading and Arbitrage Strategies › Delta-Hedged Option Strategies

Reading section 3 of 15 · Delta-Hedged Option Strategies · 14 minSection 3 of 15 · 14 min

Section 3 of 15 · 14 min read

Volatility Trading and Arbitrage Strategies › Delta-Hedged Option StrategiesOne section · Sections in this chapter3 / 15 ↓

Sections in this chapter15

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

The key to isolating pure volatility exposure from options is delta hedging. By continuously adjusting a hedge position in the underlying asset, you can neutralize directional exposure and focus exclusively on whether implied volatility overstates or understates realized volatility.

The Mechanics of Delta HedgingLink Copied

Consider if we sell a call option with delta $\Delta_C$ . To become delta-neutral, we buy $\Delta_C$ shares of the underlying. As the underlying price moves and time passes, the option's delta changes. We must rebalance the hedge, buying more shares when delta increases and selling when delta decreases.

Delta hedging turns an option position with directional and volatility exposure into a pure volatility bet. When you sell an option without hedging, your profit depends heavily on which way the underlying asset moves. But when you hedge away the directional exposure by holding offsetting shares, your profit depends only on whether the option was priced correctly relative to the actual volatility that materializes. This separation lets volatility trading possible as a distinct discipline.

Delta-Neutral Position

A delta-neutral position has zero first-order sensitivity to small changes in the underlying price. For a portfolio of options and underlying shares, the position is delta-neutral when $\sum_i \Delta_i \cdot Q_i = 0$ , where $\Delta_i$ is the delta of each position and $Q_i$ is the quantity.

In[7]:

Code

from scipy.stats import norm


def black_scholes_call(S, K, T, r, sigma):
    """Calculate Black-Scholes call price and delta."""
    if T <= 0:
        return max(S - K, 0), 1.0 if S > K else 0.0

    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)

    call_price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
    delta = norm.cdf(d1)
    gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))

    return call_price, delta, gamma


# Option parameters
S0 = 100
K = 100
T = 30 / 365  # 30 days to expiration
r = 0.05
sigma_implied = 0.25

# Calculate initial option price and Greeks
call_price, delta, gamma = black_scholes_call(S0, K, T, r, sigma_implied)

Out[8]:

Console

Initial Call Price: $3.06
Initial Delta: 0.5371
Initial Gamma: 0.0554

To delta-hedge 1 short call, buy 0.5371 shares

Out[9]:

Visualization

Call delta rises from nearly zero at a stock price of 70 to nearly one at 130, crossing 0.5 near the 100 strike. — Delta profile for a call option across a range of stock prices. The delta transitions from 0 to 1 as the asset moves from out-of-the-money to in-the-money, with the highest rate of change occurring near the strike price.

Call gamma forms a bell-shaped curve centered on the 100 strike and tapers toward zero at lower and higher stock prices. — Gamma profile for a call option highlighting its peak at the strike price. The bell-shaped curve shows where the option's delta is most sensitive to price movements, representing the area of highest hedging risk for you.

The positive delta indicates that the option price moves in the same direction as the underlying asset. To hedge a short call position (which has negative delta exposure), you must buy shares of the underlying asset to neutralize directional risk. The gamma value represents the curvature of the option price; a higher gamma requires more frequent rebalancing of the hedge ratio. Gamma tells us how quickly the delta changes as the underlying moves, and therefore how much trading activity will be required to maintain the hedge. Options near the money and close to expiration have the highest gamma, meaning they require the most active management.

P&L from Delta-Hedged PositionsLink Copied

The profit or loss from a delta-hedged option position comes from the interaction between the option's theta decay and the gamma-driven gains from rebalancing. To understand this relationship, we need to analyze how the value of a delta-hedged portfolio changes over time and with price movements.

We can derive the P&L dynamics by analyzing the change in value of the delta-hedged portfolio $\Pi = V - \Delta S$ . Using a second-order Taylor expansion (Ito's Lemma):

\begin{aligned} \text{Daily P\&L} &= dV - \Delta dS \\ &= \left( \Theta dt + \Delta dS + \frac{1}{2}\Gamma (dS)^2 \right) - \Delta dS && \text{(Ito's Lemma)} \\ &= \Theta dt + \frac{1}{2}\Gamma (dS)^2 && \text{(cancel $\Delta dS$ terms)} \\ &\approx \Theta dt + \frac{1}{2}\Gamma S^2 \sigma_{\text{real}}^2 dt && \text{(substitute $(dS)^2 \approx S^2 \sigma_{\text{real}}^2 dt$)} \end{aligned}

where:

$\text{Daily P\&L}$ : profit or loss over the time step
$V$ : option value
$\Delta$ : option delta
$\Gamma$ : option gamma
$S$ : underlying asset price
$\sigma_{\text{real}}$ : realized volatility of the underlying asset
$dt$ : small time increment
$\Theta$ : option theta

This derivation shows the tension in delta-hedged option positions. The first step applies Ito's Lemma to express how the option value changes: it moves with time (theta), with the underlying price (delta times the price change), and with the square of the price change (half gamma times the squared move). When we subtract the hedge position's change in value, the delta terms cancel perfectly because that is exactly what the hedge is designed to do. What remains are the theta and gamma terms, which cannot be hedged away simultaneously.

For a delta-hedged long option position:

Theta ( $\Theta$ ): The option loses value due to time decay. This is a cost.
Gamma ( $\Gamma$ ): When the underlying moves, the hedge position profits from rebalancing. This is a gain.

The key insight is that theta cost is determined by implied volatility (priced into the option), while gamma gains are determined by realized volatility (actual market moves). If realized volatility exceeds implied, gamma gains exceed theta costs, and the long volatility position profits. This is the essential mechanism of volatility trading: you are betting on whether the actual price movements will be larger or smaller than what the option price assumed.

The theta of an option represents the daily cost of maintaining the position, and this cost is higher when implied volatility is higher because a higher implied volatility means a more expensive option that has more time value to decay. The gamma gains, conversely, depend on how much the underlying moves. When the underlying makes a large move, a long gamma position benefits because the delta has changed, and the hedge needs rebalancing at favorable prices. If these actual moves are consistently larger than what was priced in, the rebalancing gains exceed the time decay costs.

In[10]:

Code

def simulate_delta_hedge(
    S0, K, T, r, sigma_imp, sigma_real, n_steps=100, n_paths=1000
):
    """
    Simulate delta-hedged option P&L.

    Parameters:
    - sigma_imp: Implied volatility (used to price option)
    - sigma_real: Realized volatility (actual price moves)
    """
    dt = T / n_steps

    # Initial option price at implied vol
    initial_call, initial_delta, _ = black_scholes_call(S0, K, T, r, sigma_imp)

    pnls = []

    for _ in range(n_paths):
        S = S0
        cash = initial_call - initial_delta * S  # Sell call, buy delta shares
        shares = initial_delta

        for step in range(n_steps):
            # Remaining time
            tau = T - step * dt
            if tau <= dt:
                break

            # Price moves with realized volatility
            dW = np.random.normal(0, np.sqrt(dt))
            S_new = S * np.exp((r - 0.5 * sigma_real**2) * dt + sigma_real * dW)

            # Rebalance hedge using implied vol for delta calculation
            _, new_delta, _ = black_scholes_call(
                S_new, K, tau - dt, r, sigma_imp
            )

            # Cost of rebalancing
            cash = cash * np.exp(r * dt)  # Earn interest on cash
            rebalance_cost = (new_delta - shares) * S_new
            cash -= rebalance_cost
            shares = new_delta
            S = S_new

        # Final P&L at expiration
        option_payoff = max(S - K, 0)
        final_value = cash + shares * S - option_payoff
        pnls.append(final_value)

    return np.array(pnls)

In[11]:

Code

# Simulate three scenarios
np.random.seed(42)

# Define volatility scenarios
imp_vol = 0.25
real_vol_neutral = 0.25
real_vol_low = 0.18
real_vol_high = 0.35

# Scenario 1: Realized vol = Implied vol
pnl_neutral = simulate_delta_hedge(
    100, 100, 30 / 365, 0.05, imp_vol, real_vol_neutral
)

# Scenario 2: Realized vol < Implied vol (profitable for short vol)
pnl_low_real = simulate_delta_hedge(
    100, 100, 30 / 365, 0.05, imp_vol, real_vol_low
)

# Scenario 3: Realized vol > Implied vol (loss for short vol)
pnl_high_real = simulate_delta_hedge(
    100, 100, 30 / 365, 0.05, imp_vol, real_vol_high
)

Out[12]:

Visualization

Three overlapping histograms showing P&L distributions for different volatility scenarios. — Profit and loss distributions for a delta-hedged short call across three volatility scenarios. The strategy generates positive returns when realized volatility remains below the 25% implied volatility level, while higher realized moves lead to significant losses from gamma rebalancing costs.

Out[13]:

Console

Delta-Hedged Short Call P&L Summary:

Realized = Implied (25%):  Mean P&L = $0.02, Std = $0.25
Realized (18%) < Implied:  Mean P&L = $0.83, Std = $0.32
Realized (35%) > Implied:  Mean P&L = $-1.13, Std = $0.60

The simulation confirms our theoretical expectation: when realized volatility is lower than implied, the short volatility position profits from collecting more theta than it loses to gamma. When realized volatility exceeds implied, the position loses money as gamma costs exceed theta gains. Notice also that even when realized and implied volatility are equal, there is dispersion in outcomes. This variance arises because while the average gamma gain equals the average theta loss, the actual path matters, and some paths will be more favorable than others purely by chance.

Gamma ScalpingLink Copied

Gamma scalping is a trading technique that attempts to profit from the gamma of a long option position. If you are long gamma (long options), you benefit when the underlying makes large moves in either direction. By rebalancing delta frequently, you "lock in" gains from these moves.

When you are long gamma and the stock rises, your delta increases. You are effectively longer the stock at higher prices. By selling some shares to rebalance to delta-neutral, you capture a profit. Similarly, when the stock falls, your delta decreases, and by buying shares at lower prices, you profit again.

To understand why this works, consider the mechanics of the hedge adjustment. When you are long a call option and the stock rises, your call option increases in value, but so does its delta. If you started with a delta-neutral position, you are now slightly long the market because your call is more sensitive to further moves. To restore neutrality, you sell shares at the current higher price. If the stock subsequently falls back, you will need to buy shares again at the lower price. You have effectively sold high and bought low, locking in a trading profit. This profit comes from the convexity of the option's payoff, which is measured by gamma.

You must weigh these gamma gains against theta decay. A long gamma position pays theta every day as the option loses time value. If the stock does not move enough to generate sufficient rebalancing profits, the theta costs will dominate and the position will lose money. This is why gamma scalping is only profitable when realized volatility exceeds implied volatility: the moves must be large enough and frequent enough to offset the daily time decay.

In[14]:

Code

def gamma_scalp_example(S0, K, T, r, sigma, price_path):
    """
    Demonstrate gamma scalping with a specific price path.
    """
    n_steps = len(price_path) - 1
    dt = T / n_steps

    # Initial position: long 1 call, short delta shares
    _, initial_delta, _ = black_scholes_call(S0, K, T, r, sigma)

    shares = -initial_delta  # Short shares to hedge
    cash = initial_delta * S0  # Cash from selling shares

    records = []

    for step in range(n_steps):
        tau = T - step * dt
        S = price_path[step]
        S_new = price_path[step + 1]

        # Current delta
        _, delta, gamma = black_scholes_call(S, K, tau, r, sigma)

        # Skip if time is too small
        if tau <= dt:
            break
        if tau <= dt:
            break

        # P&L from share position
        share_pnl = shares * (S_new - S)

        # New delta for rebalancing
        _, new_delta, _ = black_scholes_call(S_new, K, tau - dt, r, sigma)

        # Rebalance
        shares_traded = -(
            new_delta - (-shares)
        )  # Negative because we're short delta worth of shares
        rebalance_cash = shares_traded * S_new

        records.append(
            {
                "step": step,
                "price": S,
                "delta": delta,
                "gamma": gamma,
                "shares": shares,
                "share_pnl": share_pnl,
                "shares_traded": shares_traded,
                "rebalance_cash": rebalance_cash,
            }
        )

        shares = -new_delta
        cash += rebalance_cash

    return pd.DataFrame(records)


# Create a volatile price path
np.random.seed(123)
n_steps = 20
price_path = [100]
for _ in range(n_steps):
    move = np.random.choice([-2, -1, 1, 2])  # Discrete jumps
    price_path.append(price_path[-1] + move)
price_path = np.array(price_path)

scalp_df = gamma_scalp_example(100, 100, 20 / 252, 0.05, 0.25, price_path)

Out[15]:

Visualization

Line chart with markers showing a discrete stock price path oscillating around 100 over 20 steps. — Simulated stock price path featuring discrete jumps that trigger delta rebalancing. These price movements create the trading opportunities necessary for a gamma scalping strategy to generate profit.

Bar chart with mixed positive and negative hedge-adjustment cash flows and a cumulative line declining to roughly minus 48 dollars by step 20. — Cash paid or received at each hedge adjustment and the cumulative rebalancing balance. The simulated path contains both positive and negative flows and ends with a net cash outlay, which is only one component of the full strategy P&L.

The bars record cash paid or received when the hedge is adjusted. Under this implementation's sign convention, positive bars are cash received and negative bars are cash paid. The cumulative line ends below zero, so the hedge adjustments require net cash over this sample path. That balance is not the strategy's total profit: evaluating gamma scalping also requires the option's mark-to-market value, the stock hedge P&L, and theta decay. The example therefore illustrates the mechanics and path dependence of rebalancing rather than guaranteeing that every adjustment or path produces a gain.