Workshop 4, Hedging Vehicles - Module 2

Author

Alberto Dorantes

Published

November 24, 2025

Abstract
In this workshop we learn about The Greeks and Hedging Strategies

1 Introduction - From Valuation to Risk Management

In Workshop 3, we learned how to find the “fair price” of an option using Binomial Lattices and the Black-Scholes-Merton (BSM) model. We established that the BSM model acts as the limit case of the Binomial model as the number of steps N \to \infty

However, knowing the price is only half the battle. As a trader or portfolio manager, you need to know how that price changes when market conditions change.

  • What happens if the stock price jumps $1?
  • What happens if volatility spikes?
  • What happens as we get one day closer to expiration?

These sensitivities are called “The Greeks”. They are partial derivatives of the option pricing formula with respect to different variables.

Analogy: If the Option Price is the current speed of your car, the Greeks are the dashboard indicators (speedometer, tachometer, fuel gauge) that tell you how your speed will change if you press the gas, turn the wheel, or run out of fuel.

2 The Greeks: Definitions and Calculation

We will use the Black-Scholes analytical framework to calculate these sensitivities.

2.1 Delta (\Delta) - Directional Risk

Delta measures the rate of change of the option price with respect to changes in the underlying stock price S.

\Delta = \frac{\partial V}{\partial S}

  • Call Delta: N(d_1) (Ranges from 0 to 1)
  • Put Delta: N(d_1) - 1 (Ranges from -1 to 0)

Interpretation: If a Call has a \Delta = 0.60, and the stock price rises by $1, the option price will rise by approximately $0.60.

2.2 Gamma (\Gamma) - Curvature

Gamma measures the rate of change of Delta with respect to the stock price. It is the “convexity” of the option.

\Gamma = \frac{\partial^2 V}{\partial S^2}

  • Interpretation: Gamma tells you how stable your Delta is. A high Gamma means your Delta will change rapidly if the stock moves (making hedging difficult). Gamma is highest for At-The-Money (ATM) options.

2.3 Theta (\Theta) - Time Decay

Theta measures the change in option price with respect to the passage of time (usually 1 day).

\Theta = \frac{\partial V}{\partial t}

  • Interpretation: Theta is almost always negative for long option positions. If \Theta = -0.05, the option loses $0.05 in value every day, all else being equal. This is the “rent” you pay for holding the contract.

2.4 Vega (\nu) - Volatility Sensitivity

Vega measures the sensitivity to changes in the volatility (\sigma) of the underlying asset.

\nu = \frac{\partial V}{\partial \sigma}

  • Interpretation: If Vega = 0.15 and volatility increases by 1% (e.g., from 20% to 21%), the option price increases by $0.15.

2.5 Rho (\rho) - Interest Rate Sensitivity

Rho measures sensitivity to the risk-free rate r. It is generally less critical in low-interest environments but matters for long-dated options.

3 Python Implementation: Calculating the Greeks

Let’s use the same parameters from our previous workshop exercises to calculate the Greeks for a European Call.

  • S_0 = 100
  • K = 105
  • r = 5\%
  • \sigma = 20\%
  • T = 1 year
Code 
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# Define the BSM Class for Price and Greeks
class BlackScholes:
    def __init__(self, S, K, T, r, sigma):
        self.S = S
        self.K = K
        self.T = T
        self.r = r
        self.sigma = sigma
        
        self.d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
        self.d2 = self.d1 - sigma * np.sqrt(T)

    def price_call(self):
        return self.S * norm.cdf(self.d1) - self.K * np.exp(-self.r * self.T) * norm.cdf(self.d2)

    def delta_call(self):
        return norm.cdf(self.d1)

    def gamma(self):
        return norm.pdf(self.d1) / (self.S * self.sigma * np.sqrt(self.T))

    def vega(self):
        return self.S * norm.pdf(self.d1) * np.sqrt(self.T) / 100 # Divided by 100 to show per 1% vol change

    def theta_call_annual(self):
        term1 = - (self.S * norm.pdf(self.d1) * self.sigma) / (2 * np.sqrt(self.T))
        term2 = - self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(self.d2)
        return term1 + term2

    def theta_call_daily(self):
        return self.theta_call_annual() / 365

# Parameters
S = 100; K = 105; T = 1.0; r = 0.05; sigma = 0.20

bsm = BlackScholes(S, K, T, r, sigma)

print(f"--- Option Greeks (Call, K={K}) ---")
print(f"Price: ${bsm.price_call():.4f}")
print(f"Delta:  {bsm.delta_call():.4f} (If S goes to 101, Price goes up ~0.53)")
print(f"Gamma:  {bsm.gamma():.4f} (Curvature)")
print(f"Vega:   {bsm.vega():.4f} (If vol goes 20%->21%, Price goes up $0.37)")
print(f"Theta: {bsm.theta_call_daily():.4f} (Daily time decay)")
--- Option Greeks (Call, K=105) ---
Price: $8.0214
Delta:  0.5422 (If S goes to 101, Price goes up ~0.53)
Gamma:  0.0198 (Curvature)
Vega:   0.3967 (If vol goes 20%->21%, Price goes up $0.37)
Theta: -0.0172 (Daily time decay)

