Workshop 2, Hedging Vehicles - Module 2

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
• Hedging structures: Collar

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.

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 and Profit in one plot
    plt.figure()
    plt.plot(S, payoff, label="Payoff at Expiration")
    plt.plot(S, profit, label="Profit at Expiration")
    plt.axhline(0, linestyle="--", color="gray")
    plt.title(f"{title_prefix}: Payoff and Profit")
    plt.xlabel("Underlying Price at Expiration (S_T)")
    plt.ylabel("Value")
    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 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) - \text{net premium}).
- Breakeven: (K_1 + \text{net premium}).

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):

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 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) - \text{net premium}.
  
• Breakeven:(K_1 - \text{net premium}).

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):

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 - \text{net premium}) when centered and evenly spaced.
- Breakeven: Two points around (K_2): (K_1 + $ and K_3 - \text{net premium} (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\times 7 + 3 = 2.
- Max profit \approx (110-100) - 2 = 8.
- Breakevens \approx 90 + 2 = 92 and 110 - 2 = 108.

Python plot (payoff & profit):

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 \to 0).
- Breakevens: K \pm \text{(total premium)}.

Simple numeric sketch
Let K=100. Premiums: c=7, p=5.
- Net premium paid = 12.
- Breakevens = 100 \pm 12 \Rightarrow 88 \text{ and } 112.

Python plot (payoff & profit):

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\times 5 + 7 = 17.

Python plot (payoff & profit):

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\times 7 + 5 = 19.

Python plot (payoff & profit):

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 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 - \text{(total premium)}) and (K_C + \text{(total premium)}).

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):

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)]

---

2.5 C) Hedging Structures

2.5.1 8) Collar

2.5.1.1 What is a Collar?

A collar is a hedging strategy built from two options that together bracket the outcome within a defined range. It is designed for someone who already holds (or will receive) the underlying asset and wants to protect against an adverse price move, while accepting a cap on the upside — typically in exchange for a very low or even zero net premium.

For a holder of the underlying asset (e.g., a company that will receive foreign currency), the collar has two legs:

1. Long Put at strike K_P: buys the right to sell the asset at K_P → this is the floor (protection against downside).
2. Short Call at strike K_C > K_P: sells the right for someone else to buy the asset at K_C → this is the cap (limits upside).

The premium received from the short call offsets the premium paid for the long put. When c_C \approx c_P, the collar is called a zero-cost collar: full downside protection with no upfront premium.

Key intuition: You give up the chance to benefit if the price rises above K_C, in exchange for a guarantee that you will never receive less than K_P. Think of it as buying insurance (the put) and paying for it by selling some of your upside potential (the call).

2.5.1.2 Payoff and Profit Formulas

The net payoff of the collar (combining the asset position + put + short call) per unit of underlying is:

\text{Payoff}_{\text{collar}} = S_T + \underbrace{\max(K_P - S_T,\, 0)}_{\text{Long Put payoff}} + \underbrace{(-\max(S_T - K_C,\, 0))}_{\text{Short Call payoff}}

This simplifies to:

\boxed{\text{Payoff}_{\text{collar}} = \begin{cases} K_P & \text{if } S_T < K_P \\ S_T & \text{if } K_P \leq S_T \leq K_C \\ K_C & \text{if } S_T > K_C \end{cases}}

The payoff is therefore bounded between K_P and K_C for any market outcome.

The profit adjusts for the net premium paid:

\text{Net premium} = c_P - c_C

\boxed{\text{Profit}_{\text{collar}} = \text{Payoff}_{\text{collar}} - (c_P - c_C)}

When c_P = c_C (zero-cost collar), profit equals payoff exactly.

Breakeven points:

• Lower breakeven: K_P - (c_P - c_C) — only relevant if the net premium is positive (i.e., the put was more expensive than the call premium received).
• Upper breakeven: K_C - (c_P - c_C).

2.5.1.3 Simple Numeric Sketch

A Mexican exporter will receive USD 1,000,000 in 6 months (spot today: MXN/USD = 17.50). They fear the peso may appreciate (USD falls in MXN terms) but also want some upside if the peso depreciates.

Parameters:

• Spot S_0 = 17.50 MXN/USD
• Long Put strike K_P = 17.00 (floor: will sell USD at no less than 17.00)
• Short Call strike K_C = 18.50 (cap: will sell USD at no more than 18.50)
• Put premium paid c_P = 0.45 MXN/USD
• Call premium received c_C = 0.40 MXN/USD
• Net premium = 0.45 - 0.40 = 0.05 MXN/USD

