Put-Call-Parität

Zwei Wege zum selben Ziel

Bauen Sie zwei Portfolios. A: Kaufen Sie einen Call und legen Sie den Barwert des Strikes K * exp(-rT) bei der Bank (oder in einer risikofreien Anleihe) an. B: Kaufen Sie einen Put und die Aktie. Endet die Aktie bei Verfall über K, ist A der Call-Wert S - K plus das K der Bank, also S; B ist die Aktie S und ein wertloser Put, also S. Endet sie unter K, ist A nur das K der Bank, weil der Call wertlos verfällt, und B der Put-Wert K - S plus die Aktie S, also K. In beiden Fällen sind die Portfolios bei Verfall gleich viel wert, also müssen sie heute gleich viel kosten.

import math

spot, strike, rate, t = 100, 100, 0.05, 1
pv_strike = strike * math.exp(-rate * t)             # what must be put in the bank today to own K at expiry
print(round(pv_strike, 4))                            # 95.1229

call = 10.4506                                        # a call price we observe
put = call - spot + pv_strike                         # the parity relation
print(round(put, 4))                                  # 5.5735
print(round(put + spot - pv_strike, 4))               # 10.4506   and back to the call

Wenn die Parität bricht: Arbitrage

Notiert der Markt Preise, die die Beziehung nicht erfüllen, gibt es einen risikolosen Gewinn. Definieren Sie die Lücke (C - P) - (S - K e^(-rT)). Eine positive Lücke heißt, der Call ist im Verhältnis zum Put zu teuer: Call verkaufen, Put kaufen, Aktie kaufen und den Barwert des Strikes leihen. Das Portfolio kostet anfangs nichts, zahlt bei Verfall nichts, was die Aktie auch tut, und steckt die Lücke heute ein. Eine negative Lücke kehrt jedes Bein um. Echte Märkte haben Kosten und Geld-Brief-Spannen, kleine Lücken sind daher nicht handelbar: Das steht für die Toleranz.

def parity_gap(call, put, spot, strike, rate, t):
    return (call - put) - (spot - strike * math.exp(-rate * t))

print(round(parity_gap(11.0, put, 100, 100, 0.05, 1), 4))         # 0.5494   the call at 11.00 is too expensive: sell it
print(round(parity_gap(call, put, 100, 100, 0.05, 1), 4))         # 0.0      consistent prices: nothing to do

def arbitrage_action(call, put, spot, strike, rate, t, tolerance=0.01):
    gap = parity_gap(call, put, spot, strike, rate, t)
    if gap > tolerance:
        return "sell call, buy put, buy stock"
    if gap < -tolerance:
        return "buy call, sell put, sell stock"
    return "none"

print(arbitrage_action(11.0, put, 100, 100, 0.05, 1))             # sell call, buy put, buy stock

# The package of the arbitrage, at today's prices: sell the call at 11, buy the put, buy the stock, borrow the strike's present value
cash_today = 11.0 - put - 100 + 100 * math.exp(-0.05 * 1)
print(round(cash_today, 4))                # 0.5494   you are paid the gap now and owe nothing at expiry

# A call minus a put is a synthetic forward: it behaves like the stock bought with borrowed money
print(round(10.4506 - put, 4), round(100 - pv_strike, 4))        # 4.8771 4.8771

• C + K * exp(-rT) = P + S: ein Call plus Anleihe gleicht einem Put plus Aktie, also P = C - S + K * exp(-rT).
• Lücke (C - P) - (S - K e^(-rT)) positiv: Call verkaufen, Put und Aktie kaufen; negativ: umgekehrt.
• Die Parität ist modellfrei, nutzen Sie sie zur Kontrolle jedes Bewertungsmodells; mit Dividenden oder vorzeitiger Ausübung wird sie zur Ungleichung.

Als Nächstes: die Black-Scholes-Formel, ein Preis in geschlossener Form für Call und Put.

Lab: Was bewertet wird

• Mit parity_put_price den Put aus dem Call ableiten25 Pkt.
• Mit parity_call_price den Call aus dem Put ableiten25 Pkt.
• Mit parity_gap messen, wie weit Preise von der Parität entfernt sind25 Pkt.
• Mit arbitrage_action das risikolose Geschäft benennen25 Pkt.