Options: Parity, Binomial & BSM + the Greeks

Finance-Plus Ring · Derivatives branch · Node DV1.02 · ~20 focused hours · Standard mastery gate ≥ 85%

An option price looks like a magic trick. Somebody types five numbers into a formula with a term called N(d1) in it, and a rupee or dollar figure comes out, and the market simply agrees that this is what the contract is worth. It is not magic, and it is not even really a forecast. It is the end product of a disciplined, mechanical argument that you are about to run yourself, by hand, more than once, until it stops feeling like a trick: if a payoff can be replicated exactly by trading the underlying and cash, then the option must cost exactly what the replicating portfolio costs, or somebody prints money for free. Put-call parity is that argument applied once, statically. The binomial tree is that argument applied at every node of every step, working backward from expiry. Black-Scholes-Merton (BSM) is that same argument taken to the limit of infinitely many, infinitesimally small steps, collapsed into a closed-form expression. And the five Greeks are nothing more than "how much does this replicating argument's answer move if one input moves", a set of five partial derivatives that, together, are the entire language a trading desk uses to describe risk. This Ring is additive institutional/CFA breadth, it presents the toolkit and the plumbing alongside, not in place of, the program's process-over-P&L, concentration-over-diversification philosophy; nothing here asks you to trade options, only to understand exactly what a price and a Greek are actually saying.

By the end of this module you will have built, node by node, the exact machinery that prices a callable bond in FI1.04 and that DV1.03 will use to construct a delta-gamma hedge, and you will have done it with every number recomputed in Python in front of you, because this branch is the single highest AI-over-trust risk area in the whole corpus. A pricing engine, an implied-vol solver, a Greeks calculator, an AI tool will write all three for you in seconds, fluently, confidently, and it will occasionally get a sign wrong in exactly the way that silently inverts your hedge. The by-hand tree and the closed-form formula are not a history lesson; they are the only reconciliation target that catches that error before it costs money. Verification here is not optional, and by the end of this module you will know precisely what "verified" means: every price, every Greek, and every arbitrage profit below was computed twice (once symbolically, once by finite difference or by an independent method) and the two were required to agree before the number was allowed into this document.

Learning objectives

By the end you can:

1. State put-call parity precisely (for a non-dividend-paying underlying and, extended, for one paying a continuous yield or a known discrete dividend), derive it from a static replication argument, and, given a set of quoted option prices, detect a violation, name the correct arbitrage (conversion or reversal), and compute the riskless profit, per unit and scaled to a real contract (a Nifty lot, an SPX multiplier).
2. Build an n-step binomial tree from scratch: derive the CRR up/down factors and the risk-neutral probability from no-arbitrage, price a European option by full backward induction with every node's stock price and option value shown, and extend the same tree to an American option by checking early exercise at every node.
3. State exactly when early exercise is (and is not) optimal, never for an American call on a non-dividend stock; sometimes for an American call on a dividend payer just before an ex-dividend date; sometimes for an American put even with no dividends, when sufficiently in the money, and prove each claim with a tree, not an assertion.
4. Show numerically that the binomial model converges to Black-Scholes-Merton as the number of steps grows, and explain why (BSM is the continuous-time limit of the same risk-neutral argument).
5. State the BSM formula for a European call and put, compute d1 and d2 from scratch, and list every assumption the formula makes (constant volatility, GBM/lognormal prices, constant risk-free rate, frictionless continuous trading, European exercise, a known dividend treatment), and name, for each one, a concrete way it fails in real markets.
6. Compute and interpret all five Greeks (delta, gamma, vega, theta, rho) from the closed-form BSM formulas, cross-check every one by finite difference (bump-and-reprice), and state the economic meaning of each in plain language and in real currency terms (per lot, per contract).
7. Use the Greeks to explain a realized option P&L via a Taylor-series decomposition, and show (numerically) that the decomposition is a good approximation for a small move and a visibly worse one for a large move, and explain why (the very reason DV1.03 needs gamma-hedging, not just delta-hedging).
8. Carry India (₹, Nifty/Bank Nifty-style index options) and US ($, SPX-style index options) worked examples side by side throughout, each grounded in real, dated, cited contract facts (lot size, multiplier, exercise style, risk-free proxy) with clearly labeled synthetic/illustrative pricing inputs.
9. (R10 duality.) Use an AI coding assistant to build a pricer or Greeks engine fast, and reconcile every one of its outputs against your own by-hand tree, parity check, or closed-form derivative before trusting it with a single rupee or dollar of risk.

Prerequisites & connections