Scenario S_T	Put payoff	Short Call payoff	Effective rate	Net premium	Profit
15.00	+2.00	0.00	17.00	−0.05	16.95
16.50	+0.50	0.00	17.00	−0.05	16.95
17.50	0.00	0.00	17.50	−0.05	17.45
18.20	0.00	0.00	18.20	−0.05	18.15
19.00	0.00	−0.50	18.50	−0.05	18.45
21.00	0.00	−2.50	18.50	−0.05	18.45

Observations:

• Below K_P = 17.00: the put kicks in and the effective selling rate is always 17.00 (floor guaranteed).
• Between 17.00 and 18.50: neither option is exercised; the exporter sells at the market rate S_T (participates freely).
• Above K_C = 18.50: the call is exercised against the exporter; effective rate is capped at 18.50.

2.5.1.4 Python plot (payoff & profit)

S = np.linspace(13, 23, 500)

# --- Collar parameters ---
S0    = 17.50   # spot today (for reference)
Kp    = 17.00   # long put strike  (floor)
Kc    = 18.50   # short call strike (cap)
cp    = 0.45    # put premium paid
cc    = 0.40    # call premium received
net_premium = cp - cc   # positive => net cost; zero => zero-cost collar

# --- Component payoffs ---
put_payoff        = long_put_payoff(S, Kp)
short_call_payoff_arr = short_call_payoff(S, Kc)

# --- Collar: effective exchange rate received (asset + put + short call) ---
collar_payoff = S + put_payoff + short_call_payoff_arr
collar_profit = collar_payoff - net_premium

# --- Unhedged position (just selling at S_T) ---
unhedged_profit = S - net_premium   # same net premium deducted for fair comparison

print("Collar (Long Put + Short Call):")
print(f"  K_P (floor) = {Kp}")
print(f"  K_C (cap)   = {Kc}")
print(f"  Net premium paid = {net_premium:.2f}")
print(f"  Effective rate floor  = {Kp - net_premium:.4f}")
print(f"  Effective rate cap    = {Kc - net_premium:.4f}")
print(f"  Numerical breakevens from curve: {breakeven_points_from_curve(S, collar_profit - (S0 - net_premium))}")

# --- Plot 1: payoff and profit of the collar alone ---
plot_strategy(S, collar_payoff, collar_profit,
              title_prefix=f"Collar (K_P={Kp}, K_C={Kc})")

Collar (Long Put + Short Call):
  K_P (floor) = 17.0
  K_C (cap)   = 18.5
  Net premium paid = 0.05
  Effective rate floor  = 16.9500
  Effective rate cap    = 18.4500
  Numerical breakevens from curve: [np.float64(17.5)]

# --- Plot 2: compare collar profit vs unhedged ---
plt.figure()
plt.plot(S, collar_profit,   label=f"Collar (K_P={Kp}, K_C={Kc})", linewidth=2)
plt.plot(S, S,               label="Unhedged (sell at S_T)",        linestyle="--")
plt.axvline(S0,  color="gray",   linestyle=":", label=f"Spot today S₀={S0}")
plt.axvline(Kp,  color="green",  linestyle=":", label=f"Floor K_P={Kp}")
plt.axvline(Kc,  color="red",    linestyle=":", label=f"Cap   K_C={Kc}")
plt.axhline(0,   color="gray",   linestyle="--")
plt.title("Collar vs. Unhedged: Effective Rate Received (MXN/USD)")
plt.xlabel("USD/MXN Spot Rate at Expiration (S_T)")
plt.ylabel("Effective rate / Profit (MXN per USD)")
plt.legend()
plt.grid(True)
plt.show()

# --- Plot 3: decompose the three legs separately ---
fig, axes = plt.subplots(1, 3, figsize=(13, 4), sharey=False)

legs = [
    (S,  put_payoff,             put_payoff - cp,         f"Long Put (K_P={Kp})"),
    (S,  short_call_payoff_arr,  short_call_payoff_arr+cc, f"Short Call (K_C={Kc})"),
    (S,  collar_payoff,          collar_profit,            f"Collar combined"),
]

for ax, (x, pay, pro, title) in zip(axes, legs):
    ax.plot(x, pay, label="Payoff")
    ax.plot(x, pro, label="Profit", linestyle="--")
    ax.axhline(0, color="gray", linestyle="--", linewidth=0.8)
    ax.axvline(Kp, color="green", linestyle=":", linewidth=0.8, label=f"K_P={Kp}")
    ax.axvline(Kc, color="red",   linestyle=":", linewidth=0.8, label=f"K_C={Kc}")
    ax.set_title(title)
    ax.set_xlabel("S_T")
    ax.set_ylabel("Value")
    ax.legend(fontsize=8)
    ax.grid(True)

