Workshop 2, Hedging Vehicles - Module 2

Author

Alberto Dorantes

Published

November 4, 2025

Abstract
In this workshop we do a quick review of Option pricing and basic Option Strategies. You have to workout the exercises/challenges at the end.

1 Option pricing

Go and read my Lecture Note “Basics of Options” and be ready to work on the first exercise

2 Option Strategies

2.1 Introduction

This notebook reviews core option strategies commonly taught in an introductory derivatives course. We focus on two families:

  • Spreads: Bull, Bear, and Butterfly spreads
  • Combinations: Straddle, Strip, Strap, and Strangle

For each strategy you’ll find:

  1. A short conceptual explanation
  2. One or two simple, hand‑worked examples (with key properties)
  3. A Python example that plots both payoff and profit at expiration

Payoff vs. Profit:
- Payoff refers to the terminal value of the position at expiration, ignoring premiums paid/received.
- Profit is payoff minus the net premium paid (or plus the net premium received).
We ignore funding costs and transaction fees for simplicity.

Sign convention for premiums:
- Buying (long) an option: premium is a cash outflow → positive cost
- Writing (short) an option: premium is a cash inflow → subtract the premium from net cost

2.2 Setup

We will build reusable functions for option payoffs and helper plotters.

Code 
import numpy as np
import matplotlib.pyplot as plt

# --- Atomic option payoffs at expiration ---
def long_call_payoff(S, K):
    return np.maximum(S - K, 0.0)

def short_call_payoff(S, K):
    return -long_call_payoff(S, K)

def long_put_payoff(S, K):
    return np.maximum(K - S, 0.0)

def short_put_payoff(S, K):
    return -long_put_payoff(S, K)

# --- Plot helpers (one chart per figure; do not set colors explicitly) ---
def plot_strategy(S, payoff, profit, title_prefix="Strategy"):
    # Payoff
    plt.figure()
    plt.plot(S, payoff, label="Payoff at Expiration")
    plt.axhline(0, linestyle="--")
    plt.title(f"{title_prefix}: Payoff")
    plt.xlabel("Underlying Price at Expiration (S_T)")
    plt.ylabel("Payoff")
    plt.grid(True)
    plt.legend()

    # Profit
    plt.figure()
    plt.plot(S, profit, label="Profit at Expiration")
    plt.axhline(0, linestyle="--")
    plt.title(f"{title_prefix}: Profit")
    plt.xlabel("Underlying Price at Expiration (S_T)")
    plt.ylabel("Profit")
    plt.grid(True)
    plt.legend()

def breakeven_points_from_curve(S, profit, tol=1e-6):
    '''Return approximate breakeven S where profit crosses zero (for display).'''
    zeros = []
    for i in range(1, len(S)):
        if profit[i-1] == 0:
            zeros.append(S[i-1])
        # sign change
        if profit[i-1] * profit[i] < 0:
            # linear interpolation between S[i-1], S[i]
            x0, x1 = S[i-1], S[i]
            y0, y1 = profit[i-1], profit[i]
            xz = x0 - y0 * (x1 - x0) / (y1 - y0)
            zeros.append(xz)
    # Deduplicate near-duplicates
    zeros_unique = []
    for z in zeros:
        if not zeros_unique or abs(z - zeros_unique[-1]) > tol:
            zeros_unique.append(z)
    return zeros_unique

2.3 A) Spreads

2.3.1 1) Bull Call Spread

Construction (calls): Long one call with lower strike (K_1) and short one call with higher strike (K_2) (same expiration), with (K_1 < K_2).
- View: Moderately bullish.
- Max Loss: Net premium paid.
- Max Profit: ((K_2 - K_1) - ).
- Breakeven: (K_1 + ).

Simple numeric sketch
Suppose (K_1=100), (K_2=120). Premiums: (c_1=8) (long), (c_2=3) (short).
- Net premium paid (= 8 - 3 = 5).
- Max profit (= (120-100) - 5 = 15).
- Max loss (= 5).
- Breakeven (= 100 + 5 = 105).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)  # price at expiration grid

K1, K2 = 100, 120
c1, c2 = 8.0, 3.0           # premiums: buy c1, sell c2
net_premium = c1 - c2       # net cost paid

payoff = long_call_payoff(S, K1) + short_call_payoff(S, K2)
profit = payoff - net_premium

