Back to Home
Quantitative Finance · PDEs & Monte Carlo

Option Pricing & Delta Hedging under Black–Scholes

Deniz Coban · Python, NumPy, SciPy
Overview We derive the Black–Scholes partial differential equation from a delta-hedging argument using a second-order Taylor / Itô expansion, solve it in closed form for European options, and derive the analytic Greeks ($\Delta, \Gamma, \mathcal{V}, \Theta$). For benchmark parameters ($S_0 = 100, K = 100, r = 0.05, \sigma = 0.20, T = 1$), we validate the closed-form European call price against a risk-neutral Monte Carlo engine over $10^6$ simulated paths ($10.45$ analytic vs. $10.47 \pm 0.01$ simulated). Finally, we simulate discrete-time delta hedging across $20{,}000$ sample paths, demonstrating that the terminal hedging-error standard deviation decays as $\mathcal{O}(N^{-1/2})$ in the number of rebalancing steps $N$ with a fitted log–log slope of $-0.49$, matching the theoretical variance estimate.

1. Asset Dynamics & Second-Order Taylor / Itô Expansion

Over a small time increment $\Delta t$, we model the underlying asset price $S_t$ via Geometric Brownian Motion with drift $\mu$ and volatility $\sigma$:

$$\Delta S = \mu S\,\Delta t + \sigma S\,\Delta W, \qquad \Delta W = \sqrt{\Delta t}\,Z, \quad Z \sim \mathcal{N}(0, 1)$$

Because the random shock $\Delta W$ scales with $\sqrt{\Delta t}$, its square has expectation $\mathbb{E}[(\Delta W)^2] = \Delta t$ and variance of order $(\Delta t)^2$. Expanding a smooth option value $V(S, t)$ in a second-order Taylor series and retaining all terms of order $\Delta t$ yields Itô's Lemma:

$$\Delta V \approx \frac{\partial V}{\partial t}\Delta t + \frac{\partial V}{\partial S}\Delta S + \frac{1}{2}\frac{\partial^2 V}{\partial S^2}(\Delta S)^2 \implies dV = \left(\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2}\right)dt + \frac{\partial V}{\partial S}dS$$

2. Delta-Hedging Argument, Black–Scholes PDE & The Greeks

Consider a self-financing portfolio $\Pi = V(S,t) - \Delta S$ that is long one option and short $\Delta$ shares of the underlying stock. Over an infinitesimal step $dt$, the change in portfolio value is:

$$d\Pi = dV - \Delta\,dS = \left(\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2}\right)dt + \left(\frac{\partial V}{\partial S} - \Delta\right)dS$$
Theorem 1 (Delta Elimination of Risk & The Black–Scholes PDE) Choosing the dynamic hedge ratio $\Delta = \frac{\partial V}{\partial S}$ eliminates the stochastic $dS$ term—and with it the physical drift $\mu$—making the portfolio instantaneously riskless. By no-arbitrage, the hedged portfolio must earn the risk-free rate $d\Pi = r\Pi\,dt = r\left(V - S\frac{\partial V}{\partial S}\right)dt$, yielding the Black–Scholes PDE: $$\frac{\partial V}{\partial t} + rS\frac{\partial V}{\partial S} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} - rV = 0$$ For a European call option with terminal payoff $C(S,T) = \max(S - K, 0)$, the unique closed-form solution is: $$C(S, t) = S\Phi(d_1) - K e^{-r(T-t)}\Phi(d_2), \qquad d_{1,2} = \frac{\ln(S/K) + \left(r \pm \frac{1}{2}\sigma^2\right)(T-t)}{\sigma\sqrt{T-t}}$$

Differentiating $C(S,t)$ gives the closed-form sensitivities (Greeks) governing portfolio risk and discrete rebalancing error:

$$\Delta = \frac{\partial C}{\partial S} = \Phi(d_1), \qquad \Gamma = \frac{\partial^2 C}{\partial S^2} = \frac{\phi(d_1)}{S\sigma\sqrt{T-t}}, \qquad \mathcal{V} = \frac{\partial C}{\partial \sigma} = S\phi(d_1)\sqrt{T-t}$$