Builds on. DV1.01 (Forwards, Futures & Swaps (Pricing & Valuation) established the whole branch's central method) risk-neutral, no-arbitrage pricing via cost-of-carry, for instruments with linear, unconditional payoffs. This module is where that method meets optionality: a payoff that bends at the strike, so the tidy single-formula replication of a forward gives way to a tree of possibilities that must be walked backward one node at a time. If DV1.01's cost-of-carry argument ("price it so nobody can lock in a free profit") felt mechanical, you already have the right instinct for everything below. M1.09 (Equity, SBC & Consolidation) introduced options only as an accounting object, grant-date fair value from "a Black-Scholes or lattice model," the fair-value hierarchy, and hedge-accounting's fair-value/cash-flow/net-investment buckets; this module is deliberately the other half of that story: it never re-teaches the accounting, and instead builds the pricing engine that produces the number M1.09 told you to trust. M9.01 (Risk & Position Sizing) gave you the practitioner definition of risk (probability × magnitude of permanent impairment) and M3.02 (Risk, Return & the ERP) gave you the academic one (variance, beta, CAPM), this module does not re-derive either; it hands you a new, sharper vocabulary (delta, gamma, vega) for describing a specific kind of risk, the convex risk of an optionality position, that neither of those frameworks was built to quantify. A working comfort with the normal distribution (density and cumulative probability) from ordinary statistics is assumed; QM1.01 (Probability, Distributions, Sampling & Estimation) formalizes the lognormal/normal machinery this module leans on, if you want the fuller treatment.

Feeds forward. DV1.03 (Option Strategies & Hedging Exposures), the branch's crown, takes every Greek you compute here and turns it into a position: spreads, straddles, collars, and delta/delta-gamma hedges are all built from the exact numbers this module teaches you to compute and interpret, you cannot delta-hedge a book without a delta, and you cannot know when to rebalance without a gamma. FI1.04 (Embedded Options, OAS & Structured Products) applies the identical binomial-tree machinery from §2 of this module to a callable bond's interest-rate tree instead of an equity-price tree, same backward induction, same early-exercise check, different state variable. AL1.03 (Digital Assets & Crypto) and several Alternatives modules will describe "convexity" and "optionality" informally; this module is where those words get an exact, computable meaning.

The one-sentence version of this module. An option's price is whatever a portfolio of the underlying and cash would cost to exactly replicate its payoff, checked once, statically, by put-call parity; checked at every node, working backward from expiry, by a binomial tree; and checked in the continuous-time limit by the closed-form Black-Scholes-Merton formula, and the five Greeks are simply the sensitivities of that price to the five things that can move (spot, volatility, time, and rates, split across calls and puts), which is why every number in this module was computed twice, by two independent methods, before it was allowed to appear once.

Core teaching content

Market anchors used in this module: read this once

Before any arithmetic starts, separate what is real and cited from what is constructed for the exercise, exactly as this branch's law (R3) requires: every number below is either traceable to a named primary source, or explicitly labeled synthetic/illustrative. Read this block once; every worked example after it inherits these conventions without repeating them.

Real, dated, cited facts (perishable, check the current specs before relying on any of them for a live decision):

• SPX index options: $100 contract multiplier, European-style exercise, cash-settled (Cboe SPX Index Options product specifications and fact sheet, cboe.com, as of 2026-07).
• Nifty 50 index options: lot size 65 (revised down from 75, effective for monthly contracts from the January 2026 expiry cycle onward: NSE circular FAOP70616, nsearchives.nseindia.com). A lot size is set by the exchange and revised by circular, so it is perishable by construction: read it off the NSE contract-specification page on the day you size anything, and expect the figure in any book, this one included, to be one revision behind. DV1.03 keeps 75 in its worked examples for arithmetic continuity with the tables built before the revision, and says so; the two modules use the same rule and different vintages of the same number.
• NSE exercise style and settlement: index options (Nifty, Bank Nifty) are European-style and cash-settled. Single-stock options are also European-style, but they are physically settled: NSE moved the entire single-stock derivatives segment to compulsory delivery settlement from the October 2019 expiry, so an in-the-money stock option that survives to expiry becomes an obligation to deliver or receive shares. DV1.03 §13 carries the consequences (delivery margins, full-contract-value obligation, the do-not-exercise facility) and DV1.05 owns the margin and expiry mechanics in full.
• US risk-free proxy used below: 3.65%, close to the midpoint of the Federal Reserve's 3.50%–3.75% federal funds target range, set at the 10 December 2025 FOMC meeting and held at the 17 June 2026 meeting (federalreserve.gov press releases); the FOMC raised it to 3.75%–4.00% on 16 September 2026, so refresh the proxy before reuse.
• India risk-free proxy used below: 5.25%, the RBI repo rate as held at the Monetary Policy Committee's June 2026 review, its third consecutive hold (raised to 5.50% on 7 October 2026; refresh the proxy before reuse). A live desk would instead read the FBIL Treasury-bill/MIBOR/OIS curve (FI1.03's territory, one level more precise); the repo rate is a defensible teaching proxy for a short-dated option.

Explicitly synthetic / illustrative (constructed for clean arithmetic, never a live quote, never to be traced to an exchange):

• Nifty 50 and S&P 500 index levels used below (≈24,800 and ≈7,400 respectively) are illustrative, chosen in the real neighborhood of each index around mid-2026 for realism, by the time you read this they are stale. Look up the live level before pricing anything for real money.
• Every option premium, implied volatility, and named single-stock entity below ("Konkan Alloys Ltd," "Beacon Materials Inc") is synthetic, constructed so the arithmetic is clean and the lesson is visible. None of it is a quote from any exchange.

A fast refresher, not a re-teach