plt.tight_layout()
plt.show()

2.5.1.5 Zero-cost collar

A special case arises when the call premium exactly offsets the put premium: c_C = c_P, so the net premium is zero. This is a zero-cost collar: the exporter gets full downside protection at no cash outlay, simply by surrendering all upside above K_C.

# --- Zero-cost collar: equal premiums ---
cp_zc = 0.42    # put premium paid
cc_zc = 0.42    # call premium received (same)
net_premium_zc = cp_zc - cc_zc   # = 0

collar_payoff_zc = S + long_put_payoff(S, Kp) + short_call_payoff(S, Kc)
collar_profit_zc = collar_payoff_zc - net_premium_zc

print(f"Zero-cost collar: net premium = {net_premium_zc:.2f}")
print(f"  Profit = Payoff everywhere (no premium adjustment)")

plt.figure()
plt.plot(S, collar_profit_zc, label="Zero-cost collar profit", linewidth=2)
plt.plot(S, S,                label="Unhedged",                linestyle="--")
plt.axvline(Kp, color="green", linestyle=":", label=f"K_P={Kp}")
plt.axvline(Kc, color="red",   linestyle=":", label=f"K_C={Kc}")
plt.axhline(0,  color="gray",  linestyle="--")
plt.title(f"Zero-Cost Collar (K_P={Kp}, K_C={Kc}, net premium=0)")
plt.xlabel("S_T (MXN/USD at expiration)")
plt.ylabel("Effective rate (MXN per USD)")
plt.legend()
plt.grid(True)
plt.show()

Zero-cost collar: net premium = 0.00
  Profit = Payoff everywhere (no premium adjustment)

2.5.1.6 When is a Collar the right strategy?

Use a collar when:

• You already hold or will receive the underlying asset (a stock position, a foreign currency receivable, a commodity inventory) and want downside protection.
• You are willing to sacrifice upside above K_C in exchange for a lower (or zero) premium cost — unlike a standalone put, which you pay for fully.
• You want a defined range of outcomes: you know the worst case (K_P net of small premium) and the best case (K_C net of small premium).
• Your company needs budget certainty — for example, a Mexican exporter planning MXN cash flows for the next quarter.

Do not use a collar when:

• You have no underlying position to protect (in that case, a collar has a different risk profile and is closer to a risk reversal).
• You strongly believe the price will move sharply in your favor and you want unlimited upside (use a standalone put instead).
• The bid‑ask spread on both options makes the net premium unattractive.

2.5.1.7 Collar vs. other strategies — quick comparison

Strategy	Downside protection	Upside potential	Net premium
Unhedged	None	Unlimited	Zero
Long Put only	Full (below K_P)	Unlimited	-c_P (cost)
Forward (short)	Full	None (locked)	Zero
Collar	Full (below K_P)	Up to K_C	≈ Zero

The collar occupies the middle ground: it gives the same floor as a long put but at a fraction of the cost (or zero cost), accepting a cap on the upside.

---

3 Examples for each option strategy

3.1 1. Bull Call Spread

View: Expect moderate upside, don’t want to pay for unlimited upside.

Example A – Airline hedging fuel price rise

Firm: Airline (jet fuel is a big cost).

Scenario: Fuel is cheap now, but the airline expects prices to rise somewhat over the next 6–12 months, not explode.

Strategy: Buy a call on jet fuel with a lower strike and sell a call with a higher strike (same maturity).

Why this helps:

The bought call protects against fuel becoming too expensive.

The sold call lowers the net premium, which matters for a cost-sensitive airline.

Because the airline only expects a moderate rise in fuel costs, capping the hedge (with the short call) is acceptable.

Example B – Retailer hedging FX for imports

Firm: Clothing retailer importing from Europe, paying in euros.

Scenario: Retailer fears the euro might strengthen a bit against the local currency but not by a huge amount.

Strategy: Buy a call option on EUR (right to buy euros) at a lower strike, sell another EUR call at a higher strike.

Why this helps:

Protects the retailer from a moderate EUR appreciation, which would raise import costs.

The spread is cheaper than a plain long call, which helps margin-sensitive retail.

