23. Introducción al modelo Black-Scholes y sus supuestos

23.1 De los árboles a una fórmula cerrada

El árbol binomial responde «cuánto vale una opción» con un procedimiento: construir el árbol, recorrerlo hacia atrás, comparar ejercicio y continuación. En 1973, Fischer Black, Myron Scholes y Robert Merton publicaron una fórmula cerrada que obtiene el precio de una opción europea directamente de cinco datos: S0, K, r, σ y T. Su impacto fue tan profundo —y su uso tan masivo en los mercados— que Scholes y Merton recibieron el Premio Nobel de Economía en 1997.

Idea central: Black-Scholes no reemplaza al árbol: es su límite cuando los pasos se hacen infinitamente pequeños. El mismo principio de no arbitraje y de esperanza descontada, con una distribución continua del precio final.

23.2 El movimiento continuo del activo

En el árbol, el precio da saltos discretos de un nodo a otro. Cuando los pasos se acortan y se multiplican, el precio pasa a moverse de manera continua, con infinitos movimientos pequeños. El modelo de Black-Scholes supone que ese movimiento tiene una forma precisa: el logaritmo del precio final se distribuye normalmente (el precio es «lognormal»), con dos parámetros:

• La tendencia neutral: bajo la probabilidad neutral al riesgo del tema 20, el activo rinde la tasa libre de riesgo r. Es la misma idea del árbol: no aparece la probabilidad real de subida.
• La volatilidad σ: mide la dispersión de los retornos. Es la desviación estándar anualizada del rendimiento del activo: a mayor σ, más lejos pueden quedar los precios finales respecto de hoy.

En el límite continuo, elegir u y d se reduce a elegir σ. Por eso la fórmula final depende de σ y no de factores por período: la volatilidad resume la incertidumbre del activo.

23.3 La fórmula de Black-Scholes

Para una call y una put europeas, sin dividendos, con tasa r y volatilidad σ constantes y tiempo T hasta el vencimiento:

N(·) es la función de distribución de la normal estándar: N(x) es la probabilidad de que una normal estándar sea menor o igual que x. Su valor se obtiene de tablas, de una calculadora o de una aproximación numérica, como la que implementaremos en este tema.

Dos detalles de notación: el descuento usa capitalización continua, e−rT, que es el equivalente continuo del factor D del curso; y la fórmula de la put no es independiente de la de la call: se obtiene directamente de la paridad put-call del tema 17, P = C − S0 + K × e−rT.

23.4 Las piezas: N(d₁) y N(d₂)

La estructura de la fórmula de la call, S0 × N(d1) − K × e−rT × N(d2), es la de una cartera replicante, como en el tema 19: una posición en el activo menos una deuda en el bono. Sus dos pesos tienen nombre propio:

23.5 Los supuestos del modelo

Detrás de la fórmula hay una lista de supuestos que conviene conocer uno por uno, porque son también sus límites:

1. Precio lognormal y continuo: el activo sigue un movimiento browniano geométrico; no hay saltos ni interrupciones de negociación.
2. Volatilidad constante: σ es la misma para todos los niveles de precio y para todo el horizonte.
3. Tasa constante y libre de riesgo: se puede prestar y pedir prestado a r sin riesgo de contraparte, para cualquier plazo.
4. Sin dividendos: el activo no reparte pagos entre hoy y T (la extensión de Merton incorpora un rendimiento continuo por dividendos quitándolo del drift).
5. Ejercicio europeo: la opción sólo puede ejercerse en T. Las americanas quedan fuera de esta fórmula (y siguen necesitando el árbol, como en el tema 22).
6. Mercados sin fricciones: sin comisiones ni impuestos, activo infinitamente divisible, se puede vender en corto y operar en cualquier instante de manera continua.
7. No hay arbitraje y el mercado es completo: todo pago puede replicarse, y la fórmula es el costo único de esa réplica.

23.6 El ejemplo de referencia

Datos: S0 = $100, K = $100, r = 5 % anual continuo, σ = 20 % anual y T = 1 año. Primero las piezas del cálculo:

Con esos valores, la call y la put resultan:

Interpretación: la call vale $10,45, de los cuales $63,68 son la posición en el activo ponderada por el delta y $53,23 la deuda descontada. La probabilidad neutral de terminar dentro del dinero es N(d2) = 55,96 %, y el delta es N(d1) = 0,6368. Comprobación de paridad: C − P = 10,4506 − 5,5735 = 4,8771 y S0 − K × e−rT = 100 − 95,1229 = 4,8771 ✓.

23.7 Volatilidad: el parámetro que no se observa

De los cinco datos de la fórmula, cuatro son observables: el spot se ve en pantalla, el strike y el vencimiento son contractuales y la tasa se lee del mercado. La volatilidad σ, en cambio, no cotiza en ningún lado: hay que estimarla. Esa es la gran fragilidad y, a la vez, la oportunidad del modelo.

