26. Sensibilidad, escenarios y gestión de riesgos

26.1 El mapa de riesgos: cinco derivadas parciales

Los temas 23 a 25 resolvieron la pregunta «¿cuánto vale la opción?». Falta la pregunta que todo operador hace después: si cambia algo del mercado, ¿cuánto cambia mi posición? La respuesta son las griegas: las derivadas parciales del valor respecto de cada factor de riesgo. Cada una responde una pregunta puntual y, juntas, forman el mapa de riesgos de la posición.

En la put los signos no son los mismos: Δ = N(d₁) − 1 = −0,3632; Γ y ν son idénticas a las de la call (la curvatura y la exposición a la volatilidad son las mismas); y Θ y ρ cambian de signo en su segundo término. La notación n(d₁) es la densidad de la normal estándar evaluada en d₁ (≈ 0,3752 con los datos de referencia), mientras que N(·) es la acumulada que ya calculamos en el tema 23.

Idea central: una griega es una derivada local: describe bien lo que pasa con movimientos pequeños. Para shocks grandes hay que combinarla con escenarios de revalorización completa; el tema usa las dos herramientas y muestra cuándo falla cada una.

26.2 Delta: la exposición al subyacente

El delta es la primera derivada del valor respecto del subyacente: Δ = ∂V / ∂S. Para la call europea de Black-Scholes vale exactamente N(d₁), el mismo número que en el tema 23 aparecía como «probabilidad de terminar en el dinero bajo la medida neutral»; para la put es N(d₁) − 1.

La lectura práctica es de cartera replicante: una call equivale, localmente, a comprar 0,6368 unidades del subyacente y pedir prestado el resto (eso fue la réplica del tema 19, donde con un período el delta dio 0,5). Por eso cubrir una call vendida se hace comprando delta acciones; por eso el delta del put es negativo: un put equivale a vender el subyacente y colocar dinero. El árbol de producción del tema 25 midió el delta numéricamente y obtuvo 0,6365, casi idéntico al 0,6368 de la fórmula: la convergencia del árbol también alcanza a las griegas.

26.3 Gamma: la curvatura del delta

El delta no es constante: cambia con el precio del subyacente. La gamma mide ese cambio y es la segunda derivada del valor: Γ = ∂²V / ∂S² = n(d₁) / (S σ √T). Con los datos de referencia vale 0,0188 para la call y para la put.

Concretamente: si el subyacente sube 1, el delta de la call pasa de 0,6368 a ≈ 0,6556 (0,6368 + 0,0188). Esa convexidad es la que hace que las opciones «paguen más de lo que la pendiente sugiere» en ambos sentidos, y es la razón profunda por la que una cobertura delta no queda perfecta ante movimientos grandes.

La gamma es alta cuando la opción está cerca de terminar en el dinero y se acerca el vencimiento (el denominador S σ √T se achica); es baja cuando la opción está profundamente dentro o fuera del dinero. Los emisores suelen vigilarla más que al delta: una gamma grande significa que la cobertura hay que rebalancearla todo el tiempo.

26.4 Vega: la exposición a la volatilidad

La vega mide la sensibilidad a la volatilidad implícita: ν = ∂V / ∂σ = S n(d₁) √T. Es la única griega que afecta a la call y al put por igual en valor y en signo: con los datos de referencia, ν = 37,5240 por unidad de volatilidad, es decir 0,3752 por punto (un punto = 1 %).

Verificación con escenario completo: si la volatilidad pasa de 20 % a 25 % (+5 puntos), la call sube de 10,4506 a 12,3360, un cambio real de +1,8854. La aproximación lineal con vega daría 0,3752 × 5 = 1,8760: para la volatilidad la aproximación lineal es excelente, porque el valor es casi lineal en σ.

Atención con las unidades: hay dos convenciones para vega. «Por unidad» (37,5240) responde cuánto cambia el valor si σ cambia en 1,00 (es decir, 100 puntos). «Por punto» (0,3752) responde cuánto cambia si σ cambia en 0,01. En este curso, todas las tablas usan por punto; confundirlas genera errores de dos órdenes de magnitud.

26.5 Theta y rho: el tiempo y la tasa

La theta (Θ = ∂V / ∂t) mide cuánto pierde la opción por el solo paso del tiempo. Para la call de referencia: −6,4140 por año, es decir −0,0176 por día (se divide por 365). Para la put: −1,6579 por año, −0,0045 por día. La theta de la put es menos negativa porque su valor tiene menos «tiempo por cobrar»: parte del put ya está en el valor intrínseco de ejercer.

