The Greeks: Delta, Gamma, Theta, Vega

Learning Objectives

By the end of this section, you will be able to:

1. Recognize each Greek as an ordinary partial derivative of the Black-Scholes price.
2. Explain the intuition behind Delta, Gamma, Theta, and Vega without any opaque finance jargon.
3. Read the four-Greek "dashboard" for any option from a single picture of its curve.
4. Decompose a trader's daily P&L into Δ, Γ, Θ, and ν contributions using a second-order Taylor expansion.
5. Compute all Greeks two ways: closed-form in plain Python and automatically via PyTorch autograd.
6. Construct a delta-hedged portfolio and see why Gamma drives the residual P&L.

The Big Picture: Greeks Are Just Calculus

Black-Scholes gave us a formula for an option price $V = V(S, t; K, r, \sigma)$. The Greeks are nothing more than its partial derivatives with respect to the variables that change between today and tomorrow:

Here is the analogy that makes everything click. Imagine you are driving a car. The price $V$ is your position. The stock $S$ is the road. Then:

• Delta is your speed — how fast position changes as you move along the road.
• Gamma is your acceleration — how fast your speed itself is changing.
• Theta is the fuel gauge — value bleeds regardless of where the stock goes.
• Vega is how sensitive your speedometer is to weather — volatility is the "weather forecast" for the stock.

Quick Recap: The Black-Scholes Price

For a European call on a non-dividend stock,

where $N(\cdot)$ is the standard normal CDF and

The puts come from put-call parity: $P = C - S + K e^{-r(T-t)}$.

Delta — The First Derivative

Differentiate the call price with respect to $S$. Two terms in the product rule contain $N'(d_1) \cdot \partial d_1 / \partial S$ and a similar one for $N'(d_2) \cdot \partial d_2 / \partial S$. After algebra (a beautifully clean cancellation that is worth doing once in your life), almost everything dies and you are left with:

Closed-Form Delta

What Delta Really Means

Three different but equivalent ways to read $\Delta = N(d_1) = 0.57$:

1. Slope. If the stock rises by $1, the call gains about $0.57. That is the textbook reading.
2. Hedge ratio. To neutralize the option's stock exposure right now, short 0.57 shares per call you sold. This is the basis of delta hedging.
3. Probability. Under the risk-neutral measure, $N(d_1)$ is (almost) the probability the call ends in-the-money — actually it is the probability weighted by the stock's own dynamics, but to within a small correction it is the intuition every trader carries in their head.

Mnemonic: "Delta is shares-equivalent." A call with Δ = 0.57 behaves locally like owning 0.57 shares of the underlying.

Gamma — Curvature of the Option

Differentiate Delta one more time: $\Gamma = \partial \Delta / \partial S = \partial^2 V / \partial S^2$. The product rule combined with the chain rule on $N(d_1)$ gives:

Why Gamma Is Always Positive

Every factor on the right — $\varphi(d_1)$, $S$, $\sigma$, $\sqrt{\tau}$ — is positive. So a long option position always has positive curvature. Intuitively: the payoff function $\max(S_T - K, 0)$ is convex, and so its present value must be convex too.

Practical consequence: an option's P&L from a stock move is better than the linear approximation in both directions. If you are long an option and the stock moves either way, you get a free bonus from the curvature. That bonus is called "gamma rent" — and someone has to pay for it. They pay for it through Theta.

Theta — The Bleeding of Time

Time is the only variable in $V$ that moves on its own without anyone trading. Differentiate with respect to calendar time $t$:

For a long call this is always negative. Two stories in one formula:

• The volatility-decay term $-\tfrac{S \varphi(d_1) \sigma}{2\sqrt{\tau}}$ : every day, you lose a tiny piece of the optionality just because there is less time for the stock to move. This term is exactly the gamma rent flowing the other direction — mathematically it equals $-\tfrac{1}{2}\sigma^2 S^2 \Gamma$, which you may recognise as a term in the Black-Scholes PDE.
• The financing term $-r K e^{-r\tau} N(d_2)$ : the present value of the strike that would be paid at exercise grows as expiry approaches; that growth costs the call holder money.

The fundamental trade-off in options. Long Gamma ⇒ positive Γ ⇒ negative Θ. You buy curvature; you pay rent on it. Selling options reverses both signs — you collect rent, you owe curvature.

Vega — Sensitivity to Volatility

Differentiating with respect to $\sigma$ is again a textbook chain-rule exercise that collapses to:

Three things to notice immediately:

1. Same $\varphi(d_1)$ bell-curve factor as Gamma. So Vega is biggest at-the-money — there is the most to gain from extra volatility there.
2. Scales like $\sqrt{\tau}$, the opposite of Gamma. Long-dated options are vega-rich; short-dated ones are gamma-rich. That is a fundamental tension between the two ends of the volatility curve.
3. Same value for calls and puts (just like Gamma). Both have the same dependence on σ because they only differ by a deterministic put-call parity piece.

