Options and the Greeks

An option's price depends on the stock price, on volatility and on the time left. Traders don't just want the price; they want to know how it will change when any of those move, because that is their risk. Those sensitivities are called the Greeks. This lesson builds each one from the Black–Scholes price, shows how they behave as expiry approaches, and connects them in the one equation that explains why options lose value over time.

From price to sensitivities

The Monte Carlo lesson priced a European call with the Black–Scholes formula, $C = S\,\Phi(d_1) - K e^{-rT}\Phi(d_2)$. Differentiating it gives closed forms for every Greek, with $\varphi$ the standard normal density:

For a one-year at-the-money call ($S = K = 100$, $r = 5\%$, $\sigma = 20\%$), worth 10.45: $\Delta = 0.637$, $\Gamma = 0.0188$, vega is 0.375 per volatility point, and theta is $-0.0176$ per calendar day.

Read them as a Taylor expansion of how the price changes over a short time $\delta t$ when the stock moves by $\delta S$ (and volatility by $\delta\sigma$):

Delta: the hedge ratio

Delta is how many shares behave like the option for small moves. With $\Delta = 0.637$, a 1.00 rise in the stock adds about 0.64 to the call. A trader who sells this call and buys 0.637 shares per option is delta-neutral: small stock moves no longer change the position's value. Delta runs from 0 (far out of the money) to 1 (deep in the money), and is the starting point for hedging, which the delta hedging lesson simulates.

Gamma: curvature

Delta itself changes as the stock moves; gamma measures how fast. Because of the $\tfrac{1}{2}\Gamma(\delta S)^2$ term, a position with positive gamma gains from a move in either direction once it is delta-hedged: the hedge was set for the old delta, and the option gained more on the way up and lost less on the way down than the shares. Owning options means owning gamma.

Vega: volatility

Higher volatility makes a large final payoff more likely without making the downside worse (an option's loss is capped at its price), so call and put prices both rise with volatility. Vega is largest for at-the-money, long-dated options. Option traders often think of themselves as trading volatility rather than direction, and vega is that exposure.

Theta: the cost of time

As time passes with nothing else changing, an option loses value: theta is negative. There is no free lunch in owning gamma, and Black–Scholes makes the price exact. The model's partial differential equation says that for any option,

Check it on our call: $\tfrac{1}{2}\sigma^2 S^2\Gamma = 3.752$, $rS\Delta = 3.184$ and $rC = 0.523$, so $\Theta = -3.752 - 3.184 + 0.523 = -6.414$ per year, exactly the value from the formula above. The gamma term dominates: theta is the rent paid for gamma. A delta-hedged option holder profits if the stock moves more than volatility implied and loses the time decay if it moves less.

Key idea. Long options are long gamma and pay theta; short options earn theta and are short gamma. Whether owning gamma pays off depends on whether realised volatility beats the volatility in the price.

Watching the Greeks change

Press play on time: the chart counts down from a year to a day before expiry.

Switch between the Greeks and watch:

• The price curve bends toward the hockey-stick payoff as expiry nears.
• Delta becomes a step: near expiry the option is almost exactly worth 0 or 1 share, depending on which side of the strike the stock is.
• Gamma piles up at the strike: near expiry, delta can swing from 0 to 1 on a small move.
• Theta grows at the strike: the last days cost the most per day.

For the at-the-money call, from the code below:

Over the last month, gamma and the daily time decay both rise about five-fold; on the final day the option loses twelve times as much value as it did per day a year out. Short options close to expiry and close to the strike are among the riskiest positions a desk can hold.

In code

from math import erf, exp, log, pi, sqrt

def N(x):
    return 0.5 * (1 + erf(x / sqrt(2)))

def n(x):
    return exp(-x * x / 2) / sqrt(2 * pi)

def call(S, K, r, sigma, T):
    d1 = (log(S / K) + (r + sigma**2 / 2) * T) / (sigma * sqrt(T))
    d2 = d1 - sigma * sqrt(T)
    price = S * N(d1) - K * exp(-r * T) * N(d2)
    greeks = {
        "delta": N(d1),
        "gamma": n(d1) / (S * sigma * sqrt(T)),
        "vega": S * n(d1) * sqrt(T) / 100,  # per volatility point
        "theta": (-S * n(d1) * sigma / (2 * sqrt(T)) - r * K * exp(-r * T) * N(d2)) / 365,  # per day
    }
    return price, greeks

price, g = call(100, 100, 0.05, 0.20, 1.0)
print(f"price {price:.3f}", {k: round(v, 4) for k, v in g.items()})

# Check delta and gamma by bumping the stock price: always test formulas like this.
h = 0.01
up, down = call(100 + h, 100, 0.05, 0.2, 1.0)[0], call(100 - h, 100, 0.05, 0.2, 1.0)[0]
print(f"bumped delta {(up - down) / (2 * h):.4f}, bumped gamma {(up - 2 * price + down) / h**2:.4f}")

# Near expiry, at-the-money gamma and theta grow sharply.
for days in (365, 30, 5, 1):
    price, g = call(100, 100, 0.05, 0.20, days / 365)
    print(f"{days:>3} days: price {price:6.3f}  gamma {g['gamma']:.4f}  theta/day {g['theta']:.4f}")

It prints the price 10.451 with delta 0.6368, gamma 0.0188, vega 0.3752 and theta −0.0176. The bumped (finite-difference) delta and gamma agree, 0.6368 and 0.0188, and the loop prints the table above. Bumping is also how Greeks are computed for options with no formula: reprice with the input nudged up and down, as the floating point lesson warns, with a step size that isn't so small that rounding swamps the difference.

Where this shows up in quant work

• Risk reports. Options desks are run on aggregated Greeks: total delta, gamma, vega and theta by underlying, expiry and strike, checked against limits every day.
• Hedging. Delta is hedged with the underlying; gamma and vega can only be hedged with other options.
• Volatility trading. Buying options and delta-hedging them is a bet that realised volatility will exceed the volatility implied by the price, with theta as the cost.

Exercises

• Using put–call parity, $C - P = S - Ke^{-rT}$, show that a put's delta is $\Delta_{\text{call}} - 1$ and its gamma is the same as the call's.
• A trader is short 100 at-the-money one-month calls on 100 shares each and delta-hedged. Roughly how much do they lose, from gamma alone, if the stock jumps by 3 overnight?
• Extend call to compute vega and theta by bumping, and compare with the closed forms. How small can the bump be before the answer gets worse?

Key takeaways

• Greeks are the price's sensitivities: delta to the stock, gamma to delta's change, vega to volatility, theta to time.
• Delta is the hedge ratio; gamma is the curvature that makes hedged long options gain from moves.
• Black–Scholes links them: theta pays for gamma. Owning options profits only if the stock moves more than the price implied.
• Near expiry and near the strike, gamma and theta grow sharply.