El primer término (el decaimiento por volatilidad pendiente) es común; el segundo cambia de signo: en la call juega en contra (el dinero del ejercicio se paga después), en la put juega a favor (el dinero del ejercicio se cobra después). Para el comprador de opciones la theta es negativa —paga por mantener la posición—; para el emisor es ingreso.

La rho (ρ = ∂V / ∂r) mide la sensibilidad a la tasa: 0,5323 por punto para la call y −0,4189 por punto para la put. Con tasas del 5 % es la griega menos relevante, pero no es cero: en el tema 22 vimos que la tasa es exactamente lo que da valor al ejercicio anticipado del put americano.

26.6 Griegas de Black-Scholes en código

La función griegasBS reúne la fórmula del tema 23 con las cinco derivadas de las secciones anteriores. Devuelve todo en las mismas unidades: delta en unidades de subyacente, gamma por unidad, vega y rho por unidad de volatilidad y de tasa (la conversión «por punto» se hace dividiendo por 100 al mostrar), y theta por año (por día se divide por 365).

function normalEstandar(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const densidad = Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
  const polinomio = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const acumulada = 1 - densidad * polinomio;
  return x >= 0 ? acumulada : 1 - acumulada;
}

function densidadNormal(x) {
  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
}

function griegasBS(S, K, r, sigma, T, tipo = 'call') {
  const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normalEstandar(d1);
  const nd2 = normalEstandar(d2);
  const descuento = Math.exp(-r * T);
  const raizT = Math.sqrt(T);
  const terminoTiempo = -S * densidadNormal(d1) * sigma / (2 * raizT);
  const vega = S * densidadNormal(d1) * raizT;
  const gamma = densidadNormal(d1) / (S * sigma * raizT);
  if (tipo === 'call') {
    return {
      precio: S * nd1 - K * descuento * nd2,
      delta: nd1,
      gamma,
      vega,
      theta: terminoTiempo - r * K * descuento * nd2,
      rho: K * T * descuento * nd2
    };
  }
  return {
    precio: K * descuento * (1 - nd2) - S * (1 - nd1),
    delta: nd1 - 1,
    gamma,
    vega,
    theta: terminoTiempo + r * K * descuento * (1 - nd2),
    rho: -K * T * descuento * (1 - nd2)
  };
}

const call = griegasBS(100, 100, 0.05, 0.2, 1, 'call');
console.log(call.precio.toFixed(4), call.delta.toFixed(4), call.gamma.toFixed(4), call.vega.toFixed(4), call.rho.toFixed(4));
console.log(call.theta.toFixed(4), (call.theta / 365).toFixed(4));
const put = griegasBS(100, 100, 0.05, 0.2, 1, 'put');
console.log(put.precio.toFixed(4), put.delta.toFixed(4), put.vega.toFixed(4), put.theta.toFixed(4), (put.theta / 365).toFixed(4), put.rho.toFixed(4), (put.rho / 100).toFixed(4));

Salida esperada: 10.4506 0.6368 0.0188 37.5240 53.2325 (precio, delta, gamma, vega y rho por unidad de la call), -6.4140 -0.0176 (theta anual y diaria) y 5.5735 -0.3632 37.5240 -1.6579 -0.0045 -41.8905 -0.4189 (put: precio, delta, vega, theta anual y diaria, rho por unidad y por punto). Los valores coinciden con la tabla del apartado 26.1 y con el laboratorio del tema 23.

26.7 Griegas numéricas con el árbol de producción

Las fórmulas cerradas existen porque el modelo es Black-Scholes. Cuando el instrumento no tiene fórmula (una americana, una barrera, una estrategia con ejercicio), las griegas se miden numéricamente con el árbol del tema 25:

• Delta: diferencia central con h = 1 % del spot: (V(S+h) − V(S−h)) / (2h).
• Gamma: a partir de los deltas de los dos primeros nodos del árbol: (Δarriba − Δabajo) / (S·u − S·d). Es mucho más estable que una segunda diferencia sobre valores, porque la segunda derivada amplifica el ruido de discretización.
• Vega y rho: recalibrando el árbol con σ ± 0,5 puntos y r ± 0,5 puntos, y dividiendo por 0,01.
• Theta: revalorizando el árbol con un día menos de vencimiento: V(T − 1/365) − V(T).