4 Visualizing the Greeks

Below, we visualize how Delta and Gamma change as the Stock Price changes.

Code 
stock_prices = np.linspace(50, 150, 100)
deltas = []
gammas = []

for s in stock_prices:
    model = BlackScholes(s, K, T, r, sigma)
    deltas.append(model.delta_call())
    gammas.append(model.gamma())

fig, ax = plt.subplots(1, 2, figsize=(14, 5))

# Delta Plot
ax[0].plot(stock_prices, deltas, color='blue', lw=2)
ax[0].set_title(f'Delta vs Stock Price (K={K})')
ax[0].set_xlabel('Stock Price')
ax[0].set_ylabel('Delta')
ax[0].grid(True, alpha=0.3)
ax[0].axvline(K, color='red', linestyle='--', label='Strike')

# Gamma Plot
ax[1].plot(stock_prices, gammas, color='green', lw=2)
ax[1].set_title(f'Gamma vs Stock Price (K={K})')
ax[1].set_xlabel('Stock Price')
ax[1].set_ylabel('Gamma')
ax[1].grid(True, alpha=0.3)
ax[1].axvline(K, color='red', linestyle='--', label='Strike')

plt.show()

5 Hedging Strategies

Hedging is the practice of reducing risk in a portfolio. We use the Greeks to determine how to neutralize specific risks.

5.1 Strategy 1: Delta Hedging (The Foundation)

Objective: Make the portfolio immune to small movements in the stock price. This is achieved when the Portfolio Delta (\Delta_{\Pi}) is zero.

