Theta e rho

Mais duas formas de o preço se mover

Delta, gama e vega cobrem a ação e sua volatilidade. Restam duas entradas da fórmula de Black–Scholes: o prazo até o vencimento e a taxa de juros. O teta é a variação do valor de uma opção com a passagem do tempo (o t da fórmula encolhe a cada dia), e o rô é a variação quando os juros se movem. O teta costuma ser o que se sente todo dia: uma opção comprada é um ativo que se desgasta, e o prêmio que perde a cada dia é o preço de possuir a convexidade.

import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def norm_pdf(x):
    return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)

def d1(spot, strike, rate, sigma, t):
    return (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))

def d2(spot, strike, rate, sigma, t):
    return d1(spot, strike, rate, sigma, t) - sigma * math.sqrt(t)

def call_theta(spot, strike, rate, sigma, t):
    decay = -spot * norm_pdf(d1(spot, strike, rate, sigma, t)) * sigma / (2 * math.sqrt(t))
    carry = -rate * strike * math.exp(-rate * t) * norm_cdf(d2(spot, strike, rate, sigma, t))
    return decay + carry

theta = call_theta(100, 100, 0.05, 0.2, 1)
print(round(theta, 4))             # -6.414   per year
print(round(theta / 365, 4))       # -0.0176  per calendar day

Teta: por que o tempo machuca

O primeiro termo do teta, -S * pdf(d1) * sigma / (2 * sqrt(T)), é o desgaste do *valor da opção*: com menos tempo há menos chance de um grande movimento. O segundo, -r * K * exp(-rT) * N(d2), é o juro sobre o strike que ainda não precisa ser pago, ganho pelo comprador da call. Ambos são negativos para uma call, e o teta também, e a perda não é constante: acelera perto do vencimento, mais rápido nas opções no dinheiro. Cota-se por dia corrido, theta / 365.

# Theta per day for the same option as expiry approaches: the decay speeds up
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def norm_pdf(x):
    return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)

def call_theta(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    d_2 = d_1 - sigma * math.sqrt(t)
    return -spot * norm_pdf(d_1) * sigma / (2 * math.sqrt(t)) - rate * strike * math.exp(-rate * t) * norm_cdf(d_2)

for days in (360, 90, 30, 7):
    per_day = call_theta(100, 100, 0.05, 0.2, days / 365) / 365
    print(days, "days left:", round(per_day, 4))     # 360: -0.0177, 90: -0.0288, 30: -0.045, 7: -0.0858

Rô: a taxa de juros

O rô é K * T * exp(-rT) * N(d2): positivo para uma call, pois uma taxa maior reduz o valor presente do strike a pagar. Uma put tem o sinal oposto. É a menor das gregas em opções de curto prazo e importa nas longas (LEAPS, warrants longos). Cota-se por ponto percentual de taxa, rho / 100, como o vega por ponto de volatilidade.

# Rho of the one-year call at several rates: it grows with the rate and with the time left
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def call_rho(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    return strike * t * math.exp(-rate * t) * norm_cdf(d_1 - sigma * math.sqrt(t))

for rate in (0.0, 0.05, 0.10):
    print("rate", rate, "rho per point:", round(call_rho(100, 100, rate, 0.2, 1) / 100, 4))   # 0.0: 0.4602, 0.05: 0.5323, 0.1: 0.5931
print("two years, 5%:", round(call_rho(100, 100, 0.05, 0.2, 2) / 100, 4))                  # 1.0568

# Check theta and rho by bumping the inputs: they are slopes of the price
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def bs_call(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    return spot * norm_cdf(d_1) - strike * math.exp(-rate * t) * norm_cdf(d_1 - sigma * math.sqrt(t))

h = 1e-5
theta = -(bs_call(100, 100, 0.05, 0.2, 1 + h) - bs_call(100, 100, 0.05, 0.2, 1 - h)) / (2 * h)
rho = (bs_call(100, 100, 0.05 + h, 0.2, 1) - bs_call(100, 100, 0.05 - h, 0.2, 1)) / (2 * h)
print(round(theta, 4), round(rho, 4))                    # -6.414 53.2325

• O teta é o valor perdido com o tempo: negativo para uma call comprada, mais rápido perto do vencimento e no dinheiro; cota-se theta / 365 por dia.
• O rô é a sensibilidade à taxa de juros: positivo para calls, negativo para puts, maior nos prazos longos; cota-se rho / 100 por ponto.
• Ambos são inclinações do preço: uma pequena perturbação de t ou rate verifica qualquer fórmula.

A seguir: a volatilidade implícita, usar a fórmula ao contrário para ler a volatilidade do mercado no preço de uma opção.

Lab: o que é avaliado

• Precificar a passagem do tempo com call_theta25 pts
• Expressar o desgaste diário com theta_per_day25 pts
• Medir a sensibilidade às taxas de juros com call_rho25 pts
• Expressar o rô por ponto percentual com rho_per_point25 pts