Le delta

La sensibilité à l'action

Un trader qui détient des options doit savoir ce qui arrive au compte quand l'action bouge. Le delta est la réponse : la variation du prix de l'option pour un mouvement d'une unité de l'action, dC/dS. Un call a un delta entre 0 et 1, un put entre -1 et 0. Dans le modèle de Black–Scholes, le delta du call vaut simplement N(d1) et celui du put N(d1) - 1. Un call à 1 an à la monnaie de delta 0,64 gagne environ 64 centimes quand l'action monte d'un dollar. Le delta se lit aussi comme à peu près la probabilité que l'option finisse dans la monnaie.

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

Mesurer le delta en perturbant

Une formule fermée n'existe que pour les options simples. Pour tout modèle de valorisation, on peut estimer le delta numériquement : valorisez l'option avec l'action un peu plus haute et un peu plus basse puis divisez par l'écart. La différence centrée (f(S + h) - f(S - h)) / (2h) est plus précise que la différence unilatérale, et exacte pour une parabole. La même fonction marche pour un prix Monte Carlo ou un arbre binomial : ce « perturber et revaloriser » est la manière universelle d'obtenir des sensibilités. Choisissez h petit, mais pas au point que le bruit d'arrondi domine (1 % du cours est un départ typique).

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

Se couvrir avec le delta

Le delta transforme une position en options en une position équivalente en actions. Un contrat de call sur 100 actions de delta 0,64 se comporte comme la détention de 64 actions pour de petits mouvements. Pour supprimer l'exposition, prenez la position opposée : avec 10 contrats de call longs, vendez 10 * 100 * 0,6368 = 637 actions. Le portefeuille couvert est neutre en delta : un petit mouvement de l'action laisse sa valeur presque inchangée. La couverture n'est juste que pour le cours actuel : il faut l'ajuster quand l'action et le delta bougent. La fréquence du rééquilibrage est un compromis entre risque et coûts de transaction.

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 du call N(d1) dans (0, 1) ; delta du put N(d1) - 1 dans (-1, 0) : l'équivalent en actions d'une option.
• Delta numérique (f(S + h) - f(S - h)) / (2h) : valable pour tout modèle de valorisation ; gardez h petit mais au-dessus du bruit d'arrondi.
• Actions de couverture = -contrats * multiplicateur * delta : le portefeuille est neutre en delta pour de petits mouvements ; rééquilibrez quand le delta change.

À suivre : le gamma, la sensibilité du delta lui-même, qui dit à quelle vitesse une couverture se périme.

Lab : ce qui est noté

• Mesurer la sensibilité d'un call à l'action avec call_delta25 pts
• Déduire le delta du put avec put_delta25 pts
• Perturber le prix pour mesurer le delta avec numerical_delta25 pts
• Neutraliser la position avec hedge_shares25 pts