Opciones en R: Parte 5

Opciones americanas con el modelo binomial

Intro

En este tutorial vamos a cubrir lo siguiente:

• Equivalencia del call americano y el call europeo

• Pricing del put americano con el modelo binomial

1 Equivalencia del call americano y el call europeo

El call americano y el call europeo sobre una acción que no pagan dividendos valen exactamente lo mismo. Vamos a probar esta afirmación con las siguientes 2 proposiciones:

1.1 El valor mínimo de un call

La primera proposición dice lo siguiente:

Consideremos una opción call sobre una acción que no paga dividendos antes de su expiración al tiempo T. En ese caso, el valor del call, C_0, está dado por:

C_0 >= max(S_0 - K*exp(-r*T), 0)

donde S_0: precio spot de la acción
      K  : strike de la opción call
      r  : tasa libre de riesgo

Podemos probarlo de la misma manera que hicimos para la proposición del put-call parity, analizando los flujos de los diferentes escenarios posibles:

En el tiempo t=0 vamos a hacer lo siguiente: comprar la acción, pedir prestada una cantidad equivalente al strike del call a la tasa libre de riesgo, y vender el call. El flujo entonces en este día sería de - S_0 + K*exp(-r*T) + C_0.

En el tiempo t=T hay de dos, o el precio de la acción S_T es menor que el strike pactado K o es mayor que él. Veamos que sucede en ambos casos:

Si es menor (S_T < K):

El call expiró OTM, por lo que no será ejercido. Al mismo tiempo, tengo que regresar los fondos que pedí prestados y vendo la acción. Por lo tanto recibo S_T y pago K. Cómo quedamos en que S_T < K, perdí dinero en esta situación:

S_T - K < 0

Si es mayor (S_T > K):

El call expira ITM y será ejercido por el comprador. Yo perderé la diferencia entre ambos precios S_T y K. Igual que en el escenario anterior, puedo vender la acción por S_T y tendré que pagar K de vuelta. En esta situación, no hay ganancia:

S_T - K - (S_T - K) = 0

Por lo tanto, si es seguro que el flujo futuro de esta estrategia no será positivo, lo lógico sería que el flujo inicial sí fuera positivo (¿quién en su sano juicio pagaría para tener una pérdida asegurada?). Por lo tanto:

-S_0 + K*exp(-r*T) + C_0 > 0
∴ C_0 > S_0 - K*exp(-r*T)

Y, como el call no puede valer menos de 0, concluímos que:

C_0 >= max(S_0 - K*exp(-r*T), 0)

Y la proposición inicial queda demostrada. Esto nos va a llevar a una conclusión interesante a continuación.

1.2 Nunca es conveniente ejercer un call de manera anticipada

La segunda proposición dice lo siguiente:

Si existe un call americano sobre una acción que no paga dividendos antes de su expiración en el tiempo T, entonces nunca es óptimo ejercer la opción de manera anticipada.

Veamos esto con un ejemplo práctico:

Imagina que tienes una opción call con un strike K=80 sobre una acción con un precio spot S=83 en alguna fecha t<T. Si ejerces el call, podras comprar la acción en $80 y venderla inmediatamente por $83, ganando $3 en el proceso. Sin embargo, demostramos anteriormente que el precio mínimo de un call es, mínimo, max(S_0 - K*exp(-r*T), 0). Suponiendo que r=0.06, y faltan 6 meses para expiración, eso nos da:

C = max(83 - 80*exp(-0.06*.05), 0) = 5.36

Nos conviene más vender la opción y recibir $5.36 que ejercerla y recibir sólo $3, y la proposición inicial queda demostrada. Siempre que r > 0 y S > K sea cierto, el valor del call va a ser mayor que la diferencia entre S y K, no importa que valores tomen para r, S, K, y T.

Estos dos argumentos nos llevan a la siguiente conclusión: el precio de un call americano y un call europeo sobre una acción que no paga dividendos antes de su fecha de expiración T es el mismo.

Todo este asunto fue necesario para justificar lo siguiente: no necesitamos ajustar nuestro modelo binomial para los calls, sólo será necesario hacerlo para los puts.

2 Pricing del put americano con el modelo binomial

Ahora pasemos a lo interesante, encontrar el precio de un put americano con el modelo binomial (cosa que con el modelo Black-Scholes no es posible). Veamos que pasa en el caso de los puts con el siguiente ejemplo de 3 periodos:

Para el put europeo no hay opción de ejercicio temprano, así que el procedimiento es el mismo que para el call del tutorial anterior, los precios en t=1 se encuentran descontando los pagos en t=2 con los precios de estado q_arriba y q_abajo, y haremos lo mismo para encontrar el precio en t=0:

Y obtenemos un precio de $0.25 para t=0. En el caso del put americano, existe la opción de ejercicio temprano, así que el precio no será sólo dependiente de los precios de estado, sino del beneficio obtenido por ejercicio temprano:

Put americano = max(max(K - S, 0), q_arriba*precio_arriba + q_abajo*precio_abajo)

