Black–Scholes Greeks as Volatility Approaches Zero
Summary
The document examines how the Greeks of a European option behave as volatility approaches zero under the Black–Scholes model. Its central illustration uses delta: with no volatility, the maturity price becomes deterministic under the model’s assumed carry, so the call payoff switches from zero to positive at a discounted strike threshold. Delta therefore approaches a step function, whose dividing spot level is below the strike when the interest rate is positive.
This explains why the limiting behavior differs from simply converging to the strike, and the answer says the same reasoning can be applied to other Greeks. The discussion is qualitative and provides no plotted results or detailed limits for each Greek. The question includes code for several Greek calculations, but the response does not review the implementation, so it does not establish whether every formula or observed graph is correct.
Key ideas
- As volatility approaches zero, the Black–Scholes model makes the maturity spot deterministic.
- Call delta approaches a step function around the discounted strike threshold.
- With a positive interest rate, that threshold lies below the strike.
- The response offers intuition but does not verify the supplied code or derive every Greek’s limit.
Tags
Full text
# Why do the Greeks not converge to the strike as the volatility tends to zero?
# Why do the Greeks not converge to the strike as the volatility tends to zero?
So, I was playing around with the Greeks in Python with some made up data for a European call option assuming the Black-Scholes model. I plotted the graphs to see what happens to the Greeks when either the Time to Maturity or the Volatility change, other things being equal. You can see the graphs below:
I noticed that as the Time to maturity tends to zero, all the Greeks "converge" to the strike price. However, the same is not true for the Volatility. The Greeks seem to "converge" to the value just to the left of the strike. I am not sure if that's intended or if my code isn't correct. Would love to see either a confirmation of the result (and an explanation as to where the Greeks "converge") or a suggestion on where I might have gone wrong here. The code below shows the Python code for the Greeks:
```
def vega(S_t, K, r, q, T, t, sigma): # vega
d_1 = (np.log(S_t / K) + (r - q + sigma**2 / 2) * (T - t)) / (sigma * np.sqrt(T - t))
return S_t * np.exp(-q * (T - t)) * phi(d_1) * np.sqrt(T - t)
def delta(S_t, K, r, q, T, t, sigma, type = 'call'): # delta
d_1 = (np.log(S_t / K) + (r - q + sigma**2 / 2) * (T - t)) / (sigma * np.sqrt(T - t))
if type == 'call':
sign = 1
elif type == 'put':
sign = -1
return sign * N(sign * d_1) * np.exp(-q * (T - t))
def gamma(S_t, K, r, q, T, t, sigma): # gamma
d_1 = (np.log(S_t / K) + (r - q + sigma**2 / 2) * (T - t)) / (sigma * np.sqrt(T - t))
return np.exp(-q * (T - t)) * phi(d_1) / (S_t * sigma * np.sqrt(T - t))
def theta(S_t, K, r, q, T, t, sigma, type = 'call'): # theta
d_1 = (np.log(S_t / K) + (r - q + sigma**2 / 2) * (T - t)) / (sigma * np.sqrt(T - t))
d_2 = d_2 = d_1 - sigma * np.sqrt(T - t)
if type == 'call':
sign = 1
elif type == 'put':
sign = -1
return -np.exp(-q * (T - t)) * S_t * sigma * phi(d_1) / (2 * np.sqrt(T - t)) - sign * np.exp(-r * (T - t)) * r * K * N(d_2 * sign) + sign * q * S_t * np.exp(-q * (T - t)) * N(sign * d_1)
```
## Answer by JamesWuuuu (score 2, accepted)
https://quant.stackexchange.com/a/77555
If you shrink the volatility (let's say more extreme it goes to zero), then the spot price at maturity is simply $S_t e^{r(T-t)}$. There are no uncertainty; the at-maturity spot price becomes somehow deterministic.
Take Delta as example. Under the zero volatility situation, everything is kind of known. If $S_t < K e^{-r(T-t)}$, then it means at maturity,
$$S_t e^{r(T-t)} < K,$$ leading to a payoff of 0, corresponding to a 0 delta. On the other hand, $S_t \geq K e^{-r(T-t)}$ then
$$ S_t e^{r(T-t)} \geq K, $$ corresponding to a 1 delta. Since everything is determined on the current spot price $S_t$, the Delta is just a step function now, with the dividing point at $Ke^{-r(T-t)}$, which is exactly to the left of the strike (assuming $r>0$).
That's what happens when $\sigma$ shrinks: Delta converges more towards a step function, centering on $Ke^{-r(T-t)}$. A similar treatment can be applied to other Greeks as well.Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.