function pagoDeOpcion(tipo, strike) {
  return tipo === 'call'
    ? (precio) => Math.max(precio - strike, 0)
    : (precio) => Math.max(strike - precio, 0);
}

function valorarArbol(spot, u, d, p, descuento, pasos, pago, estilo) {
  let valores = [];
  for (let j = 0; j <= pasos; j++) {
    valores.push(pago(spot * Math.pow(u, j) * Math.pow(d, pasos - j)));
  }
  const americana = estilo === 'americana';
  for (let i = pasos - 1; i >= 0; i--) {
    for (let j = 0; j <= i; j++) {
      const continuacion = descuento * (p * valores[j + 1] + (1 - p) * valores[j]);
      if (americana) {
        const precio = spot * Math.pow(u, j) * Math.pow(d, i - j);
        valores[j] = Math.max(continuacion, pago(precio));
      } else {
        valores[j] = continuacion;
      }
    }
  }
  return valores[0];
}

function arbolCRR(spot, strike, tasa, volatilidad, tiempo, pasos, tipo, estilo) {
  const dt = tiempo / pasos;
  const u = Math.exp(volatilidad * Math.sqrt(dt));
  const d = 1 / u;
  const g = Math.exp(tasa * dt);
  const p = (g - d) / (u - d);
  return valorarArbol(spot, u, d, p, 1 / g, pasos, pagoDeOpcion(tipo, strike), estilo);
}

function deltaArbol(spot, u, d, p, descuento, pasos, pago, estilo) {
  const valorArriba = valorarArbol(spot * u, u, d, p, descuento, Math.max(pasos - 1, 0), pago, estilo);
  const valorAbajo = valorarArbol(spot * d, u, d, p, descuento, Math.max(pasos - 1, 0), pago, estilo);
  return (valorArriba - valorAbajo) / (spot * u - spot * d);
}

function griegasArbol(S, K, r, sigma, T, pasos, tipo) {
  const valor = arbolCRR(S, K, r, sigma, T, pasos, tipo, 'europea');
  const h = S * 0.01;
  const arriba = arbolCRR(S + h, K, r, sigma, T, pasos, tipo, 'europea');
  const abajo = arbolCRR(S - h, K, r, sigma, T, pasos, tipo, 'europea');
  const delta = (arriba - abajo) / (2 * h);

  const dt = T / pasos;
  const u = Math.exp(sigma * Math.sqrt(dt));
  const d = 1 / u;
  const g = Math.exp(r * dt);
  const p = (g - d) / (u - d);
  const pago = pagoDeOpcion(tipo, K);
  const deltaArriba = deltaArbol(S * u, u, d, p, 1 / g, pasos - 1, pago, 'europea');
  const deltaAbajo = deltaArbol(S * d, u, d, p, 1 / g, pasos - 1, pago, 'europea');
  const gamma = (deltaArriba - deltaAbajo) / (S * u - S * d);

  const volArriba = arbolCRR(S, K, r, sigma + 0.005, T, pasos, tipo, 'europea');
  const volAbajo = arbolCRR(S, K, r, sigma - 0.005, T, pasos, tipo, 'europea');
  const vega = (volArriba - volAbajo) / 0.01;

  const tasaArriba = arbolCRR(S, K, r + 0.005, sigma, T, pasos, tipo, 'europea');
  const tasaAbajo = arbolCRR(S, K, r - 0.005, sigma, T, pasos, tipo, 'europea');
  const rho = (tasaArriba - tasaAbajo) / 0.01;

  const ayer = arbolCRR(S, K, r, sigma, T - 1 / 365, pasos, tipo, 'europea');
  const theta = ayer - valor;

  return { precio: valor, delta, gamma, vega, theta, rho };
}

const call = griegasArbol(100, 100, 0.05, 0.2, 1, 100, 'call');
console.log(call.precio.toFixed(4), call.delta.toFixed(4), call.gamma.toFixed(4), (call.vega / 100).toFixed(4), call.theta.toFixed(4), (call.rho / 100).toFixed(4));
const put = griegasArbol(100, 100, 0.05, 0.2, 1, 100, 'put');
console.log(put.delta.toFixed(4), put.gamma.toFixed(4), (put.vega / 100).toFixed(4), put.theta.toFixed(4), (put.rho / 100).toFixed(4));

