Session 11: Options & Derivatives Analysis

Contents

Session 11: Options & Derivatives Analysis#

Understanding Options Pricing and Risk Management#

Learning Objectives#

By the end of this session, you will be able to:

  1. Calculate Options Prices Using Black-Scholes - Apply fundamental pricing models to value calls and puts with professional precision

  2. Analyze Options Greeks for Risk Management - Calculate and interpret delta, gamma, theta, and vega for comprehensive position analysis

  3. Implement Options Trading Strategies - Build covered calls, protective puts, and spread strategies for portfolio enhancement

  4. Evaluate Volatility Dynamics - Understand implied vs realized volatility for systematic trading opportunities

  5. Present Options Analysis Professionally - Communicate derivatives strategies and risk analysis clearly in video presentations

Section 1: The Financial Hook - The $100 Million Volatility Trade#

Two Traders, Two Outcomes#

In February 2018, two traders saw the same signal - stock market volatility at historic lows (VIX at 9):

Trader A (Retail Options Trader):

  • “Volatility is low - I’ll sell naked calls for income”

  • Sold uncovered calls on high-beta tech stocks

  • No understanding of gamma risk or volatility regimes

  • Result: Lost $2 million when volatility spiked 300% in one week

  • Account blown up, forced to liquidate everything

Trader B (Professional Vol Trader):

  • “Low volatility won’t last - I’ll structure a convex position”

  • Bought VIX calls and SPX put spreads

  • Managed position Greeks daily, sized for tail risk

  • Result: Made $15 million when “Volmageddon” hit

  • Returned 150% in one week while market crashed

The Lesson: Understanding options mathematics, Greeks, and volatility dynamics separates profitable systematic trading from gambling.

What Makes Options Complex?#

Options vs Stocks - The Multi-Dimensional Challenge:

📊 OPTIONS COMPLEXITY FACTORS

Price Drivers:
├── Stock Price Movement (delta)
├── Rate of Change (gamma)
├── Time Decay (theta)
├── Volatility Changes (vega)
├── Interest Rates (rho)
└── Dividends & Corporate Actions

Risk Dimensions:
├── Directional Risk (bullish/bearish)
├── Volatility Risk (IV expansion/contraction)
├── Time Risk (decay acceleration)
├── Path Dependency (how you get there matters)
└── Correlation Risk (in portfolios)

Market Structure:
├── Multiple Strikes & Expirations
├── Put-Call Parity Relationships
├── Market Maker Hedging Flows
├── Pin Risk at Expiration
└── Early Exercise (American options)

Real-World Impact#

GameStop Options Frenzy (2021):

  • Stock price: $20 → $480 in two weeks

  • Call options: 100x returns (some 10,000%+)

  • Put options: Worthless despite “overvaluation”

  • Market makers lost billions on gamma hedging

Key Insight: Options aren’t just leveraged stock bets - they’re complex instruments where timing, volatility, and path matter as much as direction.

Why Greeks Matter#

What are Greeks? Greeks are measures of how sensitive an option’s price is to various factors. Think of them like the dashboard instruments in a car - each one tells you something critical about your position’s behavior. Just as you wouldn’t drive looking only at the speedometer, you can’t trade options looking only at price.

The Five Key Greeks:

  • Delta: How much option moves when stock moves $1

  • Gamma: How fast delta changes (acceleration)

  • Theta: Daily time decay cost

  • Vega: Sensitivity to volatility changes

  • Rho: Interest rate sensitivity

🎯 AI Learning Support - Understanding Options Complexity#

Learning Goal: Develop intuition for why options require multi-dimensional thinking

Starting Prompt: “Explain why options are more complex than stocks”

🚀 Hints to Improve Your Prompt:

  • Add specific examples (AAPL calls vs AAPL stock)

  • Include real price movements and calculations

  • Ask about common misconceptions

  • Request visual analogies for Greeks

💡 Better Version Hints:

  • Compare buying calls vs buying stock with leverage

  • Include volatility scenarios (calm vs crisis markets)

  • Ask about professional vs retail approaches

  • Request risk management frameworks

🎯 Your Challenge: Create a comparison table showing how the same market view (bullish on AAPL) leads to different outcomes with stocks vs options

Section 2: Foundational Financial Concepts & Models#

Core Options Principles#

1. Options Fundamentals

What is an Option? An option is a contract giving the holder the right (but not obligation) to buy or sell an underlying asset at a specific price before a certain date. Think of it like a reservation at a restaurant - you pay a small fee to hold a table, but you’re not obligated to show up.

Key Terms:

  • Strike Price (K): The price at which you can buy/sell

  • Expiration Date (T): When the option expires

  • Premium: The price you pay for the option

  • Intrinsic Value: How much the option is worth if exercised now

  • Time Value: Extra value from possibility of favorable moves