La prueba más directa de su importancia: manteniendo todo lo demás igual, en el ejemplo de referencia la call valdría $8,5917 con σ = 15 %, $10,4506 con σ = 20 % y $12,3360 con σ = 25 %. Cuanta más volatilidad, más chance de terminar bien dentro del dinero y más vale la opción: quien compra opciones está «largo en volatilidad».

Existen dos caminos para asignarle un número a σ. El primero es histórico: estimarla con los retornos pasados del activo. El segundo es el inverso: dado el precio de mercado de una opción, despejar la σ que lo reproduce, la volatilidad implícita. En la práctica se usa la segunda vía, y sus desviaciones respecto de un σ constante —la «sonrisa de volatilidad»— son la evidencia más clara de que los supuestos del modelo son una aproximación.

23.8 La conexión con el árbol binomial

La fórmula no es un modelo distinto: es el límite del árbol del tema 21. Calibrando cada paso con u = eσ√Δt, d = 1 / u y capitalizando el bono con erΔt por período, el valor del árbol converge a la fórmula a medida que N crece:

La convergencia no es monótona —los valores oscilan alrededor del límite— pero la diferencia se desploma a medida que N crece: con 500 pasos el árbol difiere del límite en menos de medio centavo. Esta es la razón por la que ambos instrumentos conviven: la fórmula es cómoda y exacta bajo sus supuestos, y el árbol sigue siendo necesario cuando el ejercicio anticipado o los dividendos rompen esos supuestos.

23.9 Implementación en JavaScript

La función de distribución normal se puede aproximar con el polinomio de Abramowitz y Stegun, que da valores exactos hasta el séptimo decimal en todo el rango relevante. Con ella, la fórmula de Black-Scholes se escribe en pocas líneas.

function normalEstandar(x) {
  // Aproximación de Abramowitz y Stegun (7.1.26)
  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 blackScholes(spot, strike, tasa, volatilidad, tiempo, tipo = 'call') {
  const raizTiempo = Math.sqrt(tiempo);
  const d1 = (Math.log(spot / strike) + (tasa + volatilidad * volatilidad / 2) * tiempo) / (volatilidad * raizTiempo);
  const d2 = d1 - volatilidad * raizTiempo;
  if (tipo === 'call') {
    return spot * normalEstandar(d1) - strike * Math.exp(-tasa * tiempo) * normalEstandar(d2);
  }
  return strike * Math.exp(-tasa * tiempo) * normalEstandar(-d2) - spot * normalEstandar(-d1);
}

console.log(blackScholes(100, 100, 0.05, 0.2, 1).toFixed(4));        // "10.4506"
console.log(blackScholes(100, 100, 0.05, 0.2, 1, 'put').toFixed(4)); // "5.5735"

Con las mismas piezas a la vista se pueden explicar los números del apartado 23.6 y verificar la paridad put-call dentro del modelo.

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;
}

const S = 100, K = 100, r = 0.05, sigma = 0.2, T = 1;
const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
const d2 = d1 - sigma * Math.sqrt(T);

console.log(d1.toFixed(4));                     // "0.3500"
console.log(d2.toFixed(4));                     // "0.1500"
console.log(normalEstandar(d1).toFixed(4));     // "0.6368" (delta)
console.log(normalEstandar(d2).toFixed(4));     // "0.5596" (probabilidad ITM)
console.log((K * Math.exp(-r * T)).toFixed(4)); // "95.1229" (strike descontado)

23.10 Laboratorio: calculadora Black-Scholes

Ingresá el spot, el strike, la tasa continua anual, la volatilidad anual y el tiempo en años. La calculadora muestra la call, la put y el delta, desglosa las piezas del cálculo —incluida la verificación de la paridad— y arma una tabla de sensibilidad a la volatilidad alrededor del valor ingresado.

23.11 Supuestos, límites y controles

Límites prácticos que conviene tener presentes antes de usar la fórmula como si fuera la verdad:

• La realidad no es lognormal: los precios tienen saltos y colas más gruesas que la normal; la fórmula subvalora eventos extremos.
• σ no es constante: la sonrisa de volatilidad muestra que el mercado usa distintas σ para distintos strikes y vencimientos.
• La cobertura continua no es gratis: replicar deltas exige operar; con costos, la réplica perfecta es una idealización.
• Sólo opciones europeas: para americanas o con dividendos fuertes, el árbol (tema 22) o métodos numéricos son el camino.

Lista de control de la calculadora:

1. ¿La tasa es continua y anual, y T está en años? ¿La volatilidad es anualizada?
2. ¿Es una opción europea sin dividendos? Si no, la fórmula simple no aplica directamente.
3. ¿Se cumple S0 > 0, K > 0, σ > 0 y T > 0?
4. ¿Se verificó la paridad C − P = S0 − K × e−rT?
5. ¿Se respeta la cota inferior C ≥ max(S0 − K × e−rT, 0) del tema 16?
6. ¿Los valores tienen sentido económico? (Una call nunca vale más que el activo; una put, más que K × e−rT.)