If EUR appreciates a lot, they don’t gain extra—but that’s acceptable if very big moves are considered unlikely.

3.2 2. Bear Put Spread

View: Expect moderate downside, want protection but at lower cost.

Example A – Tech company with large share-based compensation

Firm: Large tech firm that holds its own stock to cover employee stock option programs.

Scenario: Management fears the stock may drop over the next year but doesn’t expect a crash.

Strategy: Buy a higher-strike put and sell a lower-strike put on its own shares.

Why this helps:

Limits the impact of a moderate decline in the firm’s stock value on the cost of equity compensation.

The sold lower-strike put reduces the hedge cost, which matters if they’re hedging a large position.

They accept some risk of very large losses beyond the lower strike, which they see as unlikely.

Example B – Commodity producer worried about price slip

Firm: Coffee exporter.

Scenario: Coffee prices are high but could fall moderately after harvest; the firm wants downside protection but doesn’t want to fully give up upside if prices stay high.

Strategy: Buy a put at a strike near current prices, sell a lower-strike put.

Why this helps:

Ensures a minimum revenue level while keeping partial exposure to favorable prices.

The cost is lower than buying a full put, which is important given thin producer margins.

Fits the view: risk of a normal price correction, not a full collapse.

3.3 3. Butterfly Spread (using calls)

View: Expect the price to stay in a narrow range around a target level (low volatility view).

Example A – Utility with stable stock and known regulation

Firm: Electric utility with very stable earnings; upcoming regulatory decision is expected to confirm current tariffs (no big surprise).

Scenario: Trader believes the utility’s stock will stay near current price over the next 6 months.

Strategy: Call butterfly centered around today’s price: long low-strike call, short two at-the-money calls, long high-strike call.

Why this helps:

Profits if the stock stays near the middle strike (the expected scenario).

Limited risk if the stock unexpectedly moves a lot.

Cheap way to “bet on stability” in a business known for low volatility.

Example B – Consumer staples company after results

Firm: Large food & beverage company.

Scenario: Earnings just came out, no major surprises, and there are no big events ahead (no lawsuits, no M&A rumors). An analyst expects the stock to trade in a tight band.

Strategy: Call butterfly around the post-earnings price.

Why this helps:

Takes advantage of expected “sideways” trading in a defensive sector.

Low cost, limited risk if something unexpected does happen.

Shows students how to profit from low volatility, not just direction.

3.4 4. Long Straddle

View: Expect a big move, but don’t know the direction (high volatility view).

Example A – Biotech company awaiting FDA decision

Firm: Biotech with a single key drug under review.

Scenario: FDA decision in 3 months: approval → stock may soar; rejection → stock may crash. Direction unknown, but magnitude likely huge.

Strategy: Buy a call and a put at the same strike and maturity.

Why this helps:

Profits if the stock moves sharply either up or down.

Perfect for “binary” events where the sign is uncertain but the move size is big.

Great classroom example of trading event risk.

Example B – Telecom operator with pending merger ruling

Firm: Telecom company awaiting an antitrust ruling on a proposed merger.

Scenario: If the merger is approved → big upside; if blocked → big downside.

Strategy: Long straddle on the telecom’s stock until the decision date.

Why this helps:

Captures large move regardless of whether the regulator says yes or no.

Simple story: students instantly see why both call and put are useful.

3.5 5. Strip (2 puts + 1 call)

View: Expect big move with downside more likely or more damaging.

Example A – Cyclical manufacturer worried about recession

Firm: Auto manufacturer.

Scenario: Macroeconomic data are weak; company is worried a recession will hit car demand, causing its stock to fall a lot, but there’s still some chance of a surprise upside.

Strategy: Buy 2 puts and 1 call at the same strike on its stock index or sector ETF.

Why this helps:

Extra weight on downside (2 puts) reflects that a big drop would be much more painful than a rally would be beneficial.

Retains some upside benefit if things surprisingly improve.

Example B – Luxury goods company exposed to China demand

Firm: Luxury fashion group.

Scenario: Uncertainty about Chinese demand: a slowdown could hurt profits badly; a rebound would be good but less impactful relative to the business risk of a downturn.

Strategy: Strip on its stock or on a luxury sector ETF.

Why this helps:

Emphasizes protection against a sharp fall in demand (downside risk).

Still makes money if demand explodes upward, but downside is the main concern.

3.6 6. Strap (2 calls + 1 put)

View: Expect big move with upside more likely or more valuable.

Example A – Tech company before major product launch

Firm: Smartphone or AI-chip manufacturer.

