Why Delta Hedging Does Not Dominate a Call Option

# Replicating call option by cash and stock under BS model


# Replicating call option by cash and stock under BS model












Suppose we are in a market following the Black-Scholes (BS) model, and we want to use cash and stock to replicate a call option. We perform Taylor expansion of the call price $ V $ with respect to the stock price $ S $: $$ V(S_t + s) = V(S_t) + \Delta_{S_t}s + \frac{1}{2}s^2\Gamma_{S_t} + o(s^2). $$ From this, we deduce the following inequality: $$ V(S_t + s) - V(S_t) > \Delta_{S_t}s \quad\quad\quad (1). $$ Our replicating portfolio is given by: $$ \Pi = x + \sum_{t=1}^{T} \Delta_{t-1}(S_t - S_{t-1}), $$ where $x$ is the call price at time $ t=0 $.

My question is: at each time point $ t $, if my understanding is correct,$V$ should dominate $ \Pi $ according to equation (1). However, the graph shows a reverse pattern. Can anyone explain why the graph exhibits this behavior?

Code:

```
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
rng = np.random.default_rng()
class BS_path:
  def __init__(self, mu, sigma, n_path, n_timestep, S_0, T):
    self.mu = mu
    self.sigma = sigma
    self.n_path = n_path
    self.n_timestep = n_timestep
    self.dt = T/self.n_timestep
    self.t = np.linspace(0,T,n_timestep+1)
    self.normal = rng.standard_normal(size=(n_path,n_timestep))
    self.initial = S_0
    self.w = np.concatenate((np.zeros((n_path, 1)), np.cumsum(self.normal * np.sqrt(self.dt), axis=1)), axis=1) # Brownian Motion path
    self.var = S_0**2 * np.exp(2*mu*T) * (np.exp(sigma**2*T) - 1)
    self.mean = S_0 * np.exp(mu*T)

  def stock_path(self,plot = False):
    S = self.initial * np.exp((self.mu - 0.5 * self.sigma**2) * self.t + self.sigma * self.w)
    return S

class hedging_simulator(BS_path):
    def __init__(self, mu, sigma, n_path, n_timestep, S_0, T, strike):
        super().__init__(mu, sigma, n_path, n_timestep, S_0, T)
        self.maturity = T - self.t
        self.strike = strike

    def theoretical_price(self):
        S_t = self.stock_path()
        K = self.strike
        ds = np.diff(S_t)
        r = self.mu
        sigma = self.sigma

        d1 = (np.log(S_t / K) + (r + 0.5 * sigma**2) * self.maturity) / (sigma * np.sqrt(self.maturity) + 1e-9)
        d2 = d1 - sigma * np.sqrt(self.maturity)

        call_price = S_t * norm.cdf(d1) - K * np.exp(-r * self.maturity) * norm.cdf(d2)
        delta = norm.cdf(d1)
        return call_price, delta, ds, S_t

    def delta_hedge(self):
      call_price, delta, ds, _ = self.theoretical_price()
      x = call_price[0,0]
      portfolio = x + np.cumsum(delta[0,:-1] * ds)
      plt.figure(figsize=(10, 5),dpi = 120)
      plt.plot(self.t[1:], call_price[0,1:], label='option price')
      plt.plot(self.t[1:], portfolio, label='hedging portfolio', linestyle='--')
      plt.title('Hedging process')
      plt.xlabel('Time')
      plt.ylabel('price')
      plt.legend()
      plt.grid(True)
      plt.show()
      

hs = hedging_simulator(mu = .05, sigma=0.16, n_path=1, n_timestep=1000, S_0=100, T = 1, strike = 100)
hs.delta_hedge()
```

## Answer by Frido (score 4, accepted)

https://quant.stackexchange.com/a/81179

Without having read your code, what happened with the option's theta? This is where I believe you erred.

In general, any derivation that results in the 'conclusion' that the self-financing replicating portfolio dominates or is dominated by the derivative for all paths is fallacious because that would imply arbitrage.

If you take theta into account, and for simplicity ignoring model-misspecification and discrete hedge intervals, what you will arrive at is $$ V(S_T,K, T) = V(S_t,K,t) + \int_t^T \Delta(S_u,K,u) dS_u $$

Clearly this does not imply your equation (1) $$ dV(S_t,K,t) > \Delta(S_t,K,t) dS_t $$