print("Bull Call Spread:")
print("  Net premium paid:", net_premium)
print("  Max profit approx:", (K2 - K1) - net_premium)
print("  Max loss:", net_premium)
print("  Breakeven ≈", K1 + net_premium)

plot_strategy(S, payoff, profit, title_prefix="Bull Call Spread")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Bull Call Spread:
  Net premium paid: 5.0
  Max profit approx: 15.0
  Max loss: 5.0
  Breakeven ≈ 105.0
  Numerical breakevens from curve: [np.float64(105.0)]

2.3.2 2) Bear Put Spread

Construction (puts): Long one put with higher strike (K_1) and short one put with lower strike (K_2) (same expiration), with (K_1 > K_2).
- View: Moderately bearish.
- Max Loss: Net premium paid.
- Max Profit: ((K_1 - K_2) - ).
- Breakeven: (K_1 - ).

Simple numeric sketch
Let (K_1=120), (K_2=100). Premiums: (p_1=9) (long), (p_2=4) (short).
- Net premium paid (= 9 - 4 = 5).
- Max profit (= (120-100) - 5 = 15).
- Max loss (= 5).
- Breakeven (= 120 - 5 = 115).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

K1, K2 = 120, 100
p1, p2 = 9.0, 4.0
net_premium = p1 - p2

payoff = long_put_payoff(S, K1) + short_put_payoff(S, K2)
profit = payoff - net_premium

print("Bear Put Spread:")
print("  Net premium paid:", net_premium)
print("  Max profit approx:", (K1 - K2) - net_premium)
print("  Max loss:", net_premium)
print("  Breakeven ≈", K1 - net_premium)

plot_strategy(S, payoff, profit, title_prefix="Bear Put Spread")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Bear Put Spread:
  Net premium paid: 5.0
  Max profit approx: 15.0
  Max loss: 5.0
  Breakeven ≈ 115.0
  Numerical breakevens from curve: [np.float64(115.0)]

2.3.3 3) Butterfly Spread (using calls)

Construction: Long one call at (K_1), short two calls at (K_2), long one call at (K_3), with (K_1 < K_2 < K_3) and typically even spacing (K_2 - K_1 = K_3 - K_2).
- View: Neutral with low volatility expectation—profit peaks if (S_T) ends near (K_2).
- Max Loss: Net premium paid (if any).
- Max Profit: Approximately (K_3 - K_2 - ) when centered and evenly spaced.
- Breakeven: Two points around (K_2): (K_1 + ) and (K_3 - ) (when evenly spaced).

Simple numeric sketch
Let ((K_1,K_2,K_3)=(90,100,110)). Premiums: (c_1=13), (c_2=7) (middle, sold twice), (c_3=3).
- Net premium paid (= 13 - 2 + 3 = 2).
- Max profit ((110-100) - 2 = 8).
- Breakevens ( + 2 = 92) and (110 - 2 = 108).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

K1, K2, K3 = 90, 100, 110
c1, c2, c3 = 13.0, 7.0, 3.0    # sell two at K2
net_premium = c1 - 2*c2 + c3

payoff = (
    long_call_payoff(S, K1)
    + short_call_payoff(S, K2) * 2.0
    + long_call_payoff(S, K3)
)
profit = payoff - net_premium

print("Butterfly (Calls):")
print("  Net premium paid:", net_premium)
print("  Max profit approx:", (K3 - K2) - net_premium)
print("  Approx breakevens (even spacing):", K1 + net_premium, "and", K3 - net_premium)

plot_strategy(S, payoff, profit, title_prefix="Butterfly (Calls)")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Butterfly (Calls):
  Net premium paid: 2.0
  Max profit approx: 8.0
  Approx breakevens (even spacing): 92.0 and 108.0
  Numerical breakevens from curve: [np.float64(92.0), np.float64(108.0)]

2.4 B) Combinations

2.4.1 4) Long Straddle

Construction: Long one call and long one put at the same strike (K) and expiration.
- View: Expect high volatility (big move either way).
- Max Loss: Total premium paid.
- Max Profit: Unlimited to the upside; large to the downside (bounded only by (S_T )).
- Breakevens: (K ).

Simple numeric sketch
Let (K=100). Premiums: (c=7), (p=5).
- Net premium paid (= 12).
- Breakevens (= 100 112).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

K = 100
c, p = 7.0, 5.0
net_premium = c + p

payoff = long_call_payoff(S, K) + long_put_payoff(S, K)
profit = payoff - net_premium

