Implied Volatility

Every day, traders buy and sell options — contracts that give the right, but not the obligation, to buy or sell an asset at a fixed price by a fixed date. To price an option fairly, you need to answer one question above all others: how wildly will the underlying asset move between now and expiry?

You could look at how volatile the asset has been in the past. But markets are forward-looking, and past turbulence is not the same as expected turbulence. Instead, the market quotes an option at a price, and inside that price — encoded by the Black-Scholes formula — lurks a number called implied volatility (IV).

Implied volatility is not observed directly. It is inferred: you take the observed option price, plug in everything you know (stock price, strike, time to expiry, interest rate), and then invert the formula to find the single value of $\sigma$ that makes the formula reproduce that market price. In this sense, IV is the volatility the market is "implying" — its collective guess at future turbulence, distilled into one number.

The fascinating wrinkle is the volatility smile: if you do this for many options on the same stock but with different strikes, you do not get the same IV every time. Instead, the IV curve smiles or smirks, revealing that markets expect crashes and tail events far more often than a simple normal distribution would suggest.

Pick a quoted option price and let the solver find the implied volatility. The demo uses the Black-Scholes call formula and locates $\sigma$ with a simple bisection search: it brackets the answer between a low and high volatility, then halves the interval until the computed price matches the target.

<!-- {{c_layout_comment}} -->
<div class="controls">
  <div class="row">
    <label>{{lbl_stock}}<input type="number" id="S" value="100" min="1" max="500" step="1"></label>
    <label>{{lbl_strike}}<input type="number" id="K" value="100" min="1" max="500" step="1"></label>
    <label>{{lbl_rate}}<input type="number" id="r" value="0.05" min="0" max="0.3" step="0.01"></label>
    <label>{{lbl_time}}<input type="number" id="T" value="0.5" min="0.01" max="3" step="0.01"></label>
  </div>
  <div class="row">
    <label>{{lbl_price}}<input type="number" id="optPrice" value="8.00" min="0.01" max="400" step="0.01"></label>
    <button id="solveBtn" type="button">{{btn_solve}}</button>
    <button id="smileBtn" type="button">{{btn_smile}}</button>
  </div>
</div>
<div id="result" class="result"></div>
<canvas id="chart" width="480" height="220" aria-label="{{chart_aria}}"></canvas>
<div class="legend" id="legend"></div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.controls { background: #f0f4f8; border-radius: 10px; padding: .7rem .8rem .5rem; margin-bottom: .6rem; }
.row { display: flex; flex-wrap: wrap; gap: .5rem .8rem; align-items: flex-end; margin-bottom: .4rem; }
label { font-size: .78rem; font-weight: 600; color: #445; display: flex; flex-direction: column; gap: 2px; }
input[type=number] { font-size: .88rem; padding: .25rem .4rem; border: 1px solid #bcc; border-radius: 6px;
                     width: 80px; background: #fff; }
button { font: 600 .82rem system-ui; padding: .35rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button:last-child { background: #2a7f62; border-color: #2a7f62; }
.result { font-size: .95rem; font-weight: 600; min-height: 1.5em; margin-bottom: .4rem; }
.result.ok { color: #1a7d40; }
.result.bad { color: #c0392b; }
canvas { display: block; max-width: 100%; border-radius: 8px; background: #f7fafc; }
.legend { font-size: .78rem; color: #556; margin-top: .3rem; display: flex; gap: 1rem; flex-wrap: wrap; }
.legend span { display: flex; align-items: center; gap: 4px; }
.legend .dot { width: 12px; height: 4px; border-radius: 2px; display: inline-block; }

// Code not found

Notice how the bisection homes in quickly — within 20 iterations the error is below $0.0001$. That speed reflects a key property of the Black-Scholes price: it is strictly increasing in $\sigma$, so there is always exactly one solution (when the price is between its intrinsic value and the stock price). The search is guaranteed to converge.

The Black-Scholes call price for a European option is:

$$C = S \cdot N(d_1) - K e^{-rT} \cdot N(d_2)$$

where $d_1 = \frac{\ln(S/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}$, $d_2 = d_1 - \sigma\sqrt{T}$, and $N(\cdot)$ is the standard normal CDF. Every variable except $\sigma$ is observable. But there is no closed-form inverse: you cannot isolate $\sigma$ algebraically.

• Bisection brackets $\sigma \in (0, \sigma_{\max})$ and halves the interval until $|C(\sigma) - C_{\text{market}}| < \varepsilon$. It converges at $O(\log_2(1/\varepsilon))$ steps — reliable but linear.
• Newton-Raphson uses the derivative $\partial C/\partial \sigma$ — known as vega — to jump directly toward the root. It converges quadratically, typically needing only 3–5 iterations from a good starting point.
• Analytic approximations (Brenner-Subrahmanyam, Corrado-Miller) give a closed-form IV estimate accurate to a few basis points, useful as a warm start for Newton.

The volatility smile is the true puzzle. Black-Scholes assumes $\sigma$ is constant, but empirically, deep out-of-the-money puts (crash insurance) trade at far higher IV than at-the-money options. This shape — flat in theory, curved in practice — is evidence that real markets are not log-normal. Models like Heston stochastic volatility and SABR were built specifically to capture this smile.

Implied volatility is not just a curiosity — it is the central language of the options market:

• The VIX index: the CBOE's "fear gauge" is constructed by aggregating implied volatilities across many S&P 500 options. It measures the market's 30-day expected volatility without assuming any model.
• Delta hedging: traders who sell options hedge their directional exposure continuously. The hedge ratio (delta) and its cost depend directly on IV.
• Risk management: Value-at-Risk and stress-testing models use IV surfaces — the full grid of IVs across strikes and maturities — to price a portfolio's exposure under adverse scenarios.
• Arbitrage detection: if IV differs across exchanges for the same option, a riskless trade exists. Algorithms scan IV surfaces in real time looking for these gaps.
• Model calibration: any stochastic volatility model (Heston, SABR, rough volatility) is calibrated by fitting its parameters to the observed IV surface.

The inversion problem — running a formula backwards from price to parameter — shows up across science and engineering. In finance, Black-Scholes inversion is solved daily by billions of dollars of automated trading, making it one of the most consequential root-finding problems in the world. Compare this with Bayesian inference, where a similar idea of inverting a model to recover hidden parameters drives much of machine learning.

Implied volatility turns a pricing formula inside out. You observe a price, you know every input except one, and you run a numerical search to recover the hidden parameter. It is a clean example of inversion: moving from an effect (the price) back to its cause (the volatility expectation).

But the real lesson is the smile. If markets were truly log-normal, IV would be flat across all strikes. That it is not — that crash insurance consistently trades richer than at-the-money options — is the market's quiet acknowledgment that tail events are more likely than any Gaussian model predicts.

Every option price is both a bet and a barometer. Read enough of them and you can see what the collective intelligence of the market genuinely fears.