Options Combination Strategies

Single option positions carry high risk. By combining multiple options, you can create strategies with various risk-reward profiles.

🔥 Vibe Prompt

"Implement common option strategy P&L calculations in Python: Bull Call Spread, Bear Put Spread, Straddle, Strangle, Iron Condor. Output P&L table and chart for each strategy."

Core Strategies

| Strategy | Market View | Risk | Reward | |----------|-------------|------|--------| | Bull Call Spread | Slightly bullish | Limited | Limited | | Bear Put Spread | Slightly bearish | Limited | Limited | | Straddle | Big move expected | High (double premium) | Unlimited | | Strangle | Big move expected | Medium (cheaper) | Unlimited | | Iron Condor | Range-bound | Limited | Limited |

Practice Exercise

💡 Vibe Coding Practice: Ask AI to build an "Options Strategy Analyzer":

Choose strategy (Spread / Straddle / Strangle / Iron Condor)

Input parameters, calculate P&L table

Plot P&L curve with break-even points

Show max profit, max loss, break-even points

Compare different strategies

Visualizing Option Prices

import matplotlib.pyplot as plt
import numpy as np

stock_prices = np.linspace(50, 150, 100)
prices = [black_scholes(S, 100, 0.5, 0.05, 0.2, 'call') for S in stock_prices]
plt.plot(stock_prices, prices)
plt.axvline(100, color='gray', linestyle='--', alpha=0.5)
plt.title('Call Option Price vs Stock Price')
plt.xlabel('Stock Price')
plt.ylabel('Option Price')
plt.grid(True, alpha=0.3)
plt.show()

Sensitivity Analysis

Impact of Volatility

vols = [0.1, 0.2, 0.3, 0.4, 0.5]
S, K, T, r = 100, 100, 0.5, 0.05
for sigma in vols:
    call = black_scholes(S, K, T, r, sigma, 'call')
    put = black_scholes(S, K, T, r, sigma, 'put')
    print(f'Vol {sigma:.0%}: Call ${call:.2f}, Put ${put:.2f}')

Time Decay

As expiration approaches, time value decreases
Theta accelerates in the final 30 days
ATM options have the highest time value

Practical Applications

Real-World Use Cases

Portfolio Insurance: Buy OTM puts to protect against market crashes
Income Generation: Sell covered calls on stocks you already own
Volatility Trading: Trade options based on volatility expectations
Earnings Play: Trade options around earnings announcements

Greeks in Practice

| Greek | Trader's Focus | |-------|---------------| | Delta | Directional risk, hedge ratio | | Gamma | Convexity, risk of large moves | | Theta | Time decay, option seller's friend | | Vega | Volatility risk, earnings plays | | Rho | Interest rate risk, long-dated options |

Common Issues & Solutions

| Problem | Cause | Solution | |---------|-------|----------| | Unexpected results | Wrong parameters | Check defaults and edge cases | | Slow execution | Inefficient algorithm | Use better data structures | | Out of memory | Too much data | Use batch processing | | Hard to debug | No logging | Add detailed logging |

Further Learning

Read official documentation
Browse open-source examples on GitHub
Join community discussions
Practice by modifying code and observing results

Vertical Spreads

A vertical spread involves buying and selling options of the same type (calls or puts) with different strikes but the same expiry.

Bull Call Spread

Buy ATM call + Sell OTM call = Limited profit, limited risk

def bull_call_spread(S, K1, K2, T, r, sigma):
    """
    K1 = lower strike (buy)
    K2 = higher strike (sell)
    """
    buy_call = black_scholes(S, K1, T, r, sigma, "call")
    sell_call = black_scholes(S, K2, T, r, sigma, "call")
    
    net_debit = buy_call - sell_call
    max_profit = K2 - K1 - net_debit
    max_loss = net_debit
    
    return {
        "net_debit": net_debit,
        "max_profit": max_profit,
        "max_loss": max_loss,
        "risk_reward": max_profit / max_loss if max_loss > 0 else float('inf')
    }