print("Long Straddle:")
print("  Net premium paid:", net_premium)
print("  Breakevens:", K - net_premium, "and", K + net_premium)

plot_strategy(S, payoff, profit, title_prefix="Long Straddle")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Long Straddle:
  Net premium paid: 12.0
  Breakevens: 88.0 and 112.0
  Numerical breakevens from curve: [np.float64(88.0), np.float64(112.0)]

2.4.2 5) Strip (put‑heavy straddle)

Construction: Long two puts and long one call at the same (K) and expiration.
- View: Expect volatility with downside bias.
- Max Loss: (2p + c) (total premium).
- Breakevens: Asymmetric; the downside breakeven is closer to (K) than the upside, reflecting the extra put.

Simple numeric sketch
Let (K=100). Premiums: (c=7), (p=5).
- Net premium paid (= 2 + 7 = 17).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

K = 100
c, p = 7.0, 5.0
net_premium = 2*p + c

payoff = 2*long_put_payoff(S, K) + long_call_payoff(S, K)
profit = payoff - net_premium

print("Strip (2P + 1C):")
print("  Net premium paid:", net_premium)

plot_strategy(S, payoff, profit, title_prefix="Strip (2P + 1C)")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Strip (2P + 1C):
  Net premium paid: 17.0
  Numerical breakevens from curve: [np.float64(91.5), np.float64(117.0)]

2.4.3 6) Strap (call‑heavy straddle)

Construction: Long two calls and long one put at the same (K) and expiration.
- View: Expect volatility with upside bias.
- Max Loss: (2c + p) (total premium).

Simple numeric sketch
Let (K=100). Premiums: (c=7), (p=5).
- Net premium paid (= 2 + 5 = 19).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

K = 100
c, p = 7.0, 5.0
net_premium = 2*c + p

payoff = 2*long_call_payoff(S, K) + long_put_payoff(S, K)
profit = payoff - net_premium

print("Strap (2C + 1P):")
print("  Net premium paid:", net_premium)

plot_strategy(S, payoff, profit, title_prefix="Strap (2C + 1P)")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Strap (2C + 1P):
  Net premium paid: 19.0
  Numerical breakevens from curve: [np.float64(81.0), np.float64(109.5)]

2.4.4 7) Long Strangle

Construction: Long one out‑of‑the‑money put at (K_P) and one out‑of‑the‑money call at (K_C) (same expiration) with (K_P < K_C).
- View: Expect high volatility, but you want to lower upfront cost compared to a straddle.
- Max Loss: (p + c) (total premium).
- Breakevens: (K_P - ) and (K_C + ).

Simple numeric sketch
Let (K_P=95), (K_C=105). Premiums: (p=4), (c=6).
- Net premium paid (= 10).
- Breakevens (= 95 - 10 = 85) and (105 + 10 = 115).

Python plot (payoff & profit):

Code 
S = np.linspace(50, 170, 400)

Kp, Kc = 95, 105
p, c = 4.0, 6.0
net_premium = p + c

payoff = long_put_payoff(S, Kp) + long_call_payoff(S, Kc)
profit = payoff - net_premium

print("Long Strangle:")
print("  Net premium paid:", net_premium)
print("  Breakevens:", Kp - net_premium, "and", Kc + net_premium)

plot_strategy(S, payoff, profit, title_prefix="Long Strangle")
print("  Numerical breakevens from curve:", breakeven_points_from_curve(S, profit))
Long Strangle:
  Net premium paid: 10.0
  Breakevens: 85.0 and 115.0
  Numerical breakevens from curve: [np.float64(85.0), np.float64(115.0)]

3 EXERCISES

(All exercises must be in your Excel Workbook)

3.1 Option pricing:

  1. According to the binomial model explained in the Lecture Note (“Basics of Options”), calculate the premium of the Call and the premium of the Put of the example illustrated in the reading. You have to design a Portfolio of a bond and a stock that “mimics” a Call option on the same stock.

With your WORDS, Explain your development and how you constructed the “mimic” portfolio

  1. Following the 3 examples at the end of the reading, create a table to show how you can design portfolios of 2 instruments to mimic:

  • A call option

  • A bond

  • Stock

  1. Do the same as 2), but instead of using a Call Option, use a Put option to create the 3 mimic portfolios and show the corresponding tables with the values at t=0 and t=1

3.2 Option Strategies

Exercises from Hull book, chapter 12

To-be-announced