The Greeks: Delta, Gamma, Vega, Theta

What Are the Greeks?

The Greeks are partial derivatives of the option price with respect to various inputs. They tell you how sensitive your option position is to changes in the underlying stock price, time, volatility, and interest rates. Every options trader thinks in terms of Greeks, and every quant interview will test your understanding of them.

Think of it this way: the option price is a function of five variables. The Greeks tell you the slope of that function in each direction. If you know the Greeks, you know how your P&L will change for small moves in any input.

Ρ Rho

Sensitivity to interest rates. For a 1% increase in the risk-free rate, how much does the option price change? Rho is the least important Greek for short-dated options but matters for LEAPS (long-dated options over a year). Calls have positive rho (benefit from higher rates), puts have negative rho.

Python: Calculate All Greeks

import numpy as np
from scipy.stats import norm

def option_greeks(S, K, T, r, sigma):
    """Calculate all option Greeks from Black-Scholes."""
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)

    # --- DELTA ---
    # Call delta: N(d1), range [0, 1]
    # Put delta: N(d1) - 1, range [-1, 0]
    delta_call = norm.cdf(d1)
    delta_put = norm.cdf(d1) - 1

    # --- GAMMA ---
    # Same for calls and puts
    # Highest for ATM options near expiry
    gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))

    # --- VEGA ---
    # Per 1% move in volatility
    # Same for calls and puts
    vega = S * norm.pdf(d1) * np.sqrt(T) / 100

    # --- THETA ---
    # Per calendar day (divide by 365)
    theta_call = (-(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T))
                  - r * K * np.exp(-r * T) * norm.cdf(d2)) / 365
    theta_put = (-(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T))
                 + r * K * np.exp(-r * T) * norm.cdf(-d2)) / 365

    # --- RHO ---
    # Per 1% move in interest rate
    rho_call = K * T * np.exp(-r * T) * norm.cdf(d2) / 100
    rho_put = -K * T * np.exp(-r * T) * norm.cdf(-d2) / 100

    return {
        "delta_call": delta_call, "delta_put": delta_put,
        "gamma": gamma, "vega": vega,
        "theta_call": theta_call, "theta_put": theta_put,
        "rho_call": rho_call, "rho_put": rho_put
    }

# ATM option: S=K=100
greeks = option_greeks(S=100, K=100, T=0.25, r=0.05, sigma=0.2)
for name, val in greeks.items():
    print(f"{name:>12}: {val:>8.4f}")

How Traders Use Greeks to Hedge

A market maker who sells a call option to a client is exposed to the stock going up (negative delta exposure). To hedge, they buy delta shares of the underlying stock, making the position "delta-neutral." As the stock moves, delta changes (because of gamma), so they must continuously rebalance. This is called dynamic delta hedging.

def delta_hedge_pnl(S0, K, T, r, sigma, n_steps=252):
    """
    Simulate delta hedging a short call position.
    Shows how traders use delta to manage risk daily.
    """
    dt = T / n_steps
    S = [S0]
    hedge_costs = []
    shares_held = 0

    for i in range(n_steps):
        t_remaining = T - i * dt
        if t_remaining <= 0:
            break

        d1 = (np.log(S[-1] / K) + (r + 0.5 * sigma**2) * t_remaining) / \
              (sigma * np.sqrt(t_remaining))
        delta = norm.cdf(d1)

        # Rebalance hedge
        shares_to_trade = delta - shares_held
        hedge_costs.append(shares_to_trade * S[-1])
        shares_held = delta

        # Simulate next price
        Z = np.random.standard_normal()
        new_S = S[-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z)
        S.append(new_S)

    # Final P&L
    option_payoff = max(S[-1] - K, 0)
    total_hedge_cost = sum(hedge_costs) - shares_held * S[-1]
    pnl = -option_payoff - total_hedge_cost

    return pnl

# Run 1000 trials
pnls = [delta_hedge_pnl(100, 100, 0.25, 0.05, 0.2) for _ in range(1000)]
print(f"Mean P&L:  {np.mean(pnls):.2f}")
print(f"Std P&L:   {np.std(pnls):.2f}")
print("(Should be close to zero if hedging works perfectly)")

Greeks Across Strike Prices

Understanding how Greeks vary with moneyness is crucial. Deep in-the-money calls have delta near 1, deep OTM calls have delta near 0. Gamma peaks at the money. This table shows the full picture.

def greek_across_strikes(S, strikes, T, r, sigma, greek_name="delta"):
    """Show how a Greek varies across strike prices."""
    print(f"
{greek_name.upper()} across strikes (S={S}, T={T:.2f})")
    print(f"{'Strike':>8} | {'Call':>8} | {'Put':>8}")
    print("-" * 30)

    for K in strikes:
        g = option_greeks(S, K, T, r, sigma)
        if greek_name == "delta":
            print(f"{K:>8.0f} | {g['delta_call']:>8.4f} | {g['delta_put']:>8.4f}")
        elif greek_name == "gamma":
            print(f"{K:>8.0f} | {g['gamma']:>8.4f} | {g['gamma']:>8.4f}")
        elif greek_name == "theta":
            print(f"{K:>8.0f} | {g['theta_call']:>8.4f} | {g['theta_put']:>8.4f}")

strikes = range(80, 121, 5)
greek_across_strikes(100, strikes, 0.25, 0.05, 0.2, "delta")
greek_across_strikes(100, strikes, 0.25, 0.05, 0.2, "gamma")
greek_across_strikes(100, strikes, 0.25, 0.05, 0.2, "theta")