# Example
result = bull_call_spread(S=180, K1=175, K2=185, T=30/365, r=0.05, sigma=0.25)
print(f"Cost: ${result['net_debit']:.2f}")
print(f"Max Profit: ${result['max_profit']:.2f}")
print(f"Max Loss: ${result['max_loss']:.2f}")
print(f"Risk/Reward: {result['risk_reward']:.2f}")

Bear Put Spread

Buy ATM put + Sell OTM put = Profits from downward moves

| Spread Type | Outlook | Net | Max Profit | Max Loss | |-------------|---------|-----|------------|----------| | Bull Call | Bullish | Debit | Strike width - cost | Cost paid | | Bear Put | Bearish | Debit | Strike width - cost | Cost paid | | Bear Call | Bearish | Credit | Credit received | Strike width - credit | | Bull Put | Bullish | Credit | Credit received | Strike width - credit |

Iron Condor

An iron condor combines a bear call spread and a bull put spread — profits from low volatility.

def iron_condor(S, K1, K2, K3, K4, T, r, sigma):
    """Four strikes: put spread + call spread"""
    # Put side
    buy_put = black_scholes(S, K1, T, r, sigma, "put")
    sell_put = black_scholes(S, K2, T, r, sigma, "put")
    
    # Call side
    sell_call = black_scholes(S, K3, T, r, sigma, "call")
    buy_call = black_scholes(S, K4, T, r, sigma, "call")
    
    net_credit = (sell_put + sell_call) - (buy_put + buy_call)
    max_loss = (K3 - K2) - net_credit
    
    return {
        "net_credit": net_credit,
        "max_profit": net_credit,
        "max_loss": max_loss,
        "breakdown": {
            "buy_put": K1,
            "sell_put": K2,
            "sell_call": K3,
            "buy_call": K4
        }
    }

Straddle and Strangle

Straddle

Buy both call and put at the same strike — profits from big moves in either direction.

| Strategy | Buy/Sell | When to Use | |----------|----------|-------------| | Long Straddle | Buy call + Buy put | Expected big move (earnings) | | Short Straddle | Sell call + Sell put | Expected low volatility |

def long_straddle(S, K, T, r, sigma):
    call = black_scholes(S, K, T, r, sigma, "call")
    put = black_scholes(S, K, T, r, sigma, "put")
    cost = call + put
    
    return {
        "cost": cost,
        "breakeven_up": K + cost,
        "breakeven_down": K - cost,
        "max_loss": cost
    }

Strangle

Buy OTM call + OTM put — cheaper than straddle but needs larger move.

| Feature | Straddle | Strangle | |---------|----------|----------| | Strikes | Same (ATM) | Different (OTM) | | Cost | Higher | Lower | | Breakeven | Closer | Wider | | Prob. of profit | Higher | Lower | | Best for | Earnings certainty | Big but uncertain move |

Butterfly Spread

Buy one ITM, sell two ATM, buy one OTM — profits from pin-point accuracy.

def butterfly(S, K_low, K_mid, K_high, T, r, sigma):
    buy_low = black_scholes(S, K_low, T, r, sigma, "call")
    sell_mid = black_scholes(S, K_mid, T, r, sigma, "call")
    sell_mid2 = black_scholes(S, K_mid, T, r, sigma, "call")
    buy_high = black_scholes(S, K_high, T, r, sigma, "call")
    
    net_debit = buy_low + buy_high - sell_mid - sell_mid2
    max_profit = K_mid - K_low - net_debit
    
    return {
        "net_debit": net_debit,
        "max_profit": max_profit,
        "max_loss": net_debit
    }

Summary

Combination strategies combine multiple options to create defined-risk, defined-reward positions. Vertical spreads limit risk, iron condors profit from range-bound markets, and straddles/strangles capitalize on volatility.

Key takeaways:

Vertical spreads: buy one, sell another — limited risk/reward |
Iron condor: four-leg range-bound strategy, profits from theta |
Straddle: ATM call + ATM put, profits from big moves |
Strangle: OTM call + OTM put, cheaper but needs wider move |
Butterfly: three strikes, profits from pin-point accuracy |
Credit spreads: receive premium upfront (bear call, bull put) |
Debit spreads: pay premium upfront (bull call, bear put) |
Always define max profit, max loss, and breakeven before entry |

What's Next: Trading System

The next chapter covers building a complete trading system.