The Greeks: How an Option's Price Moves

An option’s price depends on several inputs — spot, strike, time, volatility, rates. The Greeks are just the sensitivities: how much the price moves when each input changes by a bit. They turn “the option went up” into “the option went up because spot moved 50 points (delta) minus a day of theta”. For a programmer this is lovely, because every Greek is a formula you can compute.

The five Greeks, with real numbers

All numbers below are real Black-Scholes values for an ATM Nifty 24,000 call, 7 days to expiry, IV 12%:

• Delta (Δ) ≈ 0.54. The price change per 1-point move in spot. If Nifty rises 10 points, this call gains ~5.4 points. Delta has two more beautiful interpretations: it is roughly the probability of expiring in-the-money, and it is your “share-equivalent” exposure — holding this call is like holding ~0.54 units of Nifty. ITM options have delta near 1, OTM near 0.
• Gamma (Γ) ≈ 0.001. How fast delta itself changes as spot moves. Gamma is highest for ATM options near expiry — which is exactly why expiry day is wild: a small move swings your delta (and P&L) fast. Long options have positive gamma (good moves accelerate); short options have negative gamma (bad moves accelerate against you).
• Theta (Θ) ≈ −14 points/day. Time decay — how many points the option loses each day, all else equal. Our ATM call loses ~14 points a day just from the clock ticking. This is the buyer’s silent enemy and the seller’s entire business model.
• Vega (ν) ≈ 13 per 1% IV. Sensitivity to implied volatility. If IV rises from 12% to 13%, this call gains ~13 points without the spot moving at all. A big vega position is a bet on volatility itself, not direction (Lessons 5–6).
• Rho (ρ) — small. Sensitivity to interest rates. For short-dated Indian index options, it is usually minor. Know it exists; don’t lose sleep over it.

Computing them in Python

The Greeks come straight out of Black-Scholes. Here is a compact, runnable version:

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

def N(x):  return 0.5 * (1 + erf(x / sqrt(2)))      # normal CDF
def n(x):  return exp(-x*x/2) / sqrt(2*pi)          # normal PDF

def greeks(S, K, T, r, sigma, call=True):
    d1 = (log(S/K) + (r + sigma**2/2)*T) / (sigma*sqrt(T))
    d2 = d1 - sigma*sqrt(T)
    delta = N(d1) if call else N(d1) - 1
    gamma = n(d1) / (S*sigma*sqrt(T))
    vega  = S*n(d1)*sqrt(T) / 100                    # per 1% vol
    theta = (-S*n(d1)*sigma/(2*sqrt(T))
             - r*K*exp(-r*T)*(N(d2) if call else -N(-d2))) / 365   # per day
    return dict(delta=delta, gamma=gamma, vega=vega, theta=theta)

# ATM Nifty weekly
print(greeks(S=24000, K=24000, T=7/365, r=0.07, sigma=0.12))
# -> delta ~0.54, gamma ~0.001, vega ~13, theta ~ -14/day

That is the whole machine. Now you can compute the exact exposure of any position, sum the Greeks across many legs, and know what you are holding rather than guessing.

Theta: the one to respect

If you take one thing from this lesson, take theta. An option is a melting ice cube. Every single day it loses time value, and (as we saw in Lesson 3 and will see on the decay curve) it melts faster as expiry approaches.

The numbers are real: a 30-day ATM call worth 402 points falls to 176 by 7 days, and to 62 by the last day — the curve steepens. For buyers this is brutal: you lose money every day the market just sits there, so you must be right and quick. For sellers, it is the whole game: you sell time value and let theta quietly work for you, especially in the final week. Delta is direction; theta is time. Most beginners obsess over direction and get killed by time.

Pitfalls

• Ignoring theta. Buying options and “waiting” is paying rent every day. If your view does not play out quickly, time decay wins.
• Forgetting Greeks are portfolio-additive. Your real exposure is the sum of Greeks across all positions. Always look at the net.
• Expiry-day gamma. Near expiry, ATM gamma is huge — tiny moves cause big swings. Respect expiry day or avoid it until experienced.

Recap

The Greeks measure sensitivity: delta (direction, ≈ P(ITM), share-equivalent), gamma (how delta changes), theta (time decay — respect it most), vega (volatility), rho (rates, minor). They come straight from Black-Scholes and are additive across a portfolio, so you can always compute your true exposure.

Next: Lesson 5 — Pricing & Implied Volatility, where we write a real Black-Scholes pricer and learn what implied volatility actually is.