2.11
Where it breaks
Constant vol, continuous frictionless trading, lognormal returns vs reality; smile and skew; why the model survives as a quoting convention (vol is the unit of price).
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 .
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 at worst and to
on every number this page quotes.
One price, one vol
An implied volatility exists because the Black–Scholes price is strictly increasing in . The derivative with respect to is vega, , 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 (, , , no dividends), those bounds run from as tends to zero to as tends to infinity. Every price strictly between them has a unique implied vol; prices outside them have none.
The solver starts from a guess 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.
The solver on the base case, , , , , 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
(params.solver.sigma0) with the analytic vega, inside the bracket
(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 is
98.79 (price_at_sigma_hi), so a price between 98.79 and 100 reports above_sigma_hi
(refusals).
| iteration | |||
|---|---|---|---|
| 1 | 0.2000000000 | 10.4506 | −7.572 |
| 2 | 0.4018004711 | 18.0911 | +0.0681 |
| 3 | 0.3999999002 | 18.022948 | |
| 4 | 0.4000000000 | 18.022951 |
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 — 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 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.
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 (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 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 ) | grid | edge | vol recovered to | price reproduced to |
|---|---|---|---|---|
| 5,354 | 20 | (at most 10 iterations) | (relative above 1) | |
| 1,146 | 2 | the price error ÷ vega: worst at vega about , never more than 0.98 × that bound | ||
| 700 | 12 | not recoverable — up to 0.15 off | ||
2.9's 216-point grid, call and put, against QuantLib 1.43 blackFormulaImpliedStdDev | 432 | — | 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 and 0.452 at , 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 symmetric mixture at , , : 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
(features.symmetry_about_forward), and put–call parity holding to
(parity_gap_max_abs).
| 60 | 80 | 90 | 100 | 110 | 120 | 140 | 160 | ||
|---|---|---|---|---|---|---|---|---|---|
| mixture call price | 45.008 | 29.670 | 23.243 | 17.987 | — | 13.959 | 11.008 | 7.326 | 5.235 |
| implied vol | 0.4768 | 0.4254 | 0.4077 | 0.3990 | 0.3980 | 0.3989 | 0.4051 | 0.4277 | 0.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 , so averaging prices is almost the same as averaging volatilities. It is not the same as averaging variances.
At the money, , 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 | price | implied vol |
|---|---|---|
| the 0.2 state | 10.451 | 0.2 |
| the 0.6 state | 25.523 | 0.6 |
| the mixture, of each | 17.987 | 0.3990 |
| one lognormal at the mean vol 0.40 | 18.023 | 0.40 |
| one lognormal at the rms vol 0.447 | 19.807 | 0.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 ( weight on at , on at ), tilting the smile into a skew. The key lesson is that fat tails alone generate a smile; asymmetry generates the skew.
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
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 |
|---|---|---|---|
| 1 | 0.2000000000 | 10.450584 | −7.57 |
| 2 | 0.4018004711 | 18.091081 | +0.0681 |
| 3 | 0.3999999002 | 18.022948 | −3.8 × 10⁻⁶ |
| 4 | 0.4000000000 | 18.022951 | −1.4 × 10⁻¹⁴ |
Lognormal returns vs reality
| excess kurtosis | |
|---|---|
| the mixture's log S_T | 1.816 |
| the mixture-of-normals closed form | 1.801 |
| any lognormal | 0.000 |
| daily returns, pooled | 1.892 |
| daily returns, σ = 0.2 | −0.005 |
| daily returns, σ = 0.6 | −0.002 |
Vol is the unit of price
| the one-year 100 call | stock at 100 | stock at 110 |
|---|---|---|
| price at 40 vol | 18.02 | 24.74 |
| the vol that 18.02 means | 0.400 | 0.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.
On mixture draws against the lognormal fitted to the first two log moments
(); for and the , against the lognormal with
that vol and the forward .
2.6's checks on draws of the symmetric
mixture's at , 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 for
, for the median, and
for the . 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 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 check | measured | lognormal | verdict | |
|---|---|---|---|---|
| log-return mean | −0.05025 | −0.05000 | −0.6 | pass — matched by construction |
| log-return variance | 0.20615 | 0.20640 | −0.9 | pass — matched by construction |
| log-return skewness | −0.412 | 0 | −168 | fail |
| log-return excess kurtosis | 1.788 | 0 | +365 | fail |
| 105.08 | −0.9 | pass — the forward belongs to both models | ||
| median | 98.98 | 95.12 | +71 | fail |
| of (2.6's rule: to 3 %) | 51.04 | 50.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 , and the product of spread and stays roughly constant.
The mixture book behaves differently. Its spread falls at first and then settles around 8.08, remaining essentially unchanged from onward. Continuous rebalancing does not remove the remaining risk.
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 (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 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 the bank-account P&L equals
2.7's telescoped formula to
(bookkeeping_identity_max_abs).
| control | control | Black–Scholes hedge | … within each state | oracle hedge | … within each state | |
|---|---|---|---|---|---|---|
| 4 | 6.048 | 12.10 | 10.515 | 7.538 | 10.138 | 7.012 |
| 16 | 3.169 | 12.68 | 8.712 | 4.404 | 8.249 | 3.486 |
| 64 | 1.645 | 13.16 | 8.209 | 3.349 | 7.705 | 1.837 |
| 256 | 0.835 | 13.37 | 8.136 | 2.964 | 7.602 | 0.927 |
| 1024 | 0.416 | 13.32 | 8.091 | 2.863 | 7.552 | 0.467 |
| 4096 | 0.206 | 13.21 | 8.080 | 2.832 | 7.542 | 0.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 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.
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
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 , which is proportional to gamma times the underlying move. Since a typical price move over a timestep scales like , each trade becomes smaller as rebalancing gets more frequent. But there are trades. Multiply the two together and the total cost grows like .
That is exactly what the measurements show. Every fourfold increase in eventually doubles the cost, giving a log-log slope of about +0.5.
The spread is the , 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 over that at . 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 the log-log slope of the
rebalancing cost is +0.502 (results.hedging.control.slopes_over_N_ge_64.cost_rebalance_mean).
| spread () | rebalancing cost | ratio to | total cost | spread + cost | net P&L | |
|---|---|---|---|---|---|---|
| 4 | 6.048 | 0.048 | — | 0.173 | 6.221 | 6.032 |
| 16 | 3.169 | 0.116 | 2.42 | 0.242 | 3.410 | 3.157 |
| 64 | 1.645 | 0.240 | 2.07 | 0.366 | 2.011 | 1.636 |
| 256 | 0.835 | 0.485 | 2.016 | 0.610 | 1.445 | 0.846 |
| 1024 | 0.416 | 0.970 | 2.001 | 1.095 | 1.511 | 0.553 |
| 4096 | 0.206 | 1.940 | 2.000 | 2.065 | 2.272 | 0.761 |
The result is a trade-off. Hedging error falls like while trading costs rise like . On this grid the sum of spread and cost is smallest at , while the net P&L volatility reaches its minimum at .
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.
The one-year call struck at 100, , , 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 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 call | stock at 100 | stock at 110 |
|---|---|---|
| price at 40 vol | 18.02 | 24.74 |
| the vol that 18.02 means | 0.400 | 0.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?