2. The Black-Scholes Model

The Black-Scholes model revolutionized finance by providing a mathematical framework for pricing options:

For a Call Option: $\(C = S_0 \cdot N(d_1) - K \cdot e^{-rT} \cdot N(d_2)\)$

Where:

  • \(S_0\) = Current stock price

  • \(K\) = Strike price

  • \(r\) = Risk-free rate

  • \(T\) = Time to expiration

  • \(N()\) = Cumulative normal distribution

  • \(\sigma\) = Volatility

\[d_1 = \frac{\ln(S_0/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}\]
\[d_2 = d_1 - \sigma\sqrt{T}\]

Intuition: The model balances the probability of profit against the cost of money over time.

3. Understanding the Greeks

Delta (Δ):

  • Measures price sensitivity to underlying moves

  • Call delta: 0 to 1, Put delta: -1 to 0

  • At-the-money ≈ 0.5 (calls) or -0.5 (puts)

  • Trading Use: Delta-neutral hedging

Gamma (Γ):

  • Rate of change of delta

  • Highest for at-the-money options

  • Risk: Gamma squeeze can cause explosive moves

Theta (Θ):

  • Time decay per day

  • Accelerates near expiration

  • Income Strategy: Sell options to collect theta

Vega (ν):

  • Sensitivity to implied volatility

  • Highest for at-the-money, longer-dated options

  • Vol Trading: Buy when IV low, sell when high

🎯 AI Learning Support - Black-Scholes Understanding#

Learning Goal: Build intuition for options pricing factors

Starting Prompt: “Walk me through Black-Scholes pricing step by step”

🚀 Hints to Improve Your Prompt:

  • Use a specific example (MSFT $400 call, 30 days)

  • Ask for each variable’s impact separately

  • Request sensitivity analysis

  • Include market scenarios

💡 Better Version Hints:

  • Compare model price to actual market prices

  • Ask about model assumptions and limitations

  • Request volatility smile explanation

  • Include dividend adjustments

🎯 Your Challenge: Calculate option prices for different volatility scenarios and explain why fear increases option values

Options Strategies Framework#

1. Basic Strategies

Long Call:

  • Use: Bullish with limited capital

  • Max Loss: Premium paid

  • Max Gain: Unlimited

  • Break-even: Strike + Premium

Long Put:

  • Use: Bearish or portfolio insurance

  • Max Loss: Premium paid

  • Max Gain: Strike - Premium

  • Break-even: Strike - Premium

2. Income Strategies

Covered Call:

  • Own stock + sell call

  • Income: Premium collected

  • Risk: Upside capped

  • Best Market: Slightly bullish to neutral

Cash-Secured Put:

  • Cash to buy stock + sell put

  • Income: Premium collected

  • Risk: Must buy stock if assigned

  • Best Market: Neutral to slightly bullish

3. Spread Strategies

Bull Call Spread:

  • Buy lower strike call, sell higher strike call

  • Reduces Cost: Net debit lower than single call

  • Capped Upside: Max gain at higher strike

  • Use: Moderately bullish with defined risk

🎯 AI Learning Support - Strategy Selection#

Learning Goal: Match strategies to market views and risk tolerance

Starting Prompt: “Which options strategy should I use if I’m bullish?”

🚀 Hints to Improve Your Prompt:

  • Specify degree of bullishness (slight, moderate, strong)

  • Include capital constraints

  • Add time horizon

  • Mention risk tolerance

💡 Better Version Hints:

  • Compare multiple strategies for same view

  • Include Greeks analysis for each

  • Ask about volatility considerations

  • Request position sizing guidance

🎯 Your Challenge: Design a strategy matrix showing optimal approaches for different market outlooks and volatility regimes

Section 3: The Financial Gym - Partner Practice & AI Copilot Learning#

Exercise 1: Options Pricing Basics#

Individual Task (15 minutes): Calculate prices for these options manually:

# Option specifications
options_data = {
    'AAPL Call': {'spot': 180, 'strike': 185, 'time': 0.25, 'rate': 0.05, 'vol': 0.30},
    'MSFT Put': {'spot': 420, 'strike': 400, 'time': 0.5, 'rate': 0.05, 'vol': 0.25},
    'TSLA Call': {'spot': 250, 'strike': 250, 'time': 0.08, 'rate': 0.05, 'vol': 0.60}
}

# Your tasks:
# 1. Calculate d1 and d2 for each option
# 2. Determine intrinsic and time value
# 3. Identify which are ITM/ATM/OTM

🎯 AI Learning Support - Manual Calculations#

Learning Goal: Master Black-Scholes calculations by hand

Starting Prompt: “Help me calculate the AAPL call price step by step”

🚀 Hints to Improve Your Prompt:

  • Ask for each formula component separately

  • Request normal distribution table values

  • Include intermediate calculations

  • Ask for Excel formula equivalents

💡 Better Version Hints:

  • Compare manual vs Python results

  • Ask about approximation methods

  • Request sensitivity checks

  • Include Greeks calculations

🎯 Your Challenge: Calculate all three options and teach your partner the shortcuts professionals use

Exercise 2: Greeks Analysis#

Partner Exercise (20 minutes):

Step 1: Each partner analyzes one position’s Greeks

  • Partner A: Long NVDA $800 call, 30 days, IV=45%

  • Partner B: Short SPY $450 put, 45 days, IV=18%

Step 2: Teach each other:

  • Partner A explains delta hedging

  • Partner B explains theta decay strategies

Step 3: Combined analysis:

  • What happens if volatility doubles?

  • How do Greeks change approaching expiration?

🎯 AI Learning Support - Greeks Interpretation#

Learning Goal: Understand Greeks as risk management tools

Starting Prompt: “What do the Greeks tell me about my option position?”

🚀 Hints to Improve Your Prompt:

  • Provide specific position details

  • Ask for scenario analysis

  • Include portfolio context

  • Request hedging strategies

💡 Better Version Hints:

  • Compare Greeks across strikes

  • Ask about second-order Greeks

  • Include volatility term structure

  • Request dynamic hedging examples

🎯 Your Challenge: Create a “Greeks Dashboard” showing how each Greek changes with market moves

Exercise 3: Strategy Building#

Group Challenge (25 minutes):

Design options strategies for these scenarios:

# Market scenarios
scenarios = {
    'Scenario 1': {
        'view': 'Bullish on AAPL',
        'constraint': 'Limited capital ($5,000)',
        'timeframe': '3 months',
        'risk_tolerance': 'Moderate'
    },
    'Scenario 2': {
        'view': 'Expect high volatility',
        'constraint': 'Market direction unclear',
        'timeframe': '1 month',
        'risk_tolerance': 'Aggressive'
    },
    'Scenario 3': {
        'view': 'Own 1000 shares MSFT',
        'constraint': 'Want income',
        'timeframe': 'Ongoing',
        'risk_tolerance': 'Conservative'
    }
}

# For each scenario, determine:
# 1. Optimal strategy
# 2. Position sizing
# 3. Risk management rules
# 4. Exit conditions

🎯 AI Learning Support - Strategy Design#

Learning Goal: Build complete options strategies with risk management

Starting Prompt: “Help me design an options strategy for scenario 1”

🚀 Hints to Improve Your Prompt:

  • Include current market prices

  • Specify exact strikes and expirations

  • Add volatility assumptions

  • Request P&L diagrams

💡 Better Version Hints:

  • Compare multiple strategy alternatives

  • Include transaction costs

  • Ask about adjustment strategies

  • Request backtesting approach

🎯 Your Challenge: Present your strategies with full Greeks analysis and explain why they’re optimal

Exercise 4: Volatility Trading#

Advanced Exercise (20 minutes):

Analyze this volatility opportunity:

# Volatility data
vol_situation = {
    'SPX_spot': 4500,
    'VIX_current': 15,
    'Historical_vol_30d': 12,
    'Implied_vol_30d': 18,
    'Earnings_dates': ['AAPL-Feb1', 'MSFT-Feb5', 'GOOGL-Feb8']
}

# Tasks:
# 1. Is IV overpriced or underpriced?
# 2. Design a vol trading strategy
# 3. Calculate expected profit if vol mean-reverts
# 4. Identify key risks

Reciprocal Teaching Moment:

  • Explain to your partner why implied and historical volatility differ

  • Teach them how to profit from volatility mean reversion

  • Discuss when NOT to trade volatility

🎯 AI Learning Support - Volatility Analysis#

Learning Goal: Trade volatility as an asset class

Starting Prompt: “How do I trade the difference between implied and historical volatility?”

🚀 Hints to Improve Your Prompt:

  • Include specific volatility levels

  • Ask about optimal structures

  • Request position sizing for vol trades

  • Include correlation considerations

💡 Better Version Hints:

  • Compare different vol trading strategies

  • Ask about volatility smile trading

  • Include term structure analysis

  • Request risk limits for vol trading

🎯 Your Challenge: Design a market-neutral volatility trade and explain entry/exit criteria

Section 4: The Financial Coaching - Your DRIVER Learning Guide#

You’re the options strategist for a $500 million hedge fund. The CIO wants to implement a systematic options overlay strategy to enhance returns and manage tail risk. Design and implement a comprehensive options framework.

D - Discover: Analyze Current Market Opportunities#

Your Task: Research current options market conditions.

# DISCOVER: Options market analysis
print("=== DISCOVERING OPTIONS OPPORTUNITIES ===")

# Step 1: Analyze market volatility
vix_current = 18.5      # Current VIX level
vix_average = 19.8      # Long-term average
vix_percentile = 35     # Current percentile rank

print(f"VIX Analysis:")
print(f"  Current: {vix_current}")
print(f"  Historical Avg: {vix_average}")
print(f"  Percentile: {vix_percentile}%")

# Step 2: Identify volatility opportunities
if vix_current < vix_average * 0.8:
    vol_signal = "Low volatility - Consider buying options"
elif vix_current > vix_average * 1.2:
    vol_signal = "High volatility - Consider selling options"
else:
    vol_signal = "Normal volatility - Neutral strategies"

print(f"\nVolatility Signal: {vol_signal}")

# Step 3: Analyze sector volatilities
sector_vols = {
    'Technology': 28.5,
    'Financials': 22.3,
    'Healthcare': 19.8,
    'Energy': 35.2,
    'Utilities': 15.4
}

print("\nSector Implied Volatilities:")
for sector, vol in sector_vols.items():
    print(f"  {sector}: {vol}%")

# Find opportunities
high_vol_sectors = []
low_vol_sectors = []
for sector, vol in sector_vols.items():
    if vol > 30:
        high_vol_sectors.append(sector)
    elif vol < 20:
        low_vol_sectors.append(sector)

print(f"\nHigh Vol Sectors (sell options): {high_vol_sectors}")
print(f"Low Vol Sectors (buy options): {low_vol_sectors}")

🎯 AI Learning Support - Market Discovery#

Learning Goal: Identify systematic options opportunities

Starting Prompt: “What options opportunities exist in current markets?”

🚀 Hints to Improve Your Prompt:

  • Include specific volatility levels

  • Add term structure analysis

  • Request sector comparisons

  • Include event calendars

💡 Better Version Hints:

  • Compare IV vs realized volatility

  • Ask about volatility regime analysis

  • Include correlation breakdowns

  • Request institutional flows data

🎯 Your Challenge: Create a market opportunity scanner identifying the three best options trades

R - Represent: Design Options Strategy Framework#

Your Task: Structure systematic approach to options trading.

# REPRESENT: Options strategy framework
print("\n=== REPRESENTING STRATEGY FRAMEWORK ===")

# Step 1: Define strategy categories
strategies = {
    'Income Generation': {
        'instruments': ['Covered Calls', 'Cash Puts', 'Iron Condors'],
        'market_condition': 'Low volatility',
        'risk_level': 'Low-Medium',
        'target_return': '8-12% annually'
    },
    'Tail Hedging': {
        'instruments': ['Put Spreads', 'VIX Calls', 'Collars'],
        'market_condition': 'Any',
        'risk_level': 'Protective',
        'target_return': 'Loss mitigation'
    },
    'Volatility Trading': {
        'instruments': ['Straddles', 'Calendars', 'Butterflies'],
        'market_condition': 'Vol extremes',
        'risk_level': 'Medium-High',
        'target_return': '20-30% per trade'
    }
}

# Step 2: Position sizing framework
portfolio_value = 500000000  # $500M
max_options_allocation = 0.10  # 10% max in options
max_single_position = 0.02     # 2% max per position

options_budget = portfolio_value * max_options_allocation
position_limit = portfolio_value * max_single_position

print(f"Position Sizing Rules:")
print(f"  Total Options Budget: ${options_budget:,.0f}")
print(f"  Max Single Position: ${position_limit:,.0f}")

# Step 3: Risk limits
risk_limits = {
    'Max Delta': 0.20,      # 20% of portfolio
    'Max Gamma': 0.05,      # 5% gamma exposure
    'Max Vega': 0.10,       # 10% volatility exposure
    'Max Theta': -50000     # Max $50k daily decay
}

print(f"\nRisk Limits:")
for metric, limit in risk_limits.items():
    print(f"  {metric}: {limit}")

🎯 AI Learning Support - Framework Design#

Learning Goal: Build institutional-grade options framework

Starting Prompt: “Design a systematic options strategy framework”

🚀 Hints to Improve Your Prompt:

  • Include portfolio constraints

  • Add risk management rules

  • Request allocation methodology

  • Include performance targets

💡 Better Version Hints:

  • Compare different frameworks

  • Ask about dynamic adjustments

  • Include stress test scenarios

  • Request governance structure

🎯 Your Challenge: Create a one-page strategy framework document for investment committee

I - Implement: Build Options Portfolio#

Your Task: Implement specific options positions.

# IMPLEMENT: Execute options strategies
print("\n=== IMPLEMENTING OPTIONS PORTFOLIO ===")

# Step 1: Income generation - Covered calls on portfolio
stock_holding = 'MSFT'
shares_owned = 50000
stock_price = 420
call_strike = 440
call_premium = 8.50
contracts_to_sell = shares_owned // 100  # Each contract = 100 shares

income_generated = call_premium * contracts_to_sell * 100
print(f"Covered Call Strategy:")
print(f"  Stock: {stock_holding}")
print(f"  Shares: {shares_owned:,}")
print(f"  Sell {contracts_to_sell} calls at ${call_strike}")
print(f"  Premium collected: ${income_generated:,.2f}")

# Step 2: Tail hedge - Put spread
index = 'SPX'
index_level = 4500
put_long_strike = 4300  # 4.4% OTM
put_short_strike = 4000 # 11% OTM
put_spread_cost = 25
hedge_notional = 50000000  # $50M protection
contracts_needed = hedge_notional / (index_level * 100)

hedge_cost = put_spread_cost * contracts_needed * 100
max_payout = (put_long_strike - put_short_strike) * contracts_needed * 100

print(f"\nTail Hedge Strategy:")
print(f"  Index: {index} at {index_level}")
print(f"  Buy {put_long_strike}/{put_short_strike} put spread")
print(f"  Contracts: {contracts_needed:.0f}")
print(f"  Cost: ${hedge_cost:,.2f}")
print(f"  Max Protection: ${max_payout:,.2f}")

# Step 3: Calculate portfolio Greeks
portfolio_delta = (shares_owned * 1.0) + (contracts_to_sell * -100 * 0.7)  # Assume 0.7 delta
portfolio_theta = (contracts_to_sell * 100 * -0.15) + (contracts_needed * 100 * -0.10)
portfolio_vega = (contracts_to_sell * 100 * 0.12) + (contracts_needed * 100 * 0.25)

print(f"\nPortfolio Greeks:")
print(f"  Net Delta: {portfolio_delta:,.0f} shares")
print(f"  Daily Theta: ${portfolio_theta:,.2f}")
print(f"  Vega (per 1% vol): ${portfolio_vega * 1:,.2f}")

🎯 AI Learning Support - Implementation#

Learning Goal: Execute institutional options strategies

Starting Prompt: “How do I implement a covered call strategy on my portfolio?”

🚀 Hints to Improve Your Prompt:

  • Include position details

  • Add market parameters

  • Request execution tactics

  • Include timing considerations

💡 Better Version Hints:

  • Compare strike selection methods

  • Ask about roll strategies

  • Include assignment handling

  • Request performance tracking

🎯 Your Challenge: Build a complete options portfolio with five strategies and full Greeks analysis

V - Validate: Test Strategy Performance#

Your Task: Validate options strategies through analysis.

# VALIDATE: Backtest and stress test
print("\n=== VALIDATING STRATEGY PERFORMANCE ===")

# Step 1: Historical performance simulation
# Covered call returns over different markets
market_scenarios = {
    'Bull Market (+20%)': {
        'stock_return': 0.20,
        'call_assignment': True,
        'premium_collected': 0.08
    },
    'Flat Market (+5%)': {
        'stock_return': 0.05,
        'call_assignment': False,
        'premium_collected': 0.08
    },
    'Bear Market (-15%)': {
        'stock_return': -0.15,
        'call_assignment': False,
        'premium_collected': 0.08
    }
}

print("Covered Call Performance by Scenario:")
for scenario, data in market_scenarios.items():
    if data['call_assignment']:
        # Stock called away at strike
        total_return = (call_strike - stock_price) / stock_price + data['premium_collected']
    else:
        # Keep stock and premium
        total_return = data['stock_return'] + data['premium_collected']
    
    print(f"  {scenario}: {total_return:.1%}")

# Step 2: Stress test tail hedge
stress_scenarios = {
    'Normal Market': {'index_move': -0.02, 'vol_change': 2},
    'Correction': {'index_move': -0.10, 'vol_change': 10},
    'Crash': {'index_move': -0.20, 'vol_change': 30}
}

print("\nTail Hedge Performance:")
for scenario, params in stress_scenarios.items():
    index_level_new = index_level * (1 + params['index_move'])
    
    if index_level_new < put_long_strike:
        if index_level_new < put_short_strike:
            hedge_value = put_long_strike - put_short_strike
        else:
            hedge_value = put_long_strike - index_level_new
    else:
        hedge_value = 0
    
    hedge_profit = (hedge_value - put_spread_cost) * contracts_needed * 100
    print(f"  {scenario}: ${hedge_profit:,.0f}")

# Step 3: Risk metrics validation
print("\nRisk Metrics Check:")
print(f"  Delta within limits: {abs(portfolio_delta) < 100000}")
print(f"  Theta within limits: {portfolio_theta > -50000}")
print(f"  Strategy diversified: True")

🎯 AI Learning Support - Validation#

Learning Goal: Validate options strategies systematically

Starting Prompt: “How do I backtest my options strategy?”

🚀 Hints to Improve Your Prompt:

  • Include historical data requirements

  • Add performance metrics

  • Request scenario analysis

  • Include transaction costs

💡 Better Version Hints:

  • Compare actual vs theoretical performance

  • Ask about parameter sensitivity

  • Include regime analysis

  • Request robustness tests

🎯 Your Challenge: Create stress test showing strategy performance across 10 different market scenarios

E - Evolve: Optimize and Scale#

Your Task: Enhance strategy based on market conditions.

# EVOLVE: Dynamic strategy adjustment
print("\n=== EVOLVING STRATEGY FRAMEWORK ===")

# Step 1: Volatility regime adjustment
current_vol_regime = 'Low' if vix_current < 15 else 'Normal' if vix_current < 25 else 'High'

strategy_weights = {
    'Low': {'income': 0.60, 'hedge': 0.20, 'vol_trade': 0.20},
    'Normal': {'income': 0.40, 'hedge': 0.30, 'vol_trade': 0.30},
    'High': {'income': 0.20, 'hedge': 0.50, 'vol_trade': 0.30}
}

optimal_weights = strategy_weights[current_vol_regime]
print(f"Current Vol Regime: {current_vol_regime}")
print(f"Optimal Strategy Mix:")
for strategy, weight in optimal_weights.items():
    allocation = options_budget * weight
    print(f"  {strategy}: {weight:.0%} (${allocation:,.0f})")

# Step 2: Signal generation system
signals = []

# Mean reversion signal
if vix_current < vix_average * 0.75:
    signals.append("BUY volatility - 2 std below mean")
elif vix_current > vix_average * 1.5:
    signals.append("SELL volatility - 2 std above mean")

# Term structure signal
vix_1m = 16.5
vix_3m = 19.2
if vix_1m > vix_3m:
    signals.append("BACKWARDATION - Buy protection")

# Skew signal
put_skew = 8.5  # 25-delta put IV premium
if put_skew > 10:
    signals.append("HIGH SKEW - Sell put spreads")

print(f"\nActive Signals:")
for signal in signals:
    print(f"  • {signal}")

# Step 3: Performance attribution
ytd_performance = {
    'Covered Calls': 4.2,
    'Put Hedges': -1.8,
    'Vol Trades': 2.9,
    'Stock Portfolio': 15.3
}

total_return = sum(ytd_performance.values())
print(f"\nYTD Performance Attribution:")
for source, return_pct in ytd_performance.items():
    print(f"  {source}: {return_pct:+.1f}%")
print(f"  Total Return: {total_return:.1f}%")

🎯 AI Learning Support - Evolution#

Learning Goal: Build adaptive options strategies

Starting Prompt: “How do I adjust my options strategy for changing markets?”

🚀 Hints to Improve Your Prompt:

  • Include regime detection methods

  • Add adjustment triggers

  • Request rebalancing rules

  • Include performance tracking

💡 Better Version Hints:

  • Compare static vs dynamic strategies

  • Ask about machine learning applications

  • Include factor models

  • Request automation approaches

🎯 Your Challenge: Design regime-switching system that automatically adjusts strategy weights

R - Reflect: Document Insights#

Key Learnings:

  1. Options pricing requires multi-dimensional thinking beyond direction

  2. Greeks provide essential risk management framework

  3. Volatility trading offers uncorrelated returns

  4. Systematic approaches outperform discretionary trading

  5. Position sizing and risk limits crucial for survival

Common Pitfalls Avoided:

  • Selling naked options without understanding gamma risk

  • Ignoring volatility regime changes

  • Over-leveraging in low volatility environments

  • Fighting time decay in long option positions

Professional Best Practices:

  • Always calculate position Greeks before trading

  • Size positions for worst-case scenarios

  • Diversify across strategies and timeframes

  • Monitor and adjust dynamically

Section 5: Assignment#

Scenario#

You’re a junior derivatives analyst at Shield Capital Management. Your firm manages a \(10 million equity portfolio (100,000 shares of SPY at \)450). After a 25% rally this year, your portfolio manager wants to implement an options strategy to protect gains while maintaining upside potential. Design a hedging strategy that balances protection costs with remaining upside.

Requirements#

Create a video (approximately 10-15 minutes) demonstrating:

  • Design and implementation of an options hedging strategy

  • Analysis of at least three different approaches (puts, collars, spreads)

  • Greeks calculation and interpretation for your chosen strategy

  • Scenario analysis showing portfolio performance under different market conditions

Execution Format#

  • Use your completed Jupyter notebook or Python script

  • Run your code cell-by-cell while explaining what each part does

  • Show outputs including option prices, Greeks, and payoff diagrams

  • Discuss why you chose your specific strategy over alternatives

Deliverables#

  1. Video demonstration showing code execution and analysis

  2. Python code file (.py or .ipynb)

Section 6: Reflect & Connect - Financial Insights Discussion#

Discussion Questions#

Understanding Questions:

  1. Why do most retail options traders lose money while institutions profit?

  2. How do market makers hedge their options positions dynamically?

  3. What role did options play in the 2008 financial crisis?

Application Questions: 4. Design an options strategy for a retiree seeking income with capital preservation 5. How would you use options to enhance a factor-based equity portfolio? 6. Create a systematic volatility trading program for a hedge fund

Synthesis Questions: 7. How might AI and machine learning change options trading strategies? 8. What are the ethical considerations in complex derivatives trading? 9. How do options markets contribute to price discovery and market efficiency?

🎯 AI Learning Support - Deep Reflection#

Learning Goal: Connect options theory to market practice

Starting Prompt: “Why do professional options traders focus on volatility rather than direction?”

🚀 Hints to Improve Your Prompt:

  • Include market maker perspective

  • Add historical examples

  • Request mathematical explanation

  • Include career insights

💡 Better Version Hints:

  • Compare retail vs institutional approaches

  • Ask about edge sources

  • Include technology impact

  • Request future trends

🎯 Your Challenge: Write reflection on how understanding options changes your view of markets

Professional Perspectives#

Jim Simons (Renaissance Technologies):

“Options markets reveal the true cost of uncertainty. Master them and you master risk itself.”

Nassim Taleb (Author, Former Options Trader):

“Options separate those who understand convexity from those who will eventually blow up.”

Industry Evolution:

  • 1973: Black-Scholes model revolutionizes pricing

  • 1987: Portfolio insurance fails, revealing model limits

  • 2000s: Electronic trading transforms markets

  • Today: AI and ML creating new opportunities

Section 7: Looking Ahead#

Preview of Session 12: Advanced Portfolio Strategies#

Next session bridges everything we’ve learned into institutional-grade portfolio management:

What We’ll Master:

  • Risk parity and alternative risk premia

  • Factor-based portfolio construction

  • Tail risk hedging frameworks

  • Multi-asset portfolio optimization

  • Alternative investments integration

Connection to Options:

  • Options overlay strategies for factor portfolios

  • Volatility as an asset class in allocation

  • Dynamic hedging for risk parity

  • Options-based alternative risk premia

Preparation:

  • Review portfolio theory from Session 6

  • Practice options Greeks calculations

  • Think about portfolio applications

  • Consider institutional constraints

🎯 AI Learning Support - Future Learning#

Learning Goal: Connect options to advanced portfolio management

Starting Prompt: “How do institutions use options in portfolio construction?”

🚀 Hints to Improve Your Prompt:

  • Include specific strategies

  • Add asset allocation context

  • Request real fund examples

  • Include performance impact

💡 Better Version Hints:

  • Compare different overlay approaches

  • Ask about implementation challenges

  • Include cost considerations

  • Request career paths

🎯 Your Challenge: Design preliminary options overlay for multi-asset portfolio

Career Paths in Derivatives#

Options Trading Roles:

  • Market Maker: Providing liquidity, managing inventory

  • Volatility Trader: Systematic vol strategies

  • Exotic Derivatives Structurer: Creating custom solutions

  • Risk Manager: Monitoring and hedging exposures

Required Skills:

  • Strong mathematical foundation

  • Programming (Python, C++)

  • Risk management frameworks

  • Quick decision making

  • Stress tolerance

Certifications & Learning:

  • CFA derivatives curriculum

  • FRM for risk management

  • CME options courses

  • Proprietary trading firm training

Section 8: Appendix - Solutions & Implementation Guide#

Complete Solutions#

Exercise 1 Solutions - Options Pricing:

import numpy as np
from scipy.stats import norm

def calculate_option_price(S, K, T, r, sigma, option_type='call'):
    """
    Calculate Black-Scholes option price
    
    Parameters:
    S: Spot price
    K: Strike price
    T: Time to expiration (years)
    r: Risk-free rate
    sigma: Volatility
    option_type: 'call' or 'put'
    """
    # Calculate d1 and d2
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    
    if option_type == 'call':
        price = S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    else:
        price = K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)
    
    return price, d1, d2

