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

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

  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

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