\Delta_{\Pi} = \Delta_{Option} \times (\text{\# Options}) + \Delta_{Stock} \times (\text{\# Shares}) = 0

Recall that \Delta_{Stock} = 1.

Example:

You sold (wrote) 1,000 Call Options. You are “Short Calls”.

  • Call Delta (\Delta_c) = 0.53 (from our calculation above).

  • Your Position Delta: -1000 \times 0.53 = -530.

  • Risk: If the stock goes up, you lose money.

  • The Hedge: You need a Delta of +530 to neutralize.

  • Action: Buy 530 shares of the stock.

Result: If stock rises $1, you lose $530 on options but gain $530 on shares. Net change \approx 0.

5.2 Strategy 2: Delta-Gamma Hedging

Objective: Delta hedging works for small moves. If the stock moves significantly, Gamma changes the Delta, and your hedge breaks. This strategy neutralizes both directional risk (Delta) and curvature risk (Gamma).

Requirements: You need two different options (Option A and Option B) and the underlying stock.

Steps:

  1. Calculate Gamma exposure of your current portfolio.

  2. Buy/Sell Option B to neutralize Gamma (Stock has 0 Gamma, so it can’t help here).

  3. Adjust Stock holding to re-neutralize Delta (since trading Option B changed your Delta).

5.3 Strategy 3: Vega Hedging

Objective: Protect the portfolio against changes in market volatility (e.g., before an earnings announcement).

Mechanism: Similar to Gamma hedging, you must trade an instrument sensitive to volatility (another option).

  • If you are “Short Vega” (sold options), a spike in volatility hurts you.

  • Hedge: Buy a longer-term option (Long Vega) to offset the risk.

6 Simulation: Delta Hedging in Action

Let’s simulate a “Delta Neutral” portfolio. We are Short 1 Call Option. We will hedge by buying shares.

Scenario:

  • Stock Price moves from $90 to $110.

  • We compare the P&L of an Unhedged Short Call vs. a Delta-Hedged Short Call.

Code 
# Create arrays
S_range = np.linspace(80, 120, 50)
initial_S = 100
initial_model = BlackScholes(initial_S, K, T, r, sigma)
initial_call_price = initial_model.price_call()
initial_delta = initial_model.delta_call()

# Portfolio Construction: Short 1 Call
# To hedge: Buy 'Delta' amount of shares
shares_bought = initial_delta 

unhedged_pnl = []
hedged_pnl = []

for s_future in S_range:
    # Future option price (assuming no time passed for simplicity of curve)
    future_model = BlackScholes(s_future, K, T, r, sigma)
    future_call_price = future_model.price_call()
    
    # 1. Unhedged PnL: (Price_Sold - Price_Current)
    pnl_unhedged = (initial_call_price - future_call_price)
    unhedged_pnl.append(pnl_unhedged)
    
    # 2. Hedged PnL: Unhedged PnL + Gain/Loss on Shares
    share_gain = shares_bought * (s_future - initial_S)
    pnl_hedged = pnl_unhedged + share_gain
    hedged_pnl.append(pnl_hedged)

# Plotting
plt.figure(figsize=(10, 6))
plt.plot(S_range, unhedged_pnl, label='Unhedged (Short Call)', color='red', linestyle='--')
plt.plot(S_range, hedged_pnl, label='Delta Hedged Portfolio', color='blue', linewidth=2.5)

plt.title('Hedged vs Unhedged Portfolio Performance (Instantaneous)')
plt.xlabel('Stock Price')
plt.ylabel('Profit / Loss ($)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(initial_S, color='grey', linestyle=':', label='Initial Spot ($100)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

6.1 Observation

Look at the Blue line (Hedged):

  1. At S=100, the curve is flat. Small moves left or right result in negligible P&L changes.

  2. However, as prices move far away (e.g., to $115), the hedge loses effectiveness (the blue line curves down).

  3. Why? Because of Gamma. The Delta changed, but we held a fixed number of shares. To maintain the hedge, we would need to rebalance (dynamically adjust shares) continuously.

7 Appendix: Complete Greeks Formulas

In practice, many assets (like stock indices or large cap stocks) pay dividends. When an asset pays a continuous dividend yield \delta, the drift of the stock price is reduced, which impacts option valuation and the Greeks.

Below is the comparison between the standard model (\delta=0) and the dividend-adjusted model (\delta > 0).

7.1 The Auxiliary Variables (d_1 and d_2)

The most immediate change is in the calculation of d_1. The risk-free rate r is replaced by the cost of carry (r - \delta).

No Dividend (\delta=0) With Dividend Yield (\delta)
d_1 = \frac{\ln(S/K) + (r + \frac{\sigma^2}{2})T}{\sigma\sqrt{T}} d_1 = \frac{\ln(S/K) + (r - \delta + \frac{\sigma^2}{2})T}{\sigma\sqrt{T}}
d_2 = d_1 - \sigma\sqrt{T} d_2 = d_1 - \sigma\sqrt{T}

7.2 The Formulas

In the formulas below: * N(x) is the Cumulative Normal Distribution. * N'(x) is the Probability Density Function (PDF): N'(x) = \frac{1}{\sqrt{2\pi}} e^{-x^2/2}.

7.2.1 Delta (\Delta)

Measures change in Option Price per unit change in Stock Price.

Option Type No Dividend (\delta=0) With Dividend Yield (\delta)
Call \Delta_c = N(d_1) \Delta_c = e^{-{\delta}T} N(d_1)
Put \Delta_p = N(d_1) - 1 \Delta_p = e^{-{\delta}T} (N(d_1) - 1)

7.2.2 Gamma (\Gamma)

Measures change in Delta per unit change in Stock Price (Curvature). Note: Gamma is usually the same for Calls and Puts.

No Dividend (\delta=0) With Dividend Yield (\delta)
\Gamma = \frac{N'(d_1)}{S \sigma \sqrt{T}} \Gamma = \frac{e^{-{\delta}T} N'(d_1)}{S \sigma \sqrt{T}}

7.2.3 Vega (\nu)

Measures change in Option Price per 1% change in Volatility. Note: Vega is the same for Calls and Puts.

No Dividend (\delta=0) With Dividend Yield (\delta)
\nu = S \sqrt{T} N'(d_1) \nu = S e^{-{\delta}T} \sqrt{T} N'(d_1)

7.2.4 Rho (\rho)

Measures change in Option Price per change in Risk-Free Rate.

Option Type No Dividend (\delta=0) With Dividend Yield (\delta)
Call \rho_c = K T e^{-rT} N(d_2) \rho_c = K T e^{-rT} N(d_2)
Put \rho_p = -K T e^{-rT} N(-d_2) \rho_p = -K T e^{-rT} N(-d_2)

7.2.5 Theta (\Theta)

Measures change in Option Price per passage of Time.

For Assets with No Dividends (\delta=0):

\Theta_{call} = - \frac{S N'(d_1) \sigma}{2\sqrt{T}} - r K e^{-rT} N(d_2)

\Theta_{put} = - \frac{S N'(d_1) \sigma}{2\sqrt{T}} + r K e^{-rT} N(-d_2)

For Assets with Dividend Yield (\delta > 0):

\Theta_{call} = - \frac{S e^{-{\delta}T} N'(d_1) \sigma}{2\sqrt{T}} - r K e^{-rT} N(d_2) + q S e^{-{\delta}T} N(d_1)

\Theta_{put} = - \frac{S e^{-{\delta}T} N'(d_1) \sigma}{2\sqrt{T}} + r K e^{-rT} N(-d_2) - q S e^{-{\delta}T} N(-d_1)

8 Summary

  1. Greeks are the risk sensitivities of your option portfolio.

  2. Delta is the most important Greek for day-to-day directional hedging.

  3. Gamma measures how fast Delta changes; high Gamma requires frequent rebalancing.

  4. Hedging is not “set and forget.” It requires dynamic adjustment (Rebalancing).

9 EXERCISES

You have to do the Exercises from the Excel Greeks_Template. Follow directions in classs.