Salida esperada con N = 100: 10.4306 0.6365 0.0189 0.3743 -0.0176 0.5322 (call) y -0.3635 0.0189 0.3743 -0.0045 -0.4190 (put). Compáresela con los valores de fórmula: delta 0,6365 vs 0,6368; gamma 0,0189 vs 0,0188; vega 0,3743 vs 0,3752; theta −0,0176 vs −0,0176; rho 0,5322 vs 0,5323. El árbol mide todas las griegas con la misma calibración —incluso para opciones sin fórmula—; la fórmula cerrada queda como referencia de control.

26.8 Las griegas de una estrategia

Las griegas de una cartera se obtienen sumando las de cada pata, con su signo (compra +, venta −) y su cantidad. Eso permite leer de un vistazo el perfil de riesgo de las estructuras del tema 24 sin mirar cada payoff:

function normalEstandar(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const densidad = Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
  const polinomio = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const acumulada = 1 - densidad * polinomio;
  return x >= 0 ? acumulada : 1 - acumulada;
}

function densidadNormal(x) {
  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
}

function griegasBS(S, K, r, sigma, T, tipo = 'call') {
  const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normalEstandar(d1);
  const nd2 = normalEstandar(d2);
  const descuento = Math.exp(-r * T);
  const raizT = Math.sqrt(T);
  const terminoTiempo = -S * densidadNormal(d1) * sigma / (2 * raizT);
  const vega = S * densidadNormal(d1) * raizT;
  const gamma = densidadNormal(d1) / (S * sigma * raizT);
  if (tipo === 'call') {
    return {
      precio: S * nd1 - K * descuento * nd2,
      delta: nd1,
      gamma,
      vega,
      theta: terminoTiempo - r * K * descuento * nd2,
      rho: K * T * descuento * nd2
    };
  }
  return {
    precio: K * descuento * (1 - nd2) - S * (1 - nd1),
    delta: nd1 - 1,
    gamma,
    vega,
    theta: terminoTiempo + r * K * descuento * (1 - nd2),
    rho: -K * T * descuento * (1 - nd2)
  };
}

function sumarGriegas(componentes) {
  return componentes.reduce((acumulado, componente) => {
    const g = componente.g;
    return {
      delta: acumulado.delta + componente.cantidad * g.delta,
      gamma: acumulado.gamma + componente.cantidad * g.gamma,
      vega: acumulado.vega + componente.cantidad * g.vega,
      theta: acumulado.theta + componente.cantidad * g.theta
    };
  }, { delta: 0, gamma: 0, vega: 0, theta: 0 });
}

const bull = sumarGriegas([
  { cantidad: 1, g: griegasBS(100, 100, 0.05, 0.2, 1, 'call') },
  { cantidad: -1, g: griegasBS(100, 110, 0.05, 0.2, 1, 'call') }
]);
const straddle = sumarGriegas([
  { cantidad: 1, g: griegasBS(100, 100, 0.05, 0.2, 1, 'call') },
  { cantidad: 1, g: griegasBS(100, 100, 0.05, 0.2, 1, 'put') }
]);
const mariposa = sumarGriegas([
  { cantidad: 1, g: griegasBS(100, 90, 0.05, 0.2, 1, 'call') },
  { cantidad: -2, g: griegasBS(100, 100, 0.05, 0.2, 1, 'call') },
  { cantidad: 1, g: griegasBS(100, 110, 0.05, 0.2, 1, 'call') }
]);

const mostrar = (nombre, g) => console.log(nombre + ': delta ' + g.delta.toFixed(4) + '; gamma ' + g.gamma.toFixed(4) + '; vega/pt ' + (g.vega / 100).toFixed(4) + '; theta/día ' + (g.theta / 365).toFixed(4));
mostrar('Bull spread', bull);
mostrar('Straddle', straddle);
mostrar('Mariposa', mariposa);

Lectura de los resultados: el bull spread tiene delta reducido (0,1872: una fracción de la call sola) y gamma negativa pequeña (−0,0010): entre 100 y 110 la posición se aplana. El straddle duplica la gamma y la vega (0,0375 y 0,7505) y tiene la theta más negativa de las tres (−0,0221 por día): es la estructura que «paga por la volatilidad con el paso del tiempo». La mariposa queda prácticamente neutra en delta (−0,0143) con gamma negativa (−0,0042) y theta positiva (+0,0027 por día): el tiempo juega a favor de quien la compró bien, y vende dispersión (vega −0,0831).