Interactive: All Four Greeks at Once

Below is a five-panel dashboard. The top panel is the option price itself; the bottom four panels are its partial derivatives with respect to $S, S, t, \sigma$ respectively. Move the sliders and watch how each Greek is literally the slope, curvature, or partial of the one above.

Putting It Together: P&L as a Taylor Expansion

A trader holding an option overnight sees the stock move by $dS$, time advance by $dt$, and implied volatility shift by $d\sigma$. The change in the option's value, to second order, is a multivariate Taylor expansion:

Each term is one of the Greeks doing exactly what it was named for:

Now look at the magic. If you delta-hedge by shorting $\Delta$ shares, the first term vanishes. What is left is:

Two of those — $\Gamma$ and $\Theta$ — must balance over time, or there is arbitrage. That balance, written precisely, is the Black-Scholes PDE: $\Theta + \tfrac{1}{2}\sigma^2 S^2 \Gamma + r S \Delta - r V = 0$. Every term you have built in this section appears in that single line.

Visual: Delta and Gamma as Approximations

The most beautiful single picture in this section. Pick an expansion point $S_0$. The green dashed line is the linear (Delta-only) approximation of the option price. The amber dotted curve is the quadratic (Delta + Gamma) approximation. The blue curve is the true price.

Drag the shock $dS$ slider. For small $dS$ the three dots almost coincide — Delta is enough. Push it further and the green dot drifts below the truth because the linear approximation misses the curvature. The amber dot stays close because the quadratic term captures Gamma.

Worked Example (Try It By Hand)

Same scenario you will see in the Python output below — work through it with a calculator first so the formulas feel concrete.

Computing the Greeks in Plain Python

First the "intuition" version: write each closed-form Greek out as it appears in the textbook. No surprises — just enter the formulas and read the result.

np.log(100/100) → 0.0

norm.cdf(0) → 0.5,  norm.pdf(0) → 0.3989

S=K=100, r=.05, σ=.2, T=.25 → d₁ = (0 + 0.07·0.25)/(0.2·0.5) = 0.175

d₂ = 0.175 − 0.2·0.5 = 0.075

φ(0.175) ≈ 0.393

Atm 3-month call → ≈ 4.61

Deep ITM call → N(d₁) → 1.  Deep OTM → 0.

Atm 3-month call → Θ ≈ −15 per year ≈ −$0.041 per day.

Δ_put = 0.57 − 1 = −0.43

Atm 3-month: Γ ≈ 0.0394

Atm 3-month: ν ≈ 19.7 per unit of σ ≈ 0.197 per 1% σ.

1import numpy as np
2from scipy.stats import norm
3
4def black_scholes_greeks(S, K, T, r, sigma, option_type="call"):
5    """Price and all Greeks for a European option.
6
7    S      : current stock price
8    K      : strike price
9    T      : time to expiry (years)
10    r      : risk-free rate (annualized, continuous)
11    sigma  : volatility (annualized)
12    option_type : "call" or "put"
13    """
14    # 1. The two building blocks d1, d2.
15    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
16    d2 = d1 - sigma * np.sqrt(T)
17
18    # 2. Standard-normal CDF N(x) and PDF phi(x).
19    N   = norm.cdf
20    phi = norm.pdf
21
22    # 3. Price and Delta depend on call vs put.
23    if option_type == "call":
24        price = S * N(d1) - K * np.exp(-r * T) * N(d2)
25        delta = N(d1)
26        theta = (-S * phi(d1) * sigma / (2 * np.sqrt(T))
27                 - r * K * np.exp(-r * T) * N(d2))
28    else:
29        price = K * np.exp(-r * T) * N(-d2) - S * N(-d1)
30        delta = N(d1) - 1
31        theta = (-S * phi(d1) * sigma / (2 * np.sqrt(T))
32                 + r * K * np.exp(-r * T) * N(-d2))
33
34    # 4. Gamma and Vega are identical for calls and puts.
35    gamma = phi(d1) / (S * sigma * np.sqrt(T))
36    vega  = S * phi(d1) * np.sqrt(T)
37
38    return {
39        "price": price,
40        "delta": delta,
41        "gamma": gamma,
42        "theta_per_year": theta,
43        "theta_per_day":  theta / 365.0,
44        "vega_per_1pct":  vega / 100.0,
45    }
46
47# Toy run.
48out = black_scholes_greeks(S=100, K=100, T=0.25, r=0.05, sigma=0.20, option_type="call")
49for k, v in out.items():
50    print(f"{k:<16} = {v:.6f}")

Running this on our worked-example inputs prints:

