Pages 2.6 to 2.10 built Black–Scholes on three assumptions: one known volatility, continuous costless hedging, and lognormal returns. This page breaks each of them and measures what survives. The result is that the formula stops being a perfect model of the stock, but remains the language the market uses to price and quote options, which is why production pricers work in implied-volatility space.

What this page shows, and how

A · One price, one vol. Why an option price corresponds to exactly one implied volatility, which prices have an implied vol at all, and how the solver recovers it.

B · The smile. A market built from two volatility states priced exactly, then translated back into Black–Scholes implied vols, producing a smile and a skew.

C · Lognormal returns vs reality. A distribution that matches the first two moments of a lognormal but fails in the tails, and the checks that detect the difference.

D · The hedge. Black–Scholes hedging applied to a market that is not Black–Scholes, separating replication error from risk that cannot be hedged away.

E · Costs. Transaction costs added to the hedge, turning "rebalance more often" into a trade-off with an interior optimum.

F · Vol is the unit of price. Why desks quote options in implied volatility rather than cash prices, and why the surface replaces the single σ\sigma.

The experiment — what was done

The experiment combines four pieces. First, an implied-volatility solver using Newton's method with a bisection safeguard is tested against both QuantLib and the course's golden file. Second, a synthetic market is built from a two-state lognormal mixture, with exact option prices computed as weighted averages of Black–Scholes prices. Third, three hedged books are run: a control book on its own Black–Scholes paths, and on one shared set of mixture paths a Black–Scholes hedge and an oracle hedge that knows the path's volatility. Finally, a proportional transaction cost is charged on every rebalance.

Everything was run from 2_11_where_it_breaks.py with seed 20261108, passing 157 checks. The committed JSON was produced on the workstation and reproduced independently in the container, agreeing to 2 parts in 10910^9 at worst and to 3×10−123 \times 10^{-12} on every number this page quotes.

·
·
·

One price, one vol

An implied volatility exists because the Black–Scholes price is strictly increasing in σ\sigma. The derivative with respect to σ\sigma is vega, S0φ(d1)TS_0 \varphi(d_1) \sqrt{T}, and vega is positive everywhere, so the price curve never turns back on itself. A market price therefore corresponds to exactly one implied volatility whenever it lies inside the no-arbitrage bounds.

For the base case (S0=K=100S_0 = K = 100, r=0.05r = 0.05, T=1T = 1, no dividends), those bounds run from S0−Ke−rT=4.877S_0 - K e^{-rT} = 4.877 as σ\sigma tends to zero to S0=100S_0 = 100 as σ\sigma tends to infinity. Every price strictly between them has a unique implied vol; prices outside them have none.

The solver starts from a guess σ0=0.2\sigma_0 = 0.2 and repeatedly applies Newton's method, using vega to convert a pricing error into a volatility correction. For the 18.02 call it converges from 0.2 to 0.4 in four iterations, with the error shrinking quadratically once it is near the solution.

Newton's trace, base case

The solver on the base case, S0=K=100S_0 = K = 100, r=0.05r = 0.05, T=1T = 1, q=0q = 0, from the committed experiments/2_11_where_it_breaks.json: results.solver.base_case.trace[*].{iteration,sigma,price,price_error} and results.solver.base_case.{sigma,iterations,bisections,status}. Newton starts from σ0=0.2\sigma_0 = 0.2 (params.solver.sigma0) with the analytic vega, inside the bracket [10−6,5][10^{-6}, 5] (params.solver.{lo,hi}), and took no bisection step. The last column is the price error at each iteration. The bounds are results.solver.bounds_base_case.{lower_bound,upper_bound}; the price at σ=5\sigma = 5 is 98.79 (price_at_sigma_hi), so a price between 98.79 and 100 reports above_sigma_hi (refusals).