Y obtenemos un precio de $0.44 para el put americano. Para este caso, sí va a ser necesario obtener el precio del put calculándolo hacia atrás, no es posible usar una fórmula cerrada como para el put europeo.

Antes de pasar a la implementación de este procedimiento en R, veamos cómo los calls americanos y europeos tienen el mismo precio aunque incluyamos el ejercicio temprano, para reforzar el concepto de la sección anterior:

2.1 Implementación del modelo en R

La implementación del pricing de opciones americanas en R es el siguiente (recuerden agregarlo a su archivo de herramientas.R):

binom.ame.model <- function(p_arriba, p_abajo, rf, spot,
                            strike, periodos, tipo = "c") {
  
  # Calcula el precio teórico de una opción americana usando el
  # modelo binomial (1979)
  # Se necesita:
  # - p_arriba: movimiento hacia arriba (porcentaje en decimal)
  # - p_abajo: movimiento hacia abajo (porcentaje en decimal)
  # - rf: tasa libre de riesgo (anualizada)
  # - spot: precio spot del subyacente al momento de valuación
  # - strike: strike de la opción
  # - periodos: numero de pasos en la látice binomial
  # - tipo: "c" (call) o "p" (put)
  # Se regresa:
  # El precio de la opción según el modelo binomial (1979)
  
  tipo = tolower(tipo)
  
  if (!(tipo %in% c("c", "p"))) {
    stop("El tipo de la opción es incorrecto.
         Elige uno de 'c' (call) o 'p' (put).")
  }
  
  q_arriba <- (rf - p_abajo)/((1 + rf)*(p_arriba - p_abajo))
  q_abajo <- (p_arriba - rf)/((1 + rf)*(p_arriba - p_abajo))
  
  estados <- seq(0, periodos)
  
  if (tipo == "c") {
    value <- binom(periodos, estados)*q_arriba^estados*
      q_abajo^(periodos - estados)*
      (spot*(1 + p_arriba)^estados*
         (1 + p_abajo)^(periodos - estados) - strike)

    value <- sum(pmax(value, 0))
  } else {
    put_T <- pmax(strike -
                    spot*(1 + p_arriba)^estados*
                    (1 + p_abajo)^(periodos - estados), 0)
    
    indices <- seq(periodos - 1, 0)
    
    for (indice in indices) {
      estados <-seq(0, indice)
      
      put_t <- pmax(strike - spot*(1+p_arriba)^estados*
                      (1+p_abajo)^(indice - estados),
                    q_abajo*put_T[estados + 1] +
                      q_arriba*put_T[estados + 2])

      put_T <- put_t
    }
    
    value <- put_t
  }
  
  return(value)
}

Como ya acordamos, el cálculo para los calls no es necesario cambiarlo. Aquí escribí la manera simplificada sin el for, como les platiqué en el tutorial anterior.

Para los puts, lo que hacemos es lo siguiente:

1. Calcular los valores finales directamente (put_T)

2. Calcular el valor en el periodo inmediato anterior (put_t) usando el máximo entre la ganancia por ejercicio temprano y el valor descontado de los posibles valores de put_T con los precios de estado q_arriba y q_abajo

3. Reemplazar put_T con put_t y repetir el procedimiento hasta llegar a t=0

Podemos usar estas funciones de la siguiente manera, con los mismos datos que la sección 1.3 del tutorial anterior para comparar:

# 0. Limpiar la sesión
rm(list=ls())
if (names(dev.cur()) != "null device") {
  dev.off()
}
cat("\014")

# 1. Cargar herramientas
source("scripts/herramientas.R")

# 2. Calcular precio de opciones americanas con modelo binomial
ret_promedio <- 0.15
sigma <- 0.35
rf_anual <- 0.06

spot <- 50
strike <- 50
t <- 0.75
divisiones <- 25
delta_t <- 1/divisiones
periodos <- round(t*divisiones)
p_arriba <- exp(ret_promedio*delta_t + sigma*sqrt(delta_t)) - 1
p_abajo <- exp(ret_promedio*delta_t - sigma*sqrt(delta_t)) - 1
rf <- exp(rf_anual*delta_t) - 1

call <- binom.ame.model(p_arriba, p_abajo, rf,
                        spot, strike, periodos)
put <- binom.ame.model(p_arriba, p_abajo, rf,
                       spot, strike, periodos, "p")

Vemos que el call tiene exactamente el mismo valor. Sin embargo, el put americano cuesta ~20 centavos más reflejando el hecho de que puede ejercerse de manera anticipada.

Eso fue todo por hoy. Espero que este tutorial les haya servido. En el próximo tutorial vamos a hablar de un concepto muy importante cuando hablamos de opciones: las griegas. Si tienen cualquier duda o comentario pueden dejarlo en la sección de abajo. Si quieren compartir este blog con sus amigos y compañeros o suscribirse, les dejo los botones aquí:

Hasta el próximo tutorial!