Gamma

O delta não é constante

Uma proteção por delta só é exata por um instante. Assim que a ação se move, o delta da opção muda e a proteção fica errada. O gama é a taxa de variação do delta com a ação: gama = d(delta)/dS, a segunda derivada do preço. Uma call ou put comprada tem gama positivo. No Black–Scholes é pdf(d1) / (S * sigma * sqrt(T)), igual para calls e puts, onde pdf é a densidade do sino. Um gama grande significa que a proteção fica obsoleta rápido e deve ser ajustada com frequência.

import math

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 gamma(spot, strike, rate, sigma, t):
    return norm_pdf(d1(spot, strike, rate, sigma, t)) / (spot * sigma * math.sqrt(t))

for spot in (80, 90, 100, 110, 120):
    print(spot, round(gamma(spot, 100, 0.05, 0.2, 1), 5))
# 80 0.0186
# 90 0.02182
# 100 0.01876
# 110 0.01289
# 120 0.0075      gamma peaks near the strike and fades far from it

O gama cresce perto do vencimento

Para uma opção no dinheiro, o gama sobe bastante perto do vencimento: 0,019 com um ano pela frente, 0,039 com três meses, 0,141 com uma semana. Perto do vencimento a opção é quase um cara ou coroa entre valer nada e valer todo o movimento, então o delta vai de 0 a 1 numa faixa de preço minúscula. Por isso os traders vendidos em opções perto do vencimento (gama curto) dormem mal: a proteção precisa de ajustes constantes e um salto machuca. Também dá para estimar o gama de qualquer modelo pela diferença segunda (f(S + h) - 2 f(S) + f(S - h)) / h², exata para uma parábola.

for t in (1, 0.25, 0.02):
    print(t, round(gamma(100, 100, 0.05, 0.2, t), 5))
# 1 0.01876
# 0.25 0.03929
# 0.02 0.14087      a week before expiry the at-the-money gamma is 7 times larger

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

price = lambda s: bs_call(s, 100, 0.05, 0.2, 1)               # bs_call as in the previous topic
print(round(numerical_gamma(price, 100, 0.5), 5))             # 0.01876   the same as the formula

O que o gama rende

Como o delta muda com a ação, uma opção comprada ganha mais do que o delta sozinho prevê, para qualquer lado que a ação se mova. Uma alta de $5 leva o delta de 0,637 a 0,637 + 0,01876 * 5 = 0,731. O lucro de um movimento é delta * movimento + 0,5 * gama * movimento²: o segundo termo é o lucro de gama de uma opção comprada (uma perda para uma vendida). Cresce com o quadrado do movimento, então movimentos grandes, para qualquer lado, favorecem o lado comprado em gama. Esse lucro não é de graça: o titular o paga com o prêmio da opção e seu desgaste temporal.

g = gamma(100, 100, 0.05, 0.2, 1)
delta = call_delta(100, 100, 0.05, 0.2, 1)                     # as in the delta topic
print(round(delta, 4), round(delta + g * 5, 4))                 # 0.6368 0.7306   the delta after a $5 rise
print(round(call_delta(105, 100, 0.05, 0.2, 1), 4))             # 0.7237          the exact delta at 105 (gamma is a first-order guide)

move = 5
true_gain = bs_call(105, 100, 0.05, 0.2, 1) - bs_call(100, 100, 0.05, 0.2, 1)
print(round(true_gain - delta * move, 4), round(0.5 * g * move ** 2, 4))   # 0.2232 0.2345   what delta missed, and what gamma explains

# Dollar gamma: how many dollars of stock the delta hedge changes for a 1% move of the stock at 100
print(round(g * 100 ** 2 / 100, 3))      # 1.876

• Gama = pdf(d1) / (S * sigma * sqrt(T)), segunda derivada do preço; igual para calls e puts, maior perto do strike e do vencimento.
• Gama numérico (f(S + h) - 2 f(S) + f(S - h)) / h²; delta após um movimento delta + gama * movimento.
• Um movimento rende delta * movimento + 0,5 * gama * movimento²: uma opção comprada ganha com grandes movimentos para qualquer lado e paga por isso em desgaste temporal.

A seguir: o vega, a sensibilidade à volatilidade, a entrada que ninguém consegue observar diretamente.

Lab: o que é avaliado

• Medir a rapidez da mudança do delta com gamma25 pts
• Medir a curvatura de qualquer preço com numerical_gamma25 pts
• Atualizar o delta após um movimento com delta_after_move25 pts
• Quantificar o benefício da curvatura com gamma_pnl25 pts