iterationσ\sigmaC(σ)C(\sigma)C(σ)−18.02295C(\sigma) - 18.02295
10.200000000010.4506−7.572
20.401800471118.0911+0.0681
30.399999900218.022948−3.8×10−6-3.8 \times 10^{-6}
40.400000000018.022951−7×10−15-7 \times 10^{-15}

The interesting edge case is where vega has effectively vanished. In 700 of the golden file's 7,200 grid rows the price is flat in σ\sigma — deep in the money with no time value, or deep out of the money with almost no value at all — so the price barely changes when σ\sigma changes. There the solver can still reproduce the price to machine precision, but the price no longer contains enough information to recover the volatility that originally generated it. The broader theory of implied-volatility inversion, bounds and root-finding belongs to 3.4; this page only needs one reliable implementation.

Golden-file rows by vega

Every row of golden/bs_vanilla.json, generated by QuantLib 1.43, solved from its price back to its vol and sorted by its vega at the row's own vol, from results.solver.oracle.golden.{cases,edge_cases}.{n,statuses,identifiable,vega_limited,not_identifiable}, with the thresholds in vega_thresholds. "Vol recovered to" is the worst absolute error in σ\sigma (max_abs_sigma_error) and "price reproduced to" the worst price error (max_abs_price_error_rel), absolute below 1 and relative above it, the golden file's rule. In the middle row the bound is the price tolerance divided by the row's vega (vega_limited.max_ratio_sigma_error_to_bound). All 7,234 rows lie inside the no-arbitrage bounds to 10−1210^{-12} and every solve converged (n_inside_bounds, statuses); 677 grid rows and 10 edge rows sit on the lower bound (n_on_lower_bound). The last row is the worst of the round trip at the grid, results.solver.grid_round_trip.{max_abs_sigma_error_call,max_abs_sigma_error_put}, and of the gap from QuantLib's vol, results.solver.oracle.live.{version,n_points,max_abs_sigma_error}.

vega (per 1.00 of σ\sigma)gridedgevol recovered toprice reproduced to
vega≥1\text{vega} \ge 15,354204.6×10−114.6 \times 10^{-11} (at most 10 iterations)10−1210^{-12} (relative above 1)
10−8≤vega<110^{-8} \le \text{vega} < 11,1462the price error ÷ vega: worst 8×10−48 \times 10^{-4} at vega about 2×10−82 \times 10^{-8}, never more than 0.98 × that bound10−1210^{-12}
vega<10−8\text{vega} < 10^{-8}70012not recoverable — up to 0.15 off10−1210^{-12}
2.9's 216-point grid, call and put, against QuantLib 1.43 blackFormulaImpliedStdDev432—7.3×10−137.3 \times 10^{-13} both ways—

The smile

The synthetic market assumes the stock spends the whole year in one of two volatility states: 0.2 or 0.6, each with probability one half, with both states sharing the same forward. Every option price is therefore half a Black–Scholes price at 0.2 plus half a Black–Scholes price at 0.6.

When those prices are converted back into implied volatilities, the result is not flat. The smile bottoms out at the forward, where the implied volatility is 0.398. It rises to 0.477 at K=60K = 60 and 0.452 at K=160K = 160, still climbing towards the high-vol state's 0.6. Because both states share the same forward, the smile is symmetric in log-moneyness.

The smile, symmetric mixture, T = 1

The symmetric mixture at T=1T = 1, S0=100S_0 = 100, r=0.05r = 0.05: weights params.mixtures.symmetric.p, vols sigmas and both states on the one forward (forward_factors), from results.market.symmetric.features.{forward,at_forward,points.K_*.{mixture_price,implied_vol}}. The price is the mixture's exact call price, and the implied vol is the one Black–Scholes vol that reproduces it; at the forward the table gives the vol alone. The whole curve is results.market.symmetric.smile_T1: 101 strikes from 60 to 160, every one with a vol (n_strikes_with_vol), its minimum at the forward (features.minimum_fine_scan), symmetric in log-moneyness to 3×10−133 \times 10^{-13} (features.symmetry_about_forward), and put–call parity holding to 1.4×10−141.4 \times 10^{-14} (parity_gap_max_abs).