26.9 Escenarios: cuando el shock es grande

Las griegas son derivadas locales; un escenario de mercado es una revalorización completa con el shock aplicado. La tabla compara, para la call de referencia, el cambio real de valor contra las aproximaciones de primer orden (delta) y de segundo orden (delta y gamma):

Las cifras enseñan tres reglas. Primero: con movimientos de ±5 % la aproximación con delta ya es aceptable, y con delta y gamma el error baja a centavos. Segundo: en shocks de ±20 %, la linealidad falla fuerte en el medio (delta «pierde» más de 5 unidades en el escenario −20 %); la curvatura corrige casi todo, pero el residuo sigue creciendo con el cubo del movimiento. Tercero: en volatilidad la linealidad es mucho mejor —con +5 puntos el cambio real es +1,8854 contra +1,8760 de la vega— porque el valor es casi lineal en σ.

Regla operativa: delta para movimientos de horas; delta y gamma para movimientos moderados (unos pocos por ciento); revalorización completa para escenarios y stress testing. Las griegas orientan; el escenario decide.

26.10 Cobertura delta: neutralizar el primer orden

Cubrir una opción es construir una cartera con delta cero: quien vendió una call compra Δ unidades del subyacente (0,6368 por opción); quien vendió un put vende 0,3632 unidades. Con eso, el primer orden del riesgo queda neutralizado. Lo que queda es la gamma: el residuo de la cobertura ante el movimiento, que crece con el cuadrado del shock: aproximadamente ½ Γ (ΔS)².

function normalEstandar(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const densidad = Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
  const polinomio = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const acumulada = 1 - densidad * polinomio;
  return x >= 0 ? acumulada : 1 - acumulada;
}

function densidadNormal(x) {
  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
}

function griegasBS(S, K, r, sigma, T, tipo = 'call') {
  const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normalEstandar(d1);
  const nd2 = normalEstandar(d2);
  const descuento = Math.exp(-r * T);
  const raizT = Math.sqrt(T);
  const terminoTiempo = -S * densidadNormal(d1) * sigma / (2 * raizT);
  const vega = S * densidadNormal(d1) * raizT;
  const gamma = densidadNormal(d1) / (S * sigma * raizT);
  if (tipo === 'call') {
    return {
      precio: S * nd1 - K * descuento * nd2,
      delta: nd1,
      gamma,
      vega,
      theta: terminoTiempo - r * K * descuento * nd2,
      rho: K * T * descuento * nd2
    };
  }
  return {
    precio: K * descuento * (1 - nd2) - S * (1 - nd1),
    delta: nd1 - 1,
    gamma,
    vega,
    theta: terminoTiempo + r * K * descuento * (1 - nd2),
    rho: -K * T * descuento * (1 - nd2)
  };
}

const base = griegasBS(100, 100, 0.05, 0.2, 1, 'call');
[1, -1, 2, -2].forEach(salto => {
  const nuevo = griegasBS(100 + salto, 100, 0.05, 0.2, 1, 'call').precio;
  const cambioCall = nuevo - base.precio;
  const pnl = cambioCall - base.delta * salto;
  console.log(salto, cambioCall.toFixed(4), (base.delta * salto).toFixed(4), pnl.toFixed(4));
});

La salida —1 0.6461 0.6368 0.0093, -1 -0.6274 -0.6368 0.0095, 2 1.3105 1.2737 0.0368 y -2 -1.2355 -1.2737 0.0382— muestra las cuatro piezas: el movimiento del salto, el cambio real de la call, la cobertura delta y el residuo. El residuo es positivo y crece con el cuadrado: 0,0093 y 0,0095 con ±1 (±½Γ); 0,0368 y 0,0382 con ±2 (cuatro veces más). Quien está largo de la opción y cubre con delta queda largo de gamma: gana en cualquier dirección. El emisor, simétricamente, queda corto de gamma y pierde en ambas.

Gestionar esa gamma es el trabajo real de la mesa: rebalancear la cobertura a medida que el delta cambia (comprar cuando sube, vender cuando baja), asumir los costos de transacción, y vigilar que la posición no quede con demasiado gamma cerca del vencimiento.

26.11 Laboratorio: panel de sensibilidad y escenarios