Alcance educativo: el curso explica modelos y relaciones de valoración. Los precios obtenidos dependen de los supuestos del modelo y no constituyen recomendaciones de inversión.

23.12 Próximo paso: el módulo de implementación

Con Black-Scholes queda completa la caja de herramientas conceptuales del curso: cotas y paridad (módulo 3), replicación y valoración neutral (módulo 4), y la fórmula cerrada como límite del árbol. El quinto módulo pone todo a funcionar en código:

• Tema 24: funciones para calcular payoffs y resultados de estrategias completas, combinando los instrumentos de los temas 13 a 18.
• Tema 25: implementación de un árbol binomial de producción y su validación sistemática: convergencia a Black-Scholes, paridad, activo y ejercicio anticipado.
• Tema 26: sensibilidad y gestión de riesgos: delta, gamma, vega y theta, escenarios y coberturas.
• Tema 27: el proyecto integrador: un valuador de derivados con detección de arbitrajes, que reúne árbol, fórmula y controles.

23.13 Ejercicio propuesto

Una acción cotiza a S0 = $100; la tasa continua anual es del 5 %, la volatilidad anual del 20 %, el vencimiento es T = 1 año y no hay dividendos. Se valoran una call y una put europeas con K = $100.

1. Calculá d1 y d2.
2. Obtené N(d1), N(d2) y sus complementos (la calculadora del laboratorio sirve).
3. Calculá la prima de la call y de la put.
4. Verificá la paridad put-call con K × e−rT = 95,1229.
5. ¿Qué le pasa a la call si σ sube al 30 %? Respondé primero de forma cualitativa y después calculá las nuevas primas: call $14,2312 y put $9,3542.

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 blackScholes(spot, strike, tasa, volatilidad, tiempo, tipo = 'call') {
  const raizTiempo = Math.sqrt(tiempo);
  const d1 = (Math.log(spot / strike) + (tasa + volatilidad * volatilidad / 2) * tiempo) / (volatilidad * raizTiempo);
  const d2 = d1 - volatilidad * raizTiempo;
  if (tipo === 'call') {
    return spot * normalEstandar(d1) - strike * Math.exp(-tasa * tiempo) * normalEstandar(d2);
  }
  return strike * Math.exp(-tasa * tiempo) * normalEstandar(-d2) - spot * normalEstandar(-d1);
}

console.log(blackScholes(100, 100, 0.05, 0.2, 1).toFixed(4));        // "10.4506"
console.log(blackScholes(100, 100, 0.05, 0.2, 1, 'put').toFixed(4)); // "5.5735"
console.log(blackScholes(100, 100, 0.05, 0.3, 1).toFixed(4));        // "14.2312"
console.log(blackScholes(100, 100, 0.05, 0.3, 1, 'put').toFixed(4)); // "9.3542"

23.14 Ejercicio adicional: una put y su probabilidad

Se quiere valorar una put europea con K = $90 sobre un activo que cotiza a $100, con tasa continua del 3 % anual, volatilidad del 25 % anual y T = 0,5 años, sin dividendos.

1. Calculá d1 y d2.
2. Calculá la prima de la call y de la put; verificá la paridad con K × e−rT = 88,6601.
3. ¿Cuál es la probabilidad neutral de que la put termine dentro del dinero? (Es N(−d2): la put paga cuando ST < K.)
4. ¿Por qué la put vale tan poco comparada con la call, si su probabilidad de pagar no es despreciable?

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 blackScholes(spot, strike, tasa, volatilidad, tiempo, tipo = 'call') {
  const raizTiempo = Math.sqrt(tiempo);
  const d1 = (Math.log(spot / strike) + (tasa + volatilidad * volatilidad / 2) * tiempo) / (volatilidad * raizTiempo);
  const d2 = d1 - volatilidad * raizTiempo;
  if (tipo === 'call') {
    return spot * normalEstandar(d1) - strike * Math.exp(-tasa * tiempo) * normalEstandar(d2);
  }
  return strike * Math.exp(-tasa * tiempo) * normalEstandar(-d2) - spot * normalEstandar(-d1);
}

console.log(blackScholes(100, 90, 0.03, 0.25, 0.5).toFixed(4));        // "13.7909"
console.log(blackScholes(100, 90, 0.03, 0.25, 0.5, 'put').toFixed(4)); // "2.4509"

const d1 = (Math.log(100 / 90) + (0.03 + 0.25 * 0.25 / 2) * 0.5) / (0.25 * Math.sqrt(0.5));
const d2 = d1 - 0.25 * Math.sqrt(0.5);
console.log(normalEstandar(-d2).toFixed(4)); // "0.2768" (probabilidad ITM de la put)