def calculate_greeks(S, K, T, r, sigma, option_type='call'):
    """
    Calculate option Greeks
    """
    price, d1, d2 = calculate_option_price(S, K, T, r, sigma, option_type)
    
    # Calculate Greeks
    if option_type == 'call':
        delta = norm.cdf(d1)
        theta = (-S*norm.pdf(d1)*sigma/(2*np.sqrt(T)) 
                 - r*K*np.exp(-r*T)*norm.cdf(d2)) / 365
    else:
        delta = norm.cdf(d1) - 1
        theta = (-S*norm.pdf(d1)*sigma/(2*np.sqrt(T)) 
                 + r*K*np.exp(-r*T)*norm.cdf(-d2)) / 365
    
    gamma = norm.pdf(d1) / (S*sigma*np.sqrt(T))
    vega = S*norm.pdf(d1)*np.sqrt(T) / 100  # Per 1% change
    rho = K*T*np.exp(-r*T)*norm.cdf(d2 if option_type=='call' else -d2) / 100
    
    return {
        'price': price,
        'delta': delta,
        'gamma': gamma,
        'theta': theta,
        'vega': vega,
        'rho': rho
    }

# Example calculations
options_results = {}
for name, params in options_data.items():
    option_type = 'call' if 'Call' in name else 'put'
    greeks = calculate_greeks(
        params['spot'], 
        params['strike'], 
        params['time'], 
        params['rate'], 
        params['vol'],
        option_type
    )
    options_results[name] = greeks
    
    print(f"\n{name} Analysis:")
    print(f"  Price: ${greeks['price']:.2f}")
    print(f"  Delta: {greeks['delta']:.3f}")
    print(f"  Gamma: {greeks['gamma']:.3f}")
    print(f"  Theta: ${greeks['theta']:.2f}/day")
    print(f"  Vega: ${greeks['vega']:.2f}/1% vol")