Ajustá los parámetros y observá el panel de riesgos completo: las cajas muestran las griegas de Black-Scholes (la referencia), la tabla de griegas las compara contra el árbol del tema 25 con la cantidad de pasos elegida, y las dos tablas de escenarios revalorizan la opción con shocks de spot y de volatilidad. Con tipo «put» cambian los signos de delta, theta y rho, mientras que gamma y vega permanecen iguales.

26.12 Gestión de riesgos en la práctica

Con las piezas de los temas 23 a 26 se arma un flujo de gestión completo: valuar con Black-Scholes o con el árbol, sumar las griegas de la cartera, correr escenarios de revalorización completa, cubrir el delta y controlar el residuo con la gamma. La rutina validarModelo del tema 25 se ejecuta antes de confiar en cualquier número nuevo.

• Límites de exposición: delta neta máxima por subyacente, gamma máxima (mide el trabajo de cobertura), vega máxima (mide el riesgo de volatilidad) y pérdida máxima en el peor escenario simulado.
• Escenarios obligatorios: caída y suba del spot (±5 %, ±10 %, ±20 %), saltos de volatilidad (±5 puntos), paso del tiempo (una semana) y combinaciones.
• Reevaluación: las griegas cambian todos los días; un panel sin fecha es un panel inútil. El laboratorio recalcula todo en vivo, con la misma calibración.

Alcance educativo: las griegas y escenarios de este tema suponen el modelo de Black-Scholes (volatilidad constante, sin saltos, sin costos). Son el punto de partida profesional, no una garantía: la validación sistemática y la prudencia en los límites siguen siendo responsabilidad de quien gestiona.

26.13 Errores comunes y controles

Los tropiezos más frecuentes al trabajar con griegas:

• Confundir unidades: vega y rho «por unidad» contra «por punto» (factor 100); theta anual contra diaria (factor 365). Es el error más común y el más caro.
• Usar griegas para shocks grandes: las derivadas describen el entorno local; un movimiento del 20 % exige revalorización completa (la tabla del apartado 26.9 es la prueba).
• Olvidar el signo del delta del put: el put tiene delta negativo; cubrirlo se hace vendiendo, no comprando, subyacente.
• Creer que la cobertura delta es perfecta: el residuo cuadrático (gamma) existe y crece con el cuadrado del movimiento; sin rebalanceo, la cobertura se degrada.
• Ignorar el factor tiempo de la gamma: cerca del vencimiento y en el dinero, la gamma se dispara y el rebalanceo se vuelve frenético.
• Agregar griegas sin multiplicadores: cantidades, contratos y signos deben respetarse pata por pata antes de sumar.
• Tratar los números del modelo como verdad: las griegas son del modelo; si la volatilidad o los supuestos cambian, el riesgo real difiere del medido.

Lista de control de una posición con derivados:

1. ¿Están calculadas las cinco griegas (o las relevantes) con una calibración validada?
2. ¿Se respetaron unidades y signos al agregar la cartera?
3. ¿Se corrieron escenarios de revalorización completa además de las griegas?
4. ¿La delta neta está dentro del límite? ¿Y la gamma y la vega?
5. ¿Hay un plan de rebalanceo y una estimación de sus costos?
6. ¿La pérdida en el peor escenario es tolerable?

26.14 Ejercicio propuesto: las griegas de otro precio de ejercicio

Tomá la misma call de referencia pero con spot S = 105 (la opción queda en el dinero «por dentro»), manteniendo K = 100, r = 5 %, σ = 20 %, T = 1.

1. Calculá precio, delta, gamma, vega por punto y theta por día con griegasBS y verificá 13,8579; 0,7237; 0,0159; 0,3512 y −0,0181.
2. ¿Por qué el delta subió respecto de 0,6368? ¿Por qué la gamma y la vega bajaron?
3. ¿Qué pasó con la theta? ¿Es más o menos negativa que la de la opción en el dinero exacto?

function normalEstandar(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const densidad = Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
  const polinomio = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const acumulada = 1 - densidad * polinomio;
  return x >= 0 ? acumulada : 1 - acumulada;
}

function densidadNormal(x) {
  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
}

