Supongamos que estamos en un mercado siguiendo el modelo Black-Scholes (BS), y queremos usar efectivo y acciones para replicar una opción de compra.
Realizamos la expansión de Taylor del precio de la llamada $ V $ con respecto al precio de la acción $ S $: $$ V(S_t + s) = V(S_t) + \Delta_{S_t}s + \frac{1}{2}s^2\Gamma_{S_t} + o(s^2). $$ De esto, deducimos la siguiente desigualdad:
$$ V(S_t + s) - V(S_t) > \Delta_{S_t}s \quad\quad\quad (1). $$
Nuestra cartera de replicación está dada por:
$$ \Pi = x + \sum_{t=1}^{T} \Delta_{t-1}(S_t - S_{t-1}), $$
donde $x$ es el precio de la llamada en el momento $ t=0 $.
Mi pregunta es: en cada momento $ t $, si mi entendimiento es correcto, $V$ debería dominar a $ \Pi $ según la ecuación (1). Sin embargo, el gráfico muestra un patrón inverso. ¿Alguien puede explicar por qué el gráfico muestra este comportamiento?
Código:
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) # Camino de Movimiento Browniano
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='precio de la opción')
plt.plot(self.t[1:], portfolio, label='cartera de cobertura', linestyle='--')
plt.title('Proceso de cobertura')
plt.xlabel('Tiempo')
plt.ylabel('precio')
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()