price            = 4.614997
delta            = 0.569460
gamma            = 0.039261
theta_per_year   = -10.472929
theta_per_day    = -0.028693
vega_per_1pct    = 0.196419

Compare these numbers against the hand-computed ones above — they match to four decimals. The small differences are just rounding in the by-hand normal-table lookups.

Greeks Via PyTorch Autograd

Closed-form derivatives are great when they exist. For complicated exotic options they often don't — and even when they do, the manual chain-rule bookkeeping is error-prone. Autograd does the work for free, and it generalizes immediately to any payoff you can write down in torch ops.

The trick is to mark every market variable we want a Greek for as a leaf tensor with $\texttt{requires\_grad=True}$, then ask $\texttt{torch.autograd.grad}$ for the partial derivatives. Gamma is just the derivative of Delta — one more line.

torch.autograd.grad(price, S) → Delta

Returns tensor(0.5695) — matches N(d₁) by hand.

Returns tensor(0.0394) — matches the closed-form Gamma.

1import torch
2
3def black_scholes_call_torch(S, K, T, r, sigma):
4    """Black-Scholes call price using torch ops so we can differentiate it."""
5    d1 = (torch.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * torch.sqrt(T))
6    d2 = d1 - sigma * torch.sqrt(T)
7    Ncdf = torch.distributions.Normal(0.0, 1.0).cdf
8    price = S * Ncdf(d1) - K * torch.exp(-r * T) * Ncdf(d2)
9    return price
10
11# Treat every market variable we want a Greek for as a leaf with grad.
12S     = torch.tensor(100.0, requires_grad=True)
13sigma = torch.tensor(0.20,  requires_grad=True)
14T     = torch.tensor(0.25,  requires_grad=True)
15K     = torch.tensor(100.0)
16r     = torch.tensor(0.05)
17
18price = black_scholes_call_torch(S, K, T, r, sigma)
19
20# First derivatives — Delta, Vega, Theta (Theta is negative dV/dT).
21delta = torch.autograd.grad(price, S,     create_graph=True)[0]
22vega  = torch.autograd.grad(price, sigma, create_graph=True)[0]
23theta = -torch.autograd.grad(price, T,    create_graph=True)[0]
24
25# Gamma is the derivative of Delta with respect to S.
26gamma = torch.autograd.grad(delta, S)[0]
27
28print("price :", price.item())
29print("delta :", delta.item())
30print("gamma :", gamma.item())
31print("vega  :", vega.item())
32print("theta :", theta.item())

Expected output:

price : 4.6149974...
delta : 0.5694603...
gamma : 0.0392612...
vega  : 19.641888...
theta : -10.472929...

Identical to the closed-form numbers. You wrote the price formula once; autograd produced every Greek by walking the same computation graph backwards. This is the same machinery that backpropagates losses through neural networks — applied to a Black-Scholes price instead.

Application: Delta Hedging

Suppose a market-maker sells one ATM call for $C = 4.61$. They now have exposure $-\Delta = -0.57$ to the stock — if $S$ rises, they lose money. To neutralize this risk they immediately buy $0.57$ shares.

After hedging, the portfolio value is $\Pi = -C + \Delta S$. Its sensitivity to the stock is, by construction:

First-order risk gone. But what is left? Apply the Taylor expansion from earlier:

The short-call position has negative Gamma (so the first term is negative — the trader loses if the stock moves a lot in either direction) and positive Theta (so the second term contributes positively as time passes — the trader collects rent).

The market-maker's bet: over a day, the stock moves less than what the implied volatility predicts. They collect Theta and pay only a small amount of Gamma. Repeated thousands of times with proper risk management, this is the business of being an options market-maker.

And rebalancing the hedge — buying or selling small numbers of shares as $\Delta$ drifts — is the practical reason traders watch Gamma all day. Big Gamma ⇒ Delta changes fast ⇒ rebalance often.

Summary

Every Greek in this section is a partial derivative of the Black-Scholes price. Once you see them as ordinary calculus objects, all of options trading becomes a story about the geometry of one surface.

Take-aways:

1. Delta is the slope; it tells you the equivalent stock position and the first-order hedge.
2. Gamma is the curvature; it is always positive for a long option and creates the "free P&L when the stock moves" that everybody pays Theta for.
3. Theta is the cost of holding optionality — mathematically $-\tfrac{1}{2}\sigma^2 S^2 \Gamma$ appears inside Theta, which is how the Black-Scholes PDE locks them together.
4. Vega tells you how today's price reacts to a shift in the volatility forecast — long options are long Vega, short options are short Vega.
5. A second-order Taylor expansion in $(S, t, \sigma)$ decomposes every day's option P&L into a sum of Greek contributions. That decomposition is what every options trader stares at every morning.
6. Computationally, autograd renders all the closed-form algebra optional: write the price, ask for derivatives, get every Greek for free.