Scenario: New flagship product will be released. If it’s a hit, the stock could surge; if it disappoints, it may fall, but management believes the upside potential is larger.

Strategy: Strap (2 calls + 1 put at same strike).

Why this helps:

Benefits from volatility, but with extra weight on the upside.

Matches the firm’s belief that upside surprise (blockbuster product) is more valuable than downside risk.

Example B – Oil exploration company drilling a high-potential field

Firm: Oil & gas explorer.

Scenario: Upcoming drilling results: dry well = stock down, big discovery = stock way up. Upside move is likely larger than downside move.

Strategy: Strap on the company’s stock.

Why this helps:

Asymmetric payoff: more exposure to big positive outcome while still getting some protection if things disappoint.

Teaches students how to encode skewed expectations, not just symmetric volatility.

3.7 7. Long Strangle

View: Expect a big move, but want a cheaper volatility bet than a straddle (OK with needing a larger move to break even).

Example A – Airline facing election + regulatory changes

Firm: Airline whose profitability is strongly affected by new regulation and elections in 9–12 months.

Scenario: Combination of political/regulatory outcomes could drive the stock sharply up (deregulation, lower taxes) or sharply down (stricter rules, new taxes), but in the near term the price might drift.

Strategy: Long strangle: buy OTM put (lower strike) and OTM call (higher strike).

Why this helps:

Cheaper than a straddle, so easier to justify for a risk-averse treasury department.

Profits if there’s a large move in either direction once uncertainty resolves.

Example B – Retail chain around Black Friday + holiday season

Firm: Big-box retailer.

Scenario: Holiday season could be a blowout (stock soars) or terrible (stock tanks) depending on consumer spending and supply-chain issues; management expects “big or bust,” not a mild outcome.

Strategy: Long strangle on the retailer or on a retail sector ETF.

Why this helps:

Positions the firm (or an investor) to benefit from an extreme outcome while keeping option costs lower than at-the-money straddles.

Great pedagogical example of trading on tail outcomes.

3.8 8. Collar

View: You hold or will receive an asset and want to protect a floor price at low or zero net premium, accepting a cap on upside.

Example A – Mexican exporter hedging USD receivable (SierraPack-type company)

Firm: Agricultural exporter that invoices 100% in USD but operates in MXN.

Scenario: The company will receive USD 1,000,000 in 6 months. Spot today: 17.50 MXN/USD. The CFO fears the peso could appreciate (lower MXN revenues), but the company also wants to benefit if the peso depreciates further. The treasury does not want to pay a large option premium upfront.

Strategy: Buy a put on USD at K_P = 17.00 (floor), sell a call on USD at K_C = 18.50 (cap). Net premium \approx 0 (zero-cost collar).

Why this helps:

• Floor guaranteed: even if the peso appreciates to 15.00, the company still sells USD at 17.00 — protecting its MXN budget.
• Participates in favorable moves: if the spot stays between 17.00 and 18.50, the company sells at the market rate.
• Near-zero cost: the call premium received offsets the put premium paid — no large cash outlay from the treasury.
• Trade-off accepted: if the peso depreciates sharply (e.g., to 21.00), the company cannot capture that windfall — it is capped at 18.50.

This is the core structure recommended for companies like SierraPack that need budget certainty without paying large hedging premiums.

Example B – Equity investor protecting a concentrated stock position

Firm: Institutional investor holding a large position in a single stock (e.g., after a lockup expiry).

Scenario: The investor cannot sell the stock immediately (legal or tax constraints) but fears a correction over the next 12 months. They want downside protection without paying a large put premium.

Strategy: Buy a put at a strike 10% below current price, sell a call at a strike 15% above current price.

Why this helps:

• Limits the downside loss to 10% of portfolio value.
• Generates call premium that partially or fully offsets the put cost.
• Allows the investor to keep the position (no forced sale) while having defined risk.
• Classic application in equity risk management for concentrated positions.

4 EXERCISES

(All exercises must be in your Excel Workbook)

4.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

2. 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

3. 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

4.2 Option Strategies

Exercises from Hull book, chapter 12

In Excel do the exercises 12.1, 12.2, 12.3, 12.5, and 12.7

   Do your own Excel Template to automate almost-any option strategy
   
   For exercise 12.3, do that in paper, take a picture and paste it in your Excel 

4.3 In-class Call-Parity exercise

1. You have to do the in-class exercise to show the Call-Parity relationship

2. You have to create a general Excel template for most of the Option Strategies composed up to 3 options