3. Risk-Neutral Monte Carlo Validation ($10^6$ Paths)

Because the Black–Scholes PDE is independent of $\mu$, the option price equals the discounted expected payoff under the risk-neutral dynamics $S_T = S_0 \exp\!\big((r - \frac{1}{2}\sigma^2)T + \sigma\sqrt{T}\,Z\big)$ with $Z \sim \mathcal{N}(0,1)$. Evaluating our benchmark European call ($S_0 = 100, K = 100, r = 0.05, \sigma = 0.20, T = 1.0$) across $M = 10^6$ Monte Carlo paths validates the analytic solution within standard error:

$$C_{\text{analytic}} = 10.45 \;\;(10.4506), \qquad \hat{C}_{\text{MC}}(10^6\text{ paths}) = 10.47 \pm 0.01$$

4. Discrete Delta-Hedging Simulation & $\mathcal{O}(N^{-1/2})$ Decay

In continuous time ($N \to \infty$), rebalancing $\Delta_t = \Phi(d_1)$ eliminates hedging error completely. In practice, a portfolio can only be rebalanced at $N$ discrete dates $t_k = k\Delta t$ ($\Delta t = T/N$). Over each step $\Delta t$, the unhedged second-order curvature ($\Gamma$) produces a local replication error:

$$\epsilon_k \approx \frac{1}{2}\Gamma_{t_k} S_{t_k}^2 \sigma^2 \left(Z_k^2 - 1\right)\Delta t, \qquad \text{Var}(\epsilon_k) = \frac{1}{2}\Gamma_{t_k}^2 S_{t_k}^4 \sigma^4 (\Delta t)^2$$

Summing $N$ independent step errors of variance $\mathcal{O}((\Delta t)^2) = \mathcal{O}(N^{-2})$ implies that the total terminal hedging-error variance scales as $N \cdot \mathcal{O}(N^{-2}) = \mathcal{O}(N^{-1})$, so the standard deviation of the terminal hedging error decays as:

$$\sigma_{\text{hedge}}(N) = \text{Std}\big(\text{P\&L}_T^{(N)}\big) = \mathcal{O}\!\left(N^{-1/2}\right) \implies \log \sigma_{\text{hedge}}(N) \approx c - 0.50 \log N$$
Rebalances $N$ Step Size $\Delta t$ Hedging Error Std Dev (20,000 Paths) Analytic $\mathcal{O}(N^{-1/2})$ Estimate
40.2500 yr4.284.34
160.0625 yr2.182.17
640.0156 yr1.101.09
252 (Daily)0.0040 yr0.560.55
Fitted Log–Log Slope (20,000 Paths)−0.49−0.50 (Theoretical)
Python Implementation — Black–Scholes Greeks, $10^6$ Monte Carlo & Discrete Delta Hedging [Show / Hide Code] 
import numpy as np
from scipy.stats import norm

def bs_call_and_delta(S: np.ndarray, K: float, r: float, sigma: float, tau: np.ndarray):
    tau = np.maximum(tau, 1e-12)
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * tau) / (sigma * np.sqrt(tau))
    d2 = d1 - sigma * np.sqrt(tau)
    price = S * norm.cdf(d1) - K * np.exp(-r * tau) * norm.cdf(d2)
    delta = norm.cdf(d1)
    return price, delta

def simulate_discrete_delta_hedge(S0=100.0, K=100.0, r=0.05, sigma=0.20, T=1.0,
                                  N=64, M=20_000, seed=42) -> float:
    rng = np.random.default_rng(seed)
    dt = T / N
    S = np.full(M, S0)
    c0, delta = bs_call_and_delta(S, K, r, sigma, T)
    cash = c0 - delta * S  # self-financing initial bond position

    for step in range(1, N + 1):
        Z = rng.standard_normal(M)
        S = S * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z)
        cash *= np.exp(r * dt)
        if step < N:
            _, new_delta = bs_call_and_delta(S, K, r, sigma, T - step * dt)
            cash -= (new_delta - delta) * S
            delta = new_delta

    payoff = np.maximum(S - K, 0.0)
    hedging_error = (delta * S + cash) - payoff
    return float(np.std(hedging_error, ddof=1))