function griegasBS(S, K, r, sigma, T, tipo = 'call') {
  const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normalEstandar(d1);
  const nd2 = normalEstandar(d2);
  const descuento = Math.exp(-r * T);
  const raizT = Math.sqrt(T);
  const terminoTiempo = -S * densidadNormal(d1) * sigma / (2 * raizT);
  const vega = S * densidadNormal(d1) * raizT;
  const gamma = densidadNormal(d1) / (S * sigma * raizT);
  if (tipo === 'call') {
    return {
      precio: S * nd1 - K * descuento * nd2,
      delta: nd1,
      gamma,
      vega,
      theta: terminoTiempo - r * K * descuento * nd2,
      rho: K * T * descuento * nd2
    };
  }
  return {
    precio: K * descuento * (1 - nd2) - S * (1 - nd1),
    delta: nd1 - 1,
    gamma,
    vega,
    theta: terminoTiempo + r * K * descuento * (1 - nd2),
    rho: -K * T * descuento * (1 - nd2)
  };
}

const g105 = griegasBS(105, 100, 0.05, 0.2, 1, 'call');
console.log(g105.precio.toFixed(4), g105.delta.toFixed(4), g105.gamma.toFixed(4), (g105.vega / 100).toFixed(4), (g105.theta / 365).toFixed(4));

26.15 Ejercicio adicional: escenario y cobertura estática

Usá la call de referencia (precio 10,4506, delta 0,6368, gamma 0,0188) y respondé:

1. Si el spot cae 10 % (de 100 a 90), ¿cuánto pierde realmente la call (5,3594)? Compará con la aproximación de delta (−6,3683) y con la de delta y gamma (−5,4302).
2. Quien vendió la call a 10,4506 y cubrió comprando 0,6368 acciones a 100, ¿qué resultado tiene en el escenario S = 90? Verificá −1,0089.
3. ¿Qué debería hacer el emisor cubierto para no acumular ese residuo?

function normalEstandar(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const densidad = Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
  const polinomio = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const acumulada = 1 - densidad * polinomio;
  return x >= 0 ? acumulada : 1 - acumulada;
}

function densidadNormal(x) {
  return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
}

function griegasBS(S, K, r, sigma, T, tipo = 'call') {
  const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normalEstandar(d1);
  const nd2 = normalEstandar(d2);
  const descuento = Math.exp(-r * T);
  const raizT = Math.sqrt(T);
  const terminoTiempo = -S * densidadNormal(d1) * sigma / (2 * raizT);
  const vega = S * densidadNormal(d1) * raizT;
  const gamma = densidadNormal(d1) / (S * sigma * raizT);
  if (tipo === 'call') {
    return {
      precio: S * nd1 - K * descuento * nd2,
      delta: nd1,
      gamma,
      vega,
      theta: terminoTiempo - r * K * descuento * nd2,
      rho: K * T * descuento * nd2
    };
  }
  return {
    precio: K * descuento * (1 - nd2) - S * (1 - nd1),
    delta: nd1 - 1,
    gamma,
    vega,
    theta: terminoTiempo + r * K * descuento * (1 - nd2),
    rho: -K * T * descuento * (1 - nd2)
  };
}

const base = griegasBS(100, 100, 0.05, 0.2, 1, 'call');
const c90 = griegasBS(90, 100, 0.05, 0.2, 1, 'call').precio;
const cambio = c90 - base.precio;
const aproxDelta = base.delta * -10;
const aproxDeltaGamma = aproxDelta + 0.5 * base.gamma * 100;

console.log(cambio.toFixed(4), aproxDelta.toFixed(4), aproxDeltaGamma.toFixed(4));
const resultadoEmisor = -cambio + base.delta * -10;
console.log(resultadoEmisor.toFixed(4));

26.16 Próximo paso: el proyecto integrador

Con este tema queda completo el mapa de herramientas: valoración con fórmula cerrada (tema 23), valoración numérica con el árbol validado (tema 25), estrategias y payoffs (tema 24) y ahora sensibilidad, escenarios y gestión de riesgos. El tema 27 las reúne en un único programa: el valuador de derivados con detección de arbitrajes.

• Interfaz única para calls, puts, estrategias y opciones americanas.
• Pantalla de griegas y escenarios como la de este tema, sobre cualquier posición armada.
• Chequeos de arbitraje y validación permanente (paridad put-call, cotas, convergencia).

La lección de este tema: el precio dice qué vale una posición hoy; las griegas y los escenarios dicen qué puede pasarle mañana. Un valuador sin panel de riesgos está a mitad de camino; el integrador lo completa.