Delta

A sensibilidade à ação

Um trader que possui opções precisa saber o que acontece com a conta quando a ação se move. O delta é a resposta: a variação do preço da opção por um movimento de uma unidade da ação, dC/dS. Uma call tem delta entre 0 e 1, uma put entre -1 e 0. No modelo de Black–Scholes o delta da call é simplesmente N(d1) e o da put N(d1) - 1. Uma call de um ano no dinheiro com delta 0,64 ganha cerca de 64 centavos quando a ação sobe um dólar. O delta também é lido como, aproximadamente, a probabilidade de a opção terminar no dinheiro.

import math

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

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

def call_delta(spot, strike, rate, sigma, t):
    return norm_cdf(d1(spot, strike, rate, sigma, t))

for spot in (80, 90, 100, 110, 120):
    delta = call_delta(spot, 100, 0.05, 0.2, 1)
    print(spot, round(delta, 4), round(delta - 1, 4))      # the call delta and the put delta
# 80 0.2219 -0.7781
# 90 0.4298 -0.5702
# 100 0.6368 -0.3632
# 110 0.7958 -0.2042
# 120 0.8965 -0.1035     deep in the money: the call moves almost one for one with the stock

Medir o delta perturbando

Só existe fórmula fechada para opções simples. Para qualquer modelo de precificação dá para estimar o delta numericamente: precifique a opção com a ação um pouco mais alta e um pouco mais baixa e divida pela distância. A diferença central (f(S + h) - f(S - h)) / (2h) é mais precisa que a unilateral, e exata para uma parábola. A mesma função serve para um preço Monte Carlo ou uma árvore binomial, então esse "perturbar e reprecificar" é a forma universal de obter sensibilidades. Escolha h pequeno, mas não tanto que o ruído de arredondamento domine (1% do preço é um começo típico).

def bs_call(spot, strike, rate, sigma, t):
    d_1 = d1(spot, strike, rate, sigma, t)
    return spot * norm_cdf(d_1) - strike * math.exp(-rate * t) * norm_cdf(d_1 - sigma * math.sqrt(t))

def numerical_delta(price_function, spot, bump):
    return (price_function(spot + bump) - price_function(spot - bump)) / (2 * bump)

price = lambda s: bs_call(s, 100, 0.05, 0.2, 1)          # any function of the spot price will do
print(round(numerical_delta(price, 100, 0.01), 6))        # 0.636831
print(round(call_delta(100, 100, 0.05, 0.2, 1), 6))       # 0.636831   the same as the formula

Proteger-se com o delta

O delta transforma uma posição em opções numa posição equivalente em ações. Um contrato de call sobre 100 ações com delta 0,64 se comporta como possuir 64 ações para movimentos pequenos. Para eliminar a exposição, tome a posição oposta: com 10 contratos de call comprados, venda 10 * 100 * 0,6368 = 637 ações. A carteira protegida é neutra em delta: um pequeno movimento da ação deixa seu valor quase inalterado. A proteção só vale para o preço atual, então deve ser ajustada quando a ação e o delta se movem. A frequência de reequilíbrio é um compromisso entre risco e custos de negociação.

def hedge_shares(contracts, delta, multiplier=100):
    return -contracts * multiplier * delta

delta = call_delta(100, 100, 0.05, 0.2, 1)
print(round(hedge_shares(10, delta), 1))            # -636.8   long 10 call contracts: sell about 637 shares
print(round(hedge_shares(-10, delta), 1))           # 636.8    short 10 call contracts: buy about 637 shares

# After a $1 move the options gain about delta * 1 each and the shares lose about the same
print(round(bs_call(101, 100, 0.05, 0.2, 1) - bs_call(100, 100, 0.05, 0.2, 1), 4))    # 0.6461   close to delta, not exactly

# Delta as expiry approaches: at the money it stays near 0.5, in the money it goes to 1, out of the money to 0
for t in (1, 0.25, 0.02):
    print(t, [round(call_delta(spot, 100, 0.05, 0.2, t), 4) for spot in (90, 100, 110)])
# 1 [0.4298, 0.6368, 0.7958]
# 0.25 [0.1898, 0.5695, 0.8704]
# 0.02 [0.0001, 0.5197, 0.9997]

• Delta da call N(d1) em (0, 1); delta da put N(d1) - 1 em (-1, 0): o equivalente em ações de uma opção.
• Delta numérico (f(S + h) - f(S - h)) / (2h) vale para qualquer modelo de precificação; mantenha h pequeno, mas acima do ruído de arredondamento.
• Ações de proteção = -contratos * multiplicador * delta deixa a carteira neutra em delta para movimentos pequenos; reequilibre quando o delta mudar.

A seguir: o gama, a sensibilidade do próprio delta, que diz com que rapidez uma proteção fica obsoleta.

Lab: o que é avaliado

• Medir a sensibilidade de uma call à ação com call_delta25 pts
• Deduzir o delta da put com put_delta25 pts
• Perturbar o preço para medir o delta com numerical_delta25 pts
• Neutralizar a posição com hedge_shares25 pts