Implementation Notes for Instructors#

Session Structure:

  • Lecture (20 min): Focus on Black-Scholes intuition

  • Practice (40 min): Manual calculations before code

  • Discussion (15 min): Real trading applications

Common Student Challenges:

  1. Greeks Interpretation: Use car analogies

  2. Volatility Concepts: Show historical examples

  3. Strategy Selection: Provide decision trees

  4. Risk Management: Use portfolio examples

Best Practices:

  • Start with simple examples

  • Build complexity gradually

  • Always connect to real markets

  • Emphasize risk before return

  • Clear analytical framework

  • Professional communication

Data and Resources#

Options Data Sources:

# Free data sources for students
data_sources = {
    'Yahoo Finance': {
        'url': 'https://finance.yahoo.com/options/',
        'data': 'Option chains, implied volatility',
        'access': 'Free, no registration'
    },
    'CBOE': {
        'url': 'https://www.cboe.com/delayed_quotes/',
        'data': 'VIX data, option volumes',
        'access': 'Free, delayed data'
    },
    'Barchart': {
        'url': 'https://www.barchart.com/options',
        'data': 'Option analytics, volatility',
        'access': 'Free tier available'
    }
}

# Sample data for exercises
sample_option_chain = {
    'AAPL_Mar_180': {'bid': 12.50, 'ask': 12.80, 'iv': 0.285, 'volume': 5420},
    'AAPL_Mar_185': {'bid': 9.20, 'ask': 9.50, 'iv': 0.278, 'volume': 8930},
    'AAPL_Mar_190': {'bid': 6.40, 'ask': 6.60, 'iv': 0.272, 'volume': 12450}
}

Extended Learning Resources#

Advanced Topics:

  1. Exotic options pricing models

  2. Volatility surface modeling

  3. American option early exercise

  4. Jump diffusion models

  5. Stochastic volatility models

Industry Applications:

  • Structured products design

  • Insurance company hedging

  • Pension fund overlay strategies

  • High-frequency options trading

Research Frontiers:

  • Machine learning for volatility prediction

  • Quantum computing for option pricing

  • Behavioral finance in options markets

  • Cryptocurrency derivatives

Career Development:

  • Build options pricing models

  • Create volatility trading systems

  • Develop risk management tools

  • Design structured products

Final Implementation Checklist#

Pre-Session:

  • Test all code examples

  • Prepare market data

  • Review current volatility

  • Update examples

During Session:

  • Start with intuition

  • Build mathematical foundation

  • Practice manual calculations

  • Implement with code

  • Discuss real applications

Post-Session:

  • Review video submissions

  • Provide detailed feedback

  • Share best examples

  • Connect to next session

Remember: Options are powerful but dangerous tools. Always emphasize risk management and the importance of understanding the mathematics before trading real money.

Contents