You already know what a call and a put are; this is a two-sentence anchor, not a lesson. A call gives its holder the right, not the obligation, to buy the underlying at a fixed strike price K on or before expiry T; a put gives the right to sell at K. European exercise means only at expiry; American means any time up to and including expiry (both Nifty/Bank Nifty and SPX index options are European, which is exactly why this module's binomial trees earn their keep on equities, where American exercise is common). An option's premium splits into intrinsic value (what it would be worth if exercised right now (max(S-K, 0) for a call) and time value (everything else) the value of the optionality itself, which decays to zero at expiry). Moneyness describes where the strike sits relative to the spot: in-the-money (ITM, positive intrinsic value), at-the-money (ATM, S ≈ K), out-of-the-money (OTM, zero intrinsic value, pure time value). Hold those five ideas; everything below is about how the time value gets priced, not what these words mean.

Modern Data Analysis: the vectorized, at-scale version of this module

Everything above was deliberately built with plain loops and the math module so you can trace every step by hand. The moment you need a full options chain (every strike, every expiry, refreshed every few seconds) rather than one option, the honest tool is numpy/pandas, vectorizing every formula above across an entire array of strikes at once (d1 = (np.log(S/K_array) + ...) / (sigma*np.sqrt(T)), computed for a thousand strikes in one call, no Python-level loop at all), plus scipy.stats.norm.cdf in place of the hand-rolled math.erf wrapper once you no longer need the stdlib-only constraint, and a proper root-finder (scipy.optimize.brentq) for implied volatility instead of the bisection loop this module writes out by hand. That full build, vectorized Greeks across a live chain, an implied-vol surface fit across strikes and maturities, a backtest of a hedging rule over history, is exactly the quant-code region's territory (the DA/QD branches): this module hands off the moment the by-hand mechanism is genuinely understood, not before. Building the vectorized version without first tracing one option by hand through a tree and a closed form, the way you just did, is exactly how a sign error or a units mistake survives silently inside a script that "runs fine" and returns a plausible-looking, wrong number for every single row of a chain at once.

Common mistakes & how experts think differently

1. "Put-call parity is a classroom curiosity, real markets don't leave arbitrage lying around." True that liquid index-option arbitrage is thin and fast, but that is precisely because market makers run the parity check continuously and trade violations away in seconds, parity is not obsolete, it is enforced so efficiently that you rarely see it violated in a liquid name. The expert's use of parity is not "look for free money" (rare, and thinner than it looks once frictions are included); it is a standing internal-consistency check: any quoted call/put/forward triple that fails parity by more than the bid-ask spread is either a data error or a genuine, fleeting opportunity, and either way it demands investigation before anything else is trusted.
2. "Delta is the probability the option finishes in the money." A widely repeated shortcut that is only approximately true. The BSM formula's N(d2) is the actual risk-neutral probability of finishing in the money; delta is N(d1) (for a call), a related but distinct quantity that also weights by how much the payoff is in the money, not merely whether. The two converge only when volatility is low and time is short. Experts use delta as a hedge ratio first and a probability proxy a distant second, and never confuse the two out loud in front of a risk committee.
3. "The binomial model and Black-Scholes might legitimately disagree, they're different models." They are the same model at two different resolutions. A binomial price that has not converged to the BSM price as steps increase means either too few steps, or a bug (a wrong u/d/p, a discounting error), never a legitimate difference of opinion between "two schools of pricing." Worked Example 5 exists specifically to burn in what convergence actually looks like, oscillation and all, so a genuine disagreement is instantly recognizable as a red flag.
4. "An American option should always be exercised early if it's deep in the money." Deep-in-the-money is necessary but not sufficient, and the type of option matters enormously: it is never optimal to exercise an American call early on a non-dividend stock (Practice P5 proves this), it can be optimal for a call just ahead of a large dividend (Practice P5b), and it can be optimal for a put with no dividend at all, purely from the time-value-of-money benefit of receiving the strike sooner (Worked Example 4). "Deep ITM, so exercise" skips the actual decision, which is always continuation value versus intrinsic value, checked node by node.
5. "I'm delta-hedged, so I'm not exposed to this position anymore." Delta-hedging protects against a small move in the underlying, evaluated at a single instant. The moment the underlying moves by more than a small amount, your delta itself has changed (that is what gamma measures), and the hedge you set is already stale. Worked Example 8 shows the Taylor-decomposition residual growing from under half a percent on a modest one-day move to over seven percent on a larger, multi-day move, the exact reason DV1.03 teaches delta-gamma hedging and periodic rebalancing, not "set delta to zero once and walk away."
6. "Vega only matters to options traders, a fundamentals-driven investor can ignore it." Any position with convexity, a long option, a callable bond (FI1.04), certain structured notes, carries an implicit view on volatility whether or not anyone intended to take one. Refusing to look at vega does not make the exposure zero; it makes it unmeasured, which is worse.
7. "Implied volatility is the market's forecast of future volatility." Implied vol is the volatility number that makes BSM reproduce today's quoted price, it reflects supply and demand for optionality (hedging flows, crash-insurance demand, positioning) as much as any statistical forecast of how much the underlying will actually move. Treating it as a clean forecast is a category error; treating it as "the current price of insurance, quoted in vol units" is closer to correct.
8. "One flat volatility number describes the whole option market on a given underlying." Worked Example 6 falsifies this directly: three strikes on the same underlying and expiry, each carrying a different implied volatility, is not a data glitch, it is the skew, a real, persistent, daily-observable feature of every liquid options market since 1987. A single BSM run calibrated to one strike will misprice every other strike on the same chain.
9. "Use the fanciest tool available, always, or conversely, force the closed-form formula onto everything for speed." Neither instinct is the skill. The actual skill is matching the tool to the contract: BSM where European exercise and a known dividend treatment genuinely hold; the binomial tree (or another numerical method) the instant early exercise, a discrete dividend, or path-dependency enters the picture. Reaching for either tool out of habit, rather than checking which assumptions the specific contract in front of you satisfies, is exactly the shortcut an AI-generated pricer will happily take unless you tell it otherwise, another reason the verification habit in this module is not optional.

Worked examples

Worked example 1: Put-call parity and a reversal arbitrage, Nifty 50 index options (India, ₹)

A Nifty 50 index option desk is quoting 30-day options at spot S = ₹24,800, strike K = ₹25,000 (a level that has recently acted as real resistance for the index), India risk-free proxy r = 5.25%, and an illustrative dividend yield q = 1.2%. The quoted call premium is ₹285 and the quoted put premium is ₹460 (both illustrative quotes for this exercise). Does parity hold, and if not, what is the riskless profit?

Solution. Step 1, compute the fair put from parity. With T = 30/365 = 0.082192 years: S·e^(−qT) = 24,800·e^(−0.012×0.082192) = ₹24,775.5518, and K·e^(−rT) = 25,000·e^(−0.0525×0.082192) = ₹24,892.3557. Fair put = C − S·e^(−qT) + K·e^(−rT) = 285 − 24,775.5518 + 24,892.3557 = ₹401.8039.

Step 2, compare to the quote and name the direction. The quoted put, ₹460, is ₹58.1961 richer than fair. Check the direction algebraically rather than by feel: C − P = 285 − 460 = −175, while the parity right-hand side is 24,775.5518 − 24,892.3557 = −116.8039. Since −175 < −116.8039, the call is cheap (or the put is rich) relative to parity, the textbook signal for a reversal: short the underlying, buy the call, sell the put.

Step 3, build the exact arbitrage, handling the dividend yield correctly. Because Nifty pays dividends continuously (the index's constituents pay year-round), shorting a naive "1 unit" of the index and holding it for T understates the dividend leakage you would owe as the short-seller. The exact fix, the same trick that puts S·e^(−qT) into the parity formula in the first place, is to short e^(−qT) = 0.999014 units of the index today, not one full unit: continuously-reinvested dividends then grow that short obligation to exactly one unit by T (e^(−qT)·e^{qT} = 1), with no separate approximation needed. Cash raised today: S·e^(−qT) − C + P = 24,775.5518 − 285 + 460 = ₹24,950.5518. Invest this at r to T: 24,950.5518 × e^(0.0525×0.082192) = ₹25,058.4477. At T, whatever S_T turns out to be, the long call/short put pair forces you to pay exactly K = ₹25,000 to acquire one unit and close the now-one-unit short.

Step 4, the riskless profit. 25,058.4477 − 25,000 = ₹58.4477 per unit of the index, and this number is not an approximation: it reconciles exactly, to full floating-point precision, with the mispricing grown at the risk-free rate (58.1961 × e^{0.0525×0.082192} = 58.4477), confirmed in Python with an assertion that the two must match to within 1e-8. Scaled to a real Nifty lot (65 units, per the lot-size fact cited above): ₹3,799.10 riskless profit per lot, before transaction costs, bid-ask spread, and margin, frictions large enough, in a genuinely liquid index, to erase most or all of a mispricing this size in practice, which is exactly why you check parity as a standing discipline, not a treasure hunt.

Worked example 2: Put-call parity with a discrete dividend, a conversion arbitrage (US, $)

Beacon Materials Inc (synthetic, US, $) trades at S = $100. It pays one known dividend of $1.00 in two months (t = 2/12 years). A 6-month (T = 0.5) option at strike K = $100 is quoted: call $6.55, put $5.55. The US risk-free proxy is r = 3.65%. Is there an arbitrage?

Solution. Step 1, strip the dividend's present value out of the stock price. PV(dividend) = 1.00 × e^(−0.0365×0.1667) = $0.9939. Parity for a discrete-dividend payer replaces S with S − PV(dividends) = 100 − 0.9939 = $99.0061.

Step 2, the fair put. Fair put = C − (S − PV(div)) + K·e^(−rT) = 6.55 − 99.0061 + 100×e^(−0.0365×0.5) = 6.55 − 99.0061 + 98.1916 = $5.7355. The quoted put, $5.55, is $0.1855 cheaper than fair, the signal for a conversion: buy the stock, buy the put, sell the call.

Step 3, build the package and read off its implied rate. Buying the stock net of the dividend you will collect, buying the put, and selling the call costs (100 − 0.9939) + 5.55 − 6.55 = $98.0061 today, and, because a protective put plus a short call locks the payoff at exactly K regardless of S_T, this package guarantees exactly $100 at T, no matter what the stock does. A package that turns $98.0061 into a guaranteed $100 in six months has an implied rate of ln(100/98.0061)/0.5 = 4.0282%, a full 0.3782 percentage points above the true financing rate of 3.65%, you are buying a riskless payoff cheaper than the riskless rate justifies.

Step 4, the riskless profit. 100 − 98.0061×e^(0.0365×0.5) = 100 − 99.8111 = $0.1889 per share, and, as in Worked Example 1, this reconciles exactly with the raw mispricing grown at r (0.1855 × e^{0.0365×0.5} = 0.1889). Small per share, as textbook single-stock parity violations usually are once real dividends and financing are handled correctly, but the mechanism, and the discipline of checking it, is identical whether the number is $0.19 or $190.

Worked example 3: Two-step binomial tree, node by node, European call (India, ₹)

Konkan Alloys Ltd (synthetic, India, ₹) trades at S₀ = ₹100. Price a European call, K = ₹100, using a 2-step CRR tree over one year (r = 6%, σ = 28.28%, Δt = 0.5).

Solution. Step 1, the tree parameters. u = e^(0.2828×√0.5) = 1.221403, d = 1/u = 0.818731, p = (e^(0.06×0.5) − d)/(u − d) = (1.030455 − 0.818731)/(1.221403 − 0.818731) = 0.525797, per-step discount e^(−0.06×0.5) = 0.970446.

Step 2, every terminal node. S_uu = 100×1.221403² = ₹149.1825 (payoff ₹49.1825); S_ud = 100×1.221403×0.818731 = ₹100.0000 (payoff ₹0, exactly at the strike); S_dd = 100×0.818731² = ₹67.0320 (payoff ₹0).

Step 3: backward induction, one step. Up-node value: e^(−0.06×0.5)×[0.525797×49.1825 + 0.474203×0] = 0.970446×25.8613 = ₹25.0957. Down-node value: both its children pay zero, so its value is ₹0.0000.

Step 4: back to today. V₀ = 0.970446×[0.525797×25.0957 + 0.474203×0] = ₹12.8053. Two-step binomial call price = ₹12.8053. For reference (and to preview Worked Example 5), the same inputs priced by the closed-form BSM formula give ₹14.0736, a visible gap at only two steps, which the convergence table below closes almost entirely by n = 200.

Worked example 4: American put, n-step binomial with early exercise (US, $)

Beacon Materials Inc (synthetic, US, $), no dividend, S₀ = $100, strike K = $120 (deep in the money for a put), r = 8%, σ = 30%, T = 1 year, priced on a 4-step tree. Where, if anywhere, is early exercise optimal?

Solution. Step 1: tree parameters. Δt = 0.25, u = e^(0.30×√0.25) = 1.161834, d = 0.860708, p = 0.529656, per-step discount 0.980199.

Step 2, the full tree (S, option value), computed with the early-exercise check active at every node (step 4 is terminal; steps 0–3 compare continuation against max(K−S,0) and keep the larger):

Step 3: find where exercise beats holding. At step 3, node S = 86.07: intrinsic = 120 − 86.07 = 33.93; continuation (discounted expected value of the step-4 children) = 31.55. Intrinsic wins: exercise now. The same comparison flags three more nodes: step 3's S = 63.76 (intrinsic 56.24 vs. continuation 53.86), step 2's S = 74.08 (intrinsic 45.92 vs. continuation 43.54), and step 1's S = 86.07 (intrinsic 33.93 vs. continuation 31.78), every flagged node is deep in the money, exactly where the time-value-of-money benefit of collecting the strike sooner outweighs the option's remaining optionality.

Step 4: quantify the early-exercise premium. The American price is $21.6780; the European price on the identical tree (same u, d, p, no early-exercise check) is $19.1608. Early-exercise premium = $2.5172, real value that a European-style pricer (or a BSM formula, which cannot represent early exercise at all) would silently miss on this contract. Note this is a put with no dividend: the standard theorem that "an American call on a non-dividend stock is never exercised early" (proved cleanly in Practice P5) has no equivalent for puts, a deep enough in-the-money put can be worth more dead than alive even with zero dividends, purely from the interest you earn by collecting K now instead of at T.

Worked example 5: Binomial converges to Black-Scholes-Merton, Nifty 50 index option (India, ₹)

Using the same Nifty parameters as Worked Example 1's underlying market (S = 24,800, K = 25,000, r = 5.25%, q = 1.2%), but now with an explicit implied vol σ = 13% and T = 0.25 years (a 3-month option), show that the binomial tree converges to the BSM price as the step count grows.

Solution. BSM closed-form call price: ₹666.5637. Price the same contract on a CRR tree at increasing step counts:

Read the table carefully, it is not perfectly monotonic, and that is a real, well-documented feature of the CRR tree, not an error. The error oscillates as n grows (notice n=50's error is larger than n=25's) because odd and even step counts place the tree's central node at slightly different relative positions to the strike; practitioners routinely average adjacent step counts or use a smoother tree variant to remove the oscillation. What is unambiguous is the envelope: by n = 200 the error is two hundredths of a percent, and it is this convergence, not any assumption you have to take on faith, that licenses using the closed-form BSM formula as a fast, exact stand-in for "a binomial tree with infinitely many, infinitesimally small steps" whenever European exercise is all you need.

Worked example 6: The volatility skew: implied vol differs by strike (US, $)

An SPX-like desk quotes 30-day puts at three strikes around S = $7,400, r = 3.65%, q = 1.3%. Show that a single, flat BSM volatility cannot explain all three prices at once, and recover each strike's implied volatility.

Solution. Step 1, construct a market that is honestly skewed. To demonstrate the skew rigorously rather than asserting it, price each strike at its own assumed volatility, exactly what a real, skewed market does, using the BSM formula: K = 7,100 (a strike 4% below spot) at σ = 16.5% gives a put price of $33.3820; K = 7,250 (2% below spot) at σ = 14.5% gives $56.5139; K = 7,400 (at the money) at σ = 13.0% gives $102.8125. This "downside skew", lower strikes carrying higher implied vol, is the standard shape for equity index options since the 1987 crash: it reflects persistent demand for crash insurance (cheap, deep OTM puts), not necessarily a forecast of more downside than upside.

Step 2, pretend you only see the prices, as a market-maker would, and solve backward. Using a bisection root-finder on the BSM formula (search for the σ that reprices each quote exactly), the recovered implied vols are 16.50%, 14.50%, and 13.00%, recovering the assumed skew exactly, which both confirms the root-finder is correctly implemented and demonstrates the point: one option chain, one expiry, three strikes, three different implied volatilities. A single BSM run using one flat σ (say, the ATM 13.00%) prices the K = 7,100 put at $16.3324 against its skew-consistent $33.3820, an error of $17.05, more than half the option's value; at K = 7,250 the same flat run gives $45.8512 against $56.5139, an error of $10.66. Both errors misread real market structure as a data error, rather than the single most persistent stylized fact in the entire options market.

Worked example 7: The full Greeks table, closed form vs. finite difference, Nifty 50 (India, ₹)

Compute and interpret every Greek for the same option as Worked Example 5 (S=24,800, K=25,000, r=5.25%, q=1.2%, σ=13%, T=0.25), and verify each one against an independent finite-difference cross-check and against the Greek-parity identities.

Solution. Step 1, the base prices and d1/d2. Call = ₹666.5637, Put = ₹614.8711; d1 = 0.064697, d2 = −0.000303.

Step 2, every Greek, closed form.

Every closed-form Greek matches its finite-difference cross-check (bump S by ₹1 for delta/gamma, bump σ by 1 basis point for vega, bump T by 1/365 for theta, bump r by 1 basis point for rho, reprice with the identical BSM function, take the central difference) to at least four significant figures, the small residual is ordinary finite-difference truncation error, not a modeling disagreement.

Step 3, the Greek-parity identities, verified. Delta_call − Delta_put = 0.524218 − (−0.472787) = 0.997005, matching e^(−qT) = e^(−0.012×0.25) = 0.997004 (rounding). Gamma is identical for call and put by construction (0.00024623 both). Rho_call − Rho_put = 3,083.5076 − (−3,084.9971) = 6,168.5047, matching K·T·e^(−rT) = 25,000×0.25×e^(−0.0525×0.25) = 6,168.5047 exactly. Theta_call − Theta_put = −1,771.1856 − (−772.5082) = −998.6775, matching q·S·e^(−qT) − r·K·e^(−rT) = 296.7 − 1,295.4 ≈ −998.6775 exactly. All four identities fall directly out of differentiating put-call parity itself, they must hold for any correctly built pricer, independent of whether BSM's assumptions are even realistic, which is exactly why they make such a powerful bug-catcher.

Step 4, read the Greeks in real money, scaled to a lot. One Nifty lot (65 units): position delta = 0.524218×65 ≈ 34.07 index-unit-equivalents of exposure; position gamma ≈ 0.0160; position vega ≈ ₹3,199 per one-percentage-point move in implied vol; position theta ≈ −₹315 per day, the option loses about three hundred rupees a day from time decay alone, before the underlying or volatility move at all.

Worked example 8: Explaining a realized option P&L with the Greeks (US, $)

An SPX-like at-the-money call (S=K=7,400, r=3.65%, q=1.3%, σ=14%, T=0.25, price $227.6623, delta=0.545558, gamma=0.00076225, vega=1,460.9286, theta=−495.6229/yr) is repriced after two different moves. Does the Greek-based Taylor decomposition (ΔV ≈ Δ·ΔS + ½Γ·ΔS² + vega·Δσ + θ·Δt) explain the actual repriced change?

Solution. Move 1: small, one day. S rises $15, implied vol falls 0.2 points, one calendar day passes. Actual repriced call = $231.6666; actual P&L = $4.0043. Taylor terms: delta×15 = 8.1834, ½×gamma×15² = 0.0858, vega×(−0.002) = −2.9219, theta×(1/365) = −1.3579; Taylor total = $3.9894. Residual = 4.0043 − 3.9894 = $0.0149, 0.37% of the actual move, the linear-plus-curvature approximation is excellent for a small move.

Move 2: larger, five days. S rises $200, implied vol falls 3 points, five calendar days pass. Actual repriced call = $307.1888; actual P&L = $79.5265. Taylor terms: delta×200 = 109.1116, ½×gamma×200² = 15.2450, vega×(−0.03) = −43.8279, theta×(5/365) = −6.7894; Taylor total = $73.7394. Residual = 79.5265 − 73.7394 = $5.7871, 7.28% of the actual move, over nineteen times larger a fraction than Move 1's.

Read it. The Greeks are a local, second-order approximation, built from derivatives evaluated at a single starting point. A small move stays close enough to that point that the approximation barely notices the curvature it's missing (cross-terms like "how does delta itself shift with volatility," which none of the four terms above captures). A larger move travels far enough that those missing higher-order and cross terms start to matter, visibly, measurably, in Python, not as a hand-wave. This is not a flaw in the Greeks; it is the precise, quantified reason a delta-hedged, or even delta-gamma-hedged, book still needs periodic rebalancing and cannot be "set and forgotten", exactly the discipline DV1.03 builds into an actual hedging program.

Worked example 9: Put-call-forward parity and the implied forward, Nifty 50 (India, ₹)

The Nifty 50 is at S = 24,800, r = 5.25%, dividend yield q = 1.20%, and you are looking at the three-month (T = 0.25) chain. The 25,000-strike call is quoted at ₹666.56 and the put at ₹614.87. Price the forward, verify both forms of parity, and then reverse the calculation to read the dividend yield the option market is pricing.

Solution. Step 1, the forward. F₀ = 24,800 × e^((0.0525 − 0.012) × 0.25) = 24,800 × e^(0.010125) = 25,052.3755.

Step 2, the forward form of parity. (F₀ − K)·e^(−rT) = (25,052.3755 − 25,000) × e^(−0.0525×0.25) = 52.3755 × 0.986961 = ₹51.6926.

Step 3, the spot form, as an independent route. S·e^(−qT) − K·e^(−rT) = 24,800 × e^(−0.012×0.25) − 25,000 × e^(−0.0525×0.25) = 24,725.7115 − 24,674.0189 = ₹51.6926. The two forms agree to the fourth decimal, as they must, since one is the other after a substitution.

Step 4, the quoted pair. C − P = 666.5637 − 614.8711 = ₹51.6926. Parity holds, so the pair is priced consistently with the forward and there is no arbitrage in these three quotes.

Step 5, reverse it, which is the version you will actually use. Suppose you did not trust the published dividend yield. Read the forward out of the option pair: F₀ = K + (C − P)·e^(rT) = 25,000 + 51.6926 × e^(0.0525×0.25) = 25,052.3755. Then solve F₀ = S·e^((r−q)T) for q: q = r − ln(F₀/S)/T = 0.0525 − ln(25,052.3755/24,800)/0.25 = 0.0525 − 0.010125/0.25 = 1.2000%. The option market's implied dividend yield is 1.20%, recovering the input exactly.

Step 6, what a violation would look like. If the call were quoted ₹5.00 rich at ₹671.5637 with the put unchanged, C − P becomes ₹56.6926 and the implied forward becomes 25,000 + 56.6926 × e^(0.0525×0.25) = 25,057.4416, which is 5.0661 index points above the fair 25,052.3755. The riskless trade is to sell the synthetic forward (sell the call, buy the put) and buy the index forward at the fair rate, locking 5.0661 index points at expiry. Discounted, that is 5.0661 × 0.986961 = ₹5.0000 per unit today, exactly the mispricing you were handed, which is the check that the trade captures the error and nothing else.

Read it. The implied dividend yield in Step 5 is the most useful by-product of this identity and the reason desks compute it daily. It is also the honest limit of the exercise: the number recovered is the market's dividend expectation net of any borrow cost and any tax friction on the dividend, not a forecast of declared dividends. On a single stock with a hard-to-borrow name, the same calculation will return a dividend yield that is obviously too high, and the excess is the borrow cost, not the dividend. Nothing in the arithmetic can separate the two, and any model that claims to has assumed the answer.

Practice set

Work every problem before reading its solution. A calculator (or five lines of Python) is assumed; every numeric answer below was produced by, and matches, the module's verification script.

P1 (guided). One-step binomial call. A stock at S=100 can rise to u=1.2×S or fall to d=(1/1.2)×S over one year; K=100, r=5%. Price a European call.

Solution. p = (e^(0.05×1) − 0.8333)/(1.2 − 0.8333) = (1.0513 − 0.8333)/0.3667 = 0.594376. Terminal payoffs: up = max(120−100,0)=20, down = max(83.33−100,0)=0. Price = e^(−0.05)×(0.594376×20 + 0.405624×0) = 0.9512×11.8875 = ₹11.3078.

P2 (guided). Parity, solve for the put, no dividend. C=4.20, S=50, K=48, r=4%, T=0.5. Find the fair put.

Solution. P = C − S + K·e^(−rT) = 4.20 − 50 + 48×e^(−0.04×0.5) = 4.20 − 50 + 47.0495 = $1.2495.

P3. Parity with a dividend yield: detect the mispricing. C=6.00, P=5.00, S=100, K=100, r=5%, q=2%, T=0.5. Does parity hold? If not, which side is mispriced?

Solution. C−P = 1.00. Parity right-hand side = S·e^(−qT) − K·e^(−rT) = 100×e^(−0.01) − 100×e^(−0.025) = 99.0050 − 97.5310 = 1.4740. Since 1.00 < 1.4740, the call is cheap (or the put is rich) relative to parity by 0.4740, the reversal signal (short stock, buy call, sell put), exactly as in Worked Example 1.

P4. Two-step binomial European put. S=50, K=52, r=5%, σ=25%, T=1, 2 steps.

Solution. u=1.193365, d=0.837967, p=0.527151. Terminal payoffs: S_uu=71.21→0, S_ud=50.00→2.00, S_dd=35.11→16.89. Up-node =e^(−0.025)×(0.527151×0 + 0.472849×2.00)=0.9753×0.9457=0.9223. Down-node =0.9753×(0.527151×2.00+0.472849×16.89)=0.9753×(1.0543+7.9866)=0.9753×9.0409=8.8178. Today =0.9753×(0.527151×0.9223+0.472849×8.8178)=0.9753×(0.4863+4.1697)=0.9753×4.6560=₹4.5407.

P5. American call, no dividend, prove early exercise is never optimal. S=100, K=90, r=6%, σ=25%, T=1, 4 steps. Compare the American and European prices.

Solution. Both price at exactly $19.122989, the American and European values are identical to six decimal places, with zero nodes flagged for early exercise. This is the textbook theorem in action: an American call on a non-dividend-paying stock is never optimally exercised early, because exercising forfeits the remaining time value and pays the strike early for no benefit (there is no dividend being missed, and money is worth more later paid than earlier paid when you're the one paying it). Holding to expiry, or selling the option outright, always dominates.

P5b. The same call, now with an 8% dividend yield. Same S, K, r, σ, T, q=8%. Does early exercise ever pay?

Solution. American price $14.189082 vs. European $13.532771, a real early-exercise premium of $0.6563. Three nodes flag exercise, all late in the tree and all deep in the money (e.g., step 3, S=$145.50: intrinsic $55.50 vs. continuation $53.96). The mechanism: exercising just before value would otherwise be siphoned off by a dividend captures that dividend for the option holder; without the dividend (P5) there is nothing to capture, and early exercise never pays for a call.

P6. A single node's exercise decision. At one node of an American put tree, S=70, K=90, and the computed continuation value is 19.00. Exercise or hold?

Solution. Intrinsic = K − S = 90 − 70 = 20.00. Since 20.00 > 19.00, exercise, immediate intrinsic value beats holding for the (already-discounted) expected future payoff.

P7. Terminal nodes of a 3-step tree. S₀=100, u=1.1, d=1/1.1. List all four terminal prices.

Solution. j=0: 100×1.1³ = 133.10; j=1: 100×1.1²×0.9091 = 110.00; j=2: 100×1.1×0.9091² = 90.91; j=3: 100×0.9091³ = 75.13 (j = number of down-moves).

P8. BSM call price from scratch. S=100, K=105, r=5%, q=0%, σ=22%, T=0.5. Compute d1, d2, and the call price.

Solution. d1 = [ln(100/105) + (0.05+0.5×0.22²)×0.5] / (0.22×√0.5) = [−0.04879 + 0.03710] / 0.15556 = −0.075147. d2 = d1 − 0.22×√0.5 = −0.075147 − 0.15556 = −0.230711. N(d1)=0.470049, N(d2)=0.408770. Call = 100×0.470049 − 105×e^(−0.025)×0.408770 = 47.0049 − 102.4075×0.408770 = 47.0049 − 41.8611 = $5.1438.

P9. Cross-check P8's put via parity. Using the same inputs, compute the BSM put and confirm parity holds exactly.

Solution. Put = $7.5513. C − P = 5.1438 − 7.5513 = −2.4075. Parity right-hand side = S·e^(−qT) − K·e^(−rT) = 100 − 102.4075 = −2.4075, equal to the left-hand side to the last printed digit. A BSM-priced call and put satisfy their own model's parity identity to machine precision by construction, which is itself a useful sanity check on any pricer: if a call and put you computed don't satisfy parity, the bug is in your code, not the market. Note the discount factor 105×e^(−0.025) = 102.4075, not 102.37; carrying the rounded version through P8 would have broken this check for no reason other than arithmetic sloppiness.

P10. Delta as a P&L estimate for a $1 move. Using P8's option (delta=0.470049), estimate the P&L from a $1 rise in the stock, then compare to the actual repriced value.

Solution. Delta-only estimate: $0.4700. Actual repriced P&L (full BSM reprice at S=101): $0.4828. The $0.0128 gap is almost exactly ½×gamma×1² = ½×0.025573 = $0.0128, the curvature term delta alone misses, and gamma alone explains.

P11. Gamma, numeric. Using P8/P10's setup, state gamma and what it measures.

Solution. Gamma = 0.02557267. It is the rate at which delta itself changes per $1 move in the stock, the second derivative of price with respect to spot, and the reason a "set once" delta hedge decays as the underlying moves.

P12. Vega, and a one-point vol move. State vega for P8's option and the P&L from implied vol rising one percentage point.

Solution. Vega = $28.1299 per 100 vol points, so per 1 percentage point = $0.2813. A rise in implied vol from 22% to 23%, nothing else moving, adds about $0.28 to this call.

P13. Theta, per calendar day. State P8's theta and the daily cost of holding this call.

Solution. Theta = −$8.2816 per year = −$0.0227 per calendar day. Holding this call one more day, nothing else moving, costs about 2.3 cents.

P14. Rho, and a one-point rate move. State P8's rho and the P&L from a 1-percentage-point rate rise.

Solution. Rho = $20.9306 per 100 rate points, so per 1 percentage point = $0.2093. Rates rising from 5% to 6%, nothing else moving, adds about 21 cents to this call, small, but never zero, and larger for longer-dated options.

P15. Delta parity, no dividend case. Confirm Delta_call − Delta_put = e^(−qT) for P8's option, where q=0.

Solution. Delta_call − Delta_put = 0.470049 − (−0.529951) = 1.000000 = e^0, exactly, with no dividend, a call and a put on the same strike/expiry always have deltas exactly one apart.

P16. Solve for implied volatility. A call with S=100, K=100, r=5%, q=0%, T=0.5 is quoted at $8.50. Find the implied volatility (bisection, or any root-finder).

Solution. Implied vol = 25.8733%; repricing at that vol returns exactly $8.50, confirming the solver.

P17. Net delta/gamma of a mixed position, and the hedge. You are long 10 calls (delta 0.4700 each) and short 5 puts (delta −0.5300 each, same underlying). What is your net delta, and how would you delta-hedge with shares?

Solution. Net delta = 10×0.4700 − 5×(−0.5300) = 4.700 + 2.650 = 7.3502. Being short puts with negative delta adds positive delta to the book (shorting a negative-delta instrument is itself a long-delta position). To delta-neutralize, sell 7.3502 shares of the underlying, the position is net long-delta, so the hedge is a short-stock offset.

P18. Scale a Greek to a real contract. A Nifty call has delta=0.524218. State the position-level delta for one lot (65 units).

Solution. 0.524218 × 65 ≈ 34.07, one lot of this call behaves, for small moves, like being long about 34 units of the underlying index.

P19. Put-call-forward parity, and the synthetic forward. A non-dividend-paying stock trades at S = 100 with r = 4% and a three-month horizon (T = 0.25). The 102-strike call is quoted at $3.20. Compute the forward price, then use the forward form of parity to find the fair put, and state what the long-call/short-put pair is worth.

Solution. F₀ = 100 × e^(0.04×0.25) = 101.005017. Forward parity gives C − P = (F₀ − K)·e^(−rT) = (101.005017 − 102) × e^(−0.01) = −0.985083, so P = 3.20 + 0.985083 = $4.185083. The long-call/short-put pair costs C − P = −$0.985083, meaning you are paid 98.5 cents to hold a synthetic forward struck at 102, which is right, because 102 is above the fair forward of 101.005017 and you are agreeing to buy high. Cross-check on the spot form: S·e^(−qT) − K·e^(−rT) = 100 − 102 × e^(−0.01) = 100 − 100.985083 = −0.985083, the same number by an independent route.

Applied mini-project

Build, verify, and hedge-size a real option.

Choose one real, liquid, exchange-listed option, a Nifty/Bank Nifty index option or a listed single-stock option (India), or an SPX or a widely traded single-name option (US), with an observable bid/ask at a specific strike and expiry as of a date you name. If you cannot access a live quote, substitute one of this module's illustrative setups and say so explicitly; either path is acceptable, but never blend the two without labeling which numbers are real and which are synthetic.

Do this, in order:

1. Record the contract, cited. Underlying, strike, expiry, quoted bid/ask for both the call and the put at that strike, the exchange's stated lot size or multiplier, and the exercise style (European/American), traced to the exchange's own contract specification page, dated.
2. Build and reconcile three prices. By hand, on paper, build a 2-step binomial tree for the option (state your σ and r assumptions, cited or labeled illustrative). Separately, in Python (your own code or AI-assisted, per this module's ai-augment pattern), build an n≥200-step binomial price and a closed-form BSM price. Reconcile all three (the 2-step, the large-n, and the BSM) and explain any remaining gap in your own words.
3. Check put-call parity on the real quotes. Using the actual quoted call and put at the same strike/expiry, check whether parity holds within the bid-ask spread. State explicitly whether a genuine, tradable arbitrage exists once realistic frictions (spread, brokerage, margin) are included, and if it does not (the much more likely outcome in a liquid name), explain in your own words why the textbook arbitrage of Worked Examples 1–2 mostly evaporates once real costs enter.
4. Compute all five Greeks for your chosen option from the closed-form formulas, and cross-check at least delta and gamma by finite difference against your own pricer.
5. Size a hedge. If you held 10 lots/contracts of this option, how many units of the underlying would delta-neutralize the position right now? Using gamma, state qualitatively how much that hedge would need to move if the underlying moved 2%, and how often you would need to rebalance in a fast-moving market versus a quiet one.
6. Write a one-paragraph verification note stating, for every number in your writeup, whether it is traced to a named, dated primary source (the exchange's contract page, the quoted chain) or explicitly marked synthetic/illustrative.

Self-check rubric (10 points; pass at 8/10 with no zero on any item):

• 2 pts: the contract is fully specified and cited (or explicitly, consistently marked synthetic): underlying, strike, expiry, exercise style, lot/multiplier.
• 2 pts: the 2-step by-hand tree and the large-n/BSM Python cross-check are both shown and reconciled, with any gap explained rather than ignored.
• 2 pts: put-call parity is checked against the real quotes, with a clear verdict on whether a tradable arbitrage survives realistic frictions.
• 2 pts: all five Greeks are computed, with at least one verified by an independent finite-difference cross-check.
• 2 pts: the hedge is sized correctly (shares/units to delta-neutralize) and the gamma-driven rebalancing-frequency argument is stated in your own words.

Reading & resources

Everything below is an anchor to learn from and verify against, never a source to quote a price from; option prices are quoted live and go stale the instant they're written down.

Core texts (the anchor for this branch):

• John C. Hull, Options, Futures, and Other Derivatives, the anchor text for this entire module; its binomial and BSM chapters are the direct source for the machinery taught above. [Paid] [Core]
• Robert McDonald, Derivatives Markets: a strong alternative core text, particularly clear on the parity and binomial chapters. [Paid] [Core]
• Sheldon Natenberg, Option Volatility & Pricing: the practitioner's book on the volatility skew, implied vol, and how option desks actually think about Greeks day to day. [Paid] [Practitioner]
• Nassim Nicholas Taleb, Dynamic Hedging: an advanced, opinionated treatment of what happens to the Greeks when BSM's assumptions break under real hedging pressure. [Paid] [Advanced]
• CFA Institute Level I/II Derivatives curriculum readings, the direct CFA-aligned treatment of everything in this module. [Paid] [Core]

Free primary/institutional sources (contract specs, check the current specs before relying on any of them):

• Cboe's own SPX Index Options product specifications and fact sheet (cboe.com), the primary source for the SPX contract multiplier, exercise style, and settlement facts cited above. [Free] [Beginner–Intermediate]
• NSE's F&O circulars and product pages (nseindia.com, nsearchives.nseindia.com), the primary source for Nifty/Bank Nifty lot sizes, contract specs, and SEBI's exercise-style rules. [Free] [Beginner–Intermediate]
• SEBI's derivatives-market investor education material, plain-language grounding on India's options market structure. [Free] [Beginner]
• CME/CBOE education portals, options-payoff explainers and interactive tools, useful for building first intuition before the math. [Free] [Beginner]

Do this, not just read: run the crr_tree and bsm_price functions from this module verbatim, reprice one of the worked examples, and confirm your own output matches the figures printed here to the decimal. Then change one input (double the volatility, halve the time to expiry) and predict, before running it, which Greek moves the most and in which direction. Ten minutes of doing this will teach you more about the five Greeks' relative sizes than an hour of reading their definitions.

Teach it back & journal

Feynman prompt. Explain to a friend who has heard the phrase "options are priced with a complicated formula" why that framing undersells what is actually happening, using the sentence "an option is priced by figuring out what portfolio of the stock and cash would exactly replicate its payoff, and refusing to let it trade for anything else." Walk them through put-call parity as the simplest, static version of that idea, then the binomial tree as the same idea applied one step at a time, then say, in one sentence, why Black-Scholes-Merton is "the same tree with infinitely many, infinitesimally small steps" rather than a competing method. If your friend can, unprompted, predict that a binomial price and a BSM price for the same contract must converge as steps increase, and explain why a persistent gap would mean a bug, not a legitimate disagreement, you have installed the actual mechanism, which is the whole point of this module.

Journal prompt. Pick one real, currently-listed option (Nifty, Bank Nifty, SPX, or any liquid single name in either market) and, without using any pricing software, write down what you expect each of its five Greeks to look like in rough relative terms, is delta closer to 0 or 1, is gamma large or small, is theta a bigger or smaller drag than you'd guess, is vega meaningful given the time to expiry, is rho close to negligible. Then actually compute all five (by hand or in Python) and compare. Where were you most wrong, and can you explain why in terms of moneyness, time to expiry, and volatility, the three things that most directly drive each Greek's size? Then write a paragraph on this: every Greek in this module was verified twice (once symbolically, once by finite difference or an independent identity) before being allowed into the document. Which single habit from this module (parity as a standing check, reconciling binomial against BSM, cross-checking a Greek by finite difference) would most change how much you trust an AI-generated pricing script on the first read, and what will you do the next time you ask an AI tool to price something, to make that habit automatic rather than optional?

This module's flashcards and mastery quiz are wired into the app: see the node's Quiz and Reviews.