KK608090100105.13=F105.13 = F110120140160
mixture call price45.00829.67023.24317.987—13.95911.0087.3265.235
implied vol0.47680.42540.40770.39900.39800.39890.40510.42770.4524

At the money, the implied volatility is 0.399. That is slightly below the mean volatility of 0.40 and well below the rms volatility of 0.447. The reason is that near the money, option prices are almost linear in σ\sigma, so averaging prices is almost the same as averaging volatilities. It is not the same as averaging variances.

At the money, K = 100

At the money, K=100K = 100, from results.market.symmetric.atm.{component_prices,mixture_price,implied_vol,price_at_mean_vol,price_at_rms_vol} and params.mixtures.symmetric.{mean_vol,rms_vol}. The first two rows are the Black–Scholes price in each vol state, and the mixture's price is their average. The last two rows price a single lognormal at the mean of the two vols and at their root mean square.

at K=100K = 100priceimplied vol
the 0.2 state10.4510.2
the 0.6 state25.5230.6
the mixture, 12\tfrac12 of each17.9870.3990
one lognormal at the mean vol 0.4018.0230.40
one lognormal at the rms vol 0.44719.8070.447

The skewed mixture breaks the equal-forward assumption. The high-vol state carries a lower forward and the low-vol state a higher one (34\tfrac34 weight on σ=0.3\sigma = 0.3 at 1.05 F1.05\,F, 14\tfrac14 on σ=0.6\sigma = 0.6 at 0.85 F0.85\,F), tilting the smile into a skew. The key lesson is that fat tails alone generate a smile; asymmetry generates the skew.

D9Implied vol solver and smile
The smile

p = 0.5 / 0.5 · σ = 0.2 / 0.6 · F / F · τ = 1

K
100
C
17.987
P
13.110
σ_i
0.3990
F
105.13
mixture
Expiry τ
One price, one vol

S₀ = K = 100 · r = 0.05 · T = 1 · q = 0

σ_i
0.4000000000
status
converged
iterations
4
the no-arbitrage bounds
4.877 < C < 100
iterationσC(σ)C(σ) − 18.02295
10.200000000010.450584−7.57
20.401800471118.091081+0.0681
30.399999900218.022948−3.8 × 10⁻⁶
40.400000000018.022951−1.4 × 10⁻¹⁴

Lognormal returns vs reality

excess kurtosis
the mixture's log S_T1.816
the mixture-of-normals closed form1.801
any lognormal0.000
daily returns, pooled1.892
daily returns, σ = 0.2−0.005
daily returns, σ = 0.6−0.002

Vol is the unit of price

the one-year 100 callstock at 100stock at 110
price at 40 vol18.0224.74
the vol that 18.02 means0.4000.211

Lognormal returns vs reality

A single lognormal distribution has zero excess kurtosis in log-return space. The mixture does not. Its excess kurtosis is about 1.8, meaning substantially heavier tails than the lognormal benchmark.

That is exactly where 2.6's test battery finds the problem. The lognormal is fitted to the mixture's first two log moments, so the checks on mean and variance pass by construction. The failures appear in the skewness, kurtosis and median tests, with enormous z-scores, because the fourth moment reveals information that the first two moments cannot.

Lognormal checks on the mixture

On 10610^6 mixture draws against the lognormal fitted to the first two log moments (σfit=0.4543\sigma_{\text{fit}} = 0.4543); for E[ST]\E[S_T] and the sd⁡\sd, against the lognormal with that vol and the forward FF. 2.6's checks on 10610^6 draws of the symmetric mixture's STS_T at T=1T = 1, from results.returns.battery_2_6.{n,sigma_fit,rows[*].{check,measured,expected}}, with se, z and pass_within_5se for the first six rows and relative_gap and pass_to_3pct for the last. The lognormal column is each check's expected value (rows[*].expected), with the vol sigma_fit: the mixture's own log mean and log variance in the first two rows, 0 for skewness and excess kurtosis, the forward FF for E[ST]\E[S_T], eE[log⁡ST]e^{\E[\log S_T]} for the median, and Feσfit2T−1F\sqrt{e^{\sigma_{\text{fit}}^2 T} - 1} for the sd⁡\sd. zz is the gap in the draws' standard errors, and a check passes within 5 s.e. Behind the failures, results.market.kurtosis.{mixture,lognormal}: the mixture's log STS_T has excess kurtosis 1.816 ± 0.012 against the mixture-of-normals closed form 1.8009, and 1.23 % of draws beyond 3 sd against the normal's 0.27 %. Each vol state alone is Gaussian within 5 s.e. (results.returns.battery_2_6.by_state).

2.6's checkmeasuredlognormalzzverdict
log-return mean−0.05025−0.05000−0.6pass — matched by construction
log-return variance0.206150.20640−0.9pass — matched by construction
log-return skewness−0.4120−168fail
log-return excess kurtosis1.7880+365fail
E[ST]\E[S_T]105.08105.13=F105.13 = F−0.9pass — the forward belongs to both models
median STS_T98.9895.12+71fail
sd⁡\sd of STS_T (2.6's rule: to 3 %)51.0450.33+1.4 %pass

The daily-return experiment tells the same story. Pooled across all paths, returns exhibit heavy tails, with 1.26 % of observations beyond three standard deviations against the 0.27 % a Gaussian predicts. Yet if the paths are separated into their volatility states, each state individually looks Gaussian.

"The fat tails are the mixing" means exactly that. Nothing pathological is happening inside either component model. The non-Gaussian behaviour appears only when observations from different volatility regimes are pooled together. For a developer, that is a reminder that passing mean and variance checks is not enough. A simulator can match the first two moments perfectly and still fail badly in the tails, which is where option prices are most sensitive.

The hedge under the wrong model

The control book reproduces 2.7's result. As rebalancing becomes more frequent, the spread falls like 1/N1/\sqrt{N}, and the product of spread and N\sqrt{N} stays roughly constant.

The mixture book behaves differently. Its spread falls at first and then settles around 8.08, remaining essentially unchanged from N=256N = 256 onward. Continuous rebalancing does not remove the remaining risk.

Hedged P&L spread against N

The Black–Scholes and oracle hedges are both on the mixture. The standard deviation of the discounted hedged P&L, gross of fees, over 4,000 paths per book, every path set drifting at rr (results.hedging.mu), from results.hedging.{control,mixture_bs_hedge,mixture_oracle_hedge}.per_N[*].{N,pnl_gross.sd,sd_times_sqrtN} and results.hedging.{mixture_bs_hedge,mixture_oracle_hedge}.per_N[*].within_state_sd. The control is priced and hedged at σ=0.4\sigma = 0.4 on its own Black–Scholes paths. The two mixture books share one set of the symmetric mixture's paths and paid the mixture's price (results.hedging.mixture_paths.price_paid_P_mix): one hedges at its implied vol (mixture_bs_hedge.sigma_hedge), the oracle at the path's own. "Within each state" is the spread inside each vol state, the two states' variances averaged with weights of one half. The spread between the states is results.hedging.mixture_paths.between_state_sd, 7.536. On every path and at every NN the bank-account P&L equals 2.7's telescoped formula to 5×10−125 \times 10^{-12} (bookkeeping_identity_max_abs).

NNcontrol sd⁡\sdcontrol sd⁡⋅N\sd \cdot \sqrt{N}Black–Scholes hedge sd⁡\sd… within each stateoracle hedge sd⁡\sd… within each state
46.04812.1010.5157.53810.1387.012
163.16912.688.7124.4048.2493.486
641.64513.168.2093.3497.7051.837
2560.83513.378.1362.9647.6020.927
10240.41613.328.0912.8637.5520.467
40960.20613.218.0802.8327.5420.230

That floor has two pieces. The largest, 7.54, comes from not knowing which volatility state was sold when the option was priced. The option was bought at the average of the two state prices, so every realised path begins with a gain or loss relative to the price that would have been charged if the state had been known. That uncertainty remains no matter how good the hedge becomes.

The second piece, about 2.83, comes from hedging with Greeks computed from the implied volatility rather than the path's true volatility. This is model error inside each state.

The oracle hedge separates them. Give the hedger the correct volatility on every path and the within-state spread collapses back at the familiar 1/N1/\sqrt{N} rate. What remains is the 7.54 between-state uncertainty.

So when volatility is not known, the trader is exposed to two distinct risks: uncertainty about the regime that was actually sold, and imperfect hedging caused by using the wrong model inputs. Only the second can be reduced by better hedging.

D5Delta-hedging simulator

seed 20261101 · 4,000 paths · μ = 0 · σ_r = 0.4 · σ_i = 0.4 · S₀ = K = 100 · r = 0.05

V₀, at σ_i
18.02
fitted slope, N ≥ 4
−0.488
hedged mean, N = 256
−0.01 ± 0.01
hedged sd, N = 256
0.874sd × √N = 14.0
unhedged mean
−3.11 ± 0.47closed form −3.10
unhedged sd
29.6closed form 29.8
discounted hedged mean
−0.01 ± 0.01(σ_r² − σ_i²) × gamma integral: +0.00 × 46.8 = +0.00
forward: max |P&L|
2e−12Δ = 1, N = 256
live sample: hedged mean
+0.01 ± 0.03781 paths, this site’s generator
live sample: hedged sd
0.8870 off the bins
committed bars
N = 2560 past ±20
unhedged, past the axis
5.0 %beyond 60
Source
Drift μ
Realised vol σ_r

The experiment’s first five paths, hedged at N = 256, at μ = 0 and σ_r = σ_i = 0.4, whatever is set above.

path 1: S_T
75.11
path 1: P&L at T
+1.37
path 2: P&L at T
+0.14
path 3: P&L at T
+1.07
path 4: P&L at T
−0.46
path 5: P&L at T
−0.74

The ladder, the bars and the readouts above the live sample are the committed experiment: 4,000 paths drawn once at 4,096 steps and hedged at each N, P&L at T unless marked discounted. The experiment kept its histograms at N = 1, 256 and 4096; the line is a fresh sample on this site’s generator, which is not numpy’s. The fitted slope is −0.488 against a theoretical −½.

Transaction costs

In 2.7, more frequent hedging always improved replication. Once costs are introduced, that stops being true.

Each rebalance trades roughly ∣δΔ∣|\delta\Delta|, which is proportional to gamma times the underlying move. Since a typical price move over a timestep scales like 1/N1/\sqrt{N}, each trade becomes smaller as rebalancing gets more frequent. But there are NN trades. Multiply the two together and the total cost grows like N\sqrt{N}.

That is exactly what the measurements show. Every fourfold increase in NN eventually doubles the cost, giving a log-log slope of about +0.5.

Costs against N, control book

The spread is the sd⁡\sd, gross of fees; the costs are means. The control book of the table above, with a fee of 10 basis points on the value of every share traded at setup, at each rebalance and at the unwind (params.hedging.{fee_k,fee_note}), from results.hedging.control.per_N[*].{N,pnl_gross.sd,cost_rebalance.mean,cost_setup.mean,cost_unwind.mean,cost_total.mean,spread_plus_cost,pnl_net.sd} and results.hedging.control.trade_off.{N_minimising_spread_plus_cost_on_grid,cost_ratio_N_to_4N}. Costs are means over the 4,000 paths, discounted to time 0. The ratio is the rebalancing cost at NN over that at N/4N/4. The total cost adds the setup's and the unwind's to the rebalancing cost; "spread + cost" is the first column plus the total cost, and the net P&L is after every fee. Over N≥64N \ge 64 the log-log slope of the rebalancing cost is +0.502 (results.hedging.control.slopes_over_N_ge_64.cost_rebalance_mean).

NNspread (sd⁡\sd)rebalancing costratio to N/4N/4total costspread + costnet P&L sd⁡\sd
46.0480.048—0.1736.2216.032
163.1690.1162.420.2423.4103.157
641.6450.2402.070.3662.0111.636
2560.8350.4852.0160.6101.4450.846
10240.4160.9702.0011.0951.5110.553
40960.2061.9402.0002.0652.2720.761

The result is a trade-off. Hedging error falls like 1/N1/\sqrt{N} while trading costs rise like N\sqrt{N}. On this grid the sum of spread and cost is smallest at N=256N = 256, while the net P&L volatility reaches its minimum at N=1024N = 1024.

That is why "hedge continuously" is a mathematical benchmark rather than practical advice. Real desks have to balance replication quality against the cost of achieving it.

Vol is the unit of price

Suppose the stock rises from 100 to 110. The cash price quote of 18.02 becomes stale immediately. At the same 40 % implied volatility, the option is now worth 24.74. The market would never continue trading the option at 18.02.

Price quote against vol quote

The one-year call struck at 100, r=0.05r = 0.05, q=0q = 0, from results.quotes.{price_at_100_vol_0.40,price_at_110_vol_0.40,implied_vol_of_18.02_at_110}. The first row prices it at σ=0.4\sigma = 0.4 with the stock at 100 and at 110; the second row is the implied vol of the first row's 18.02 with the stock at each, at 100 the solver's base case, results.solver.base_case.sigma.

the one-year 100 callstock at 100stock at 110
price at 40 vol18.0224.74
the vol that 18.02 means0.4000.211

The volatility quote is different. If the market still believes the option should trade at 40 vol, that quote remains valid. The new option price is obtained simply by feeding the updated inputs into Black–Scholes. In that sense, implied volatility divides out the inputs everyone can observe and leaves the quantity options are compared and traded on.

That is why the market's object is not a table of prices but a surface of implied volatilities.

Where Part 2 ends

The page closes Part 2. We started with random walks and Brownian motion, built Geometric Brownian motion (GBM), derived Black–Scholes, checked it against simulation, studied hedging, and then removed its assumptions one at a time. Part 3 turns those ideas into production tools: 3.1 builds the closed form in code, 3.2 prices by Monte Carlo, 3.3 solves the PDE by finite differences, 3.4 constructs and interpolates implied-volatility surfaces, and 3.5 computes Greeks even when no closed form exists. The topics deferred here, transaction-cost adjustments, jumps, stochastic volatility, vanna and volga, become the material for v2 rather than foundations.

Check

A market quotes the one-year 100-strike call at 18.02 (S₀ = 100, r = 0.05). How many values of σ make the Black–Scholes formula return that price?

With probability ½ the stock’s vol is 0.2, with probability ½ it is 0.6, same forward. You back out Black–Scholes implied vols from the mixture’s prices at every strike. The curve against strike is:

The mixture passes 2.6’s checks on the mean and variance of log S_T against a lognormal fitted to them. Which of 2.6’s checks catches it?

You hedge the mixture market with Black–Scholes deltas at the implied vol 0.399, rebalancing N times. As N → ∞ the hedged P&L’s spread:

A fee of k on every share traded. You double the number of rebalances N. The total rebalancing cost is multiplied by about:

The desk quotes the one-year 100 call at "40 vol" rather than "18.02". The stock moves from 100 to 110. Which quote has gone stale?