Multi-Asset Structures

Level 3: Advanced | Module 3.1 | Time: 3 hours

🎯 Learning Objectives

By the end of this module, you will:

Master basket options and multi-asset structures
Understand correlation impact on pricing
Learn best-of and worst-of mechanics
Model dependency using copulas
Design rainbow and spread options

What Are Multi-Asset Structures?

Financial products whose payoff depends on the performance of multiple underlying assets simultaneously.

The Single-Asset Limitation

Traditional Option:
Payoff = f(Bitcoin)
Depends only on Bitcoin price

Multi-Asset Structure:
Payoff = f(Bitcoin, Ethereum, Solana)
Depends on multiple asset prices AND their relationship

Key Insight: Correlation between assets dramatically affects pricing and risk.

Why Multi-Asset Structures?

1. Diversification

Reduce single-asset risk

Problem: 100% Bitcoin exposure = high risk

Solution: Basket of BTC + ETH + SOL
- Reduces volatility
- Smooths returns
- Lowers correlation to any single asset

2. Customization

Tailor exposure precisely

Investor wants:
- 50% Bitcoin exposure
- 30% Ethereum exposure
- 20% Solana exposure

Single basket option achieves this exactly

3. Correlation Trading

Profit from relationship changes

Observation:
BTC and ETH normally 85% correlated
Currently 60% correlated (low!)

Trade: Bet on correlation mean-reverting
Structure: Spread option on BTC-ETH

4. Risk Management

Hedge complex portfolios

Portfolio:
- Long BTC mining stocks
- Long ETH validators
- Short altcoins

Hedge with worst-of put on BTC/ETH
Protects if either crashes

Correlation Fundamentals

What is Correlation?

Measure of how two assets move together

Correlation (ρ) ranges from -1 to +1:

ρ = +1.0: Perfect positive (move together exactly)
ρ = +0.5: Moderate positive (often move together)
ρ = 0.0: No relationship (independent)
ρ = -0.5: Moderate negative (often move opposite)
ρ = -1.0: Perfect negative (exact mirror)

Crypto Correlation Examples

Typical Correlations (2023-2024):

Bitcoin vs Ethereum: +0.85 (very high)
Bitcoin vs Altcoins: +0.70 (high)
Bitcoin vs Stocks: +0.45 (moderate)
Bitcoin vs Bonds: -0.10 (slightly negative)
Bitcoin vs Gold: +0.25 (low positive)
Bitcoin vs USD: -0.60 (negative)

During crashes: All correlations → +1.0 (disaster!)

Correlation Formula

Correlation(X, Y) = Cov(X, Y) / (σ_X × σ_Y)

Where:
Cov(X, Y) = E[(X - μ_X)(Y - μ_Y)]
σ_X = Standard deviation of X
σ_Y = Standard deviation of Y

Example:
Bitcoin: σ = 80%
Ethereum: σ = 90%
Covariance: 0.0648

ρ = 0.0648 / (0.80 × 0.90) = 0.0648 / 0.72 = 0.90

BTC and ETH have 90% correlation

Basket Options

Options on a weighted portfolio of multiple assets

Simple Basket Call

Basket: 50% Bitcoin + 50% Ethereum

Current Prices:
BTC: $50,000
ETH: $3,000

Basket Value = 0.5×$50,000 + 0.5×$3,000 = $26,500

Basket Call Option:
Strike: $30,000
Expiration: 90 days

Payoff = max(Basket_T - $30,000, 0)

Pricing Impact of Correlation

THIS IS CRITICAL: Correlation significantly affects basket option prices.

Scenario A: High Correlation (ρ = 0.90)
BTC and ETH move together
Basket volatility: ~82%
Basket call value: $4,500

Scenario B: Low Correlation (ρ = 0.30)
BTC and ETH move independently
Basket volatility: ~58% (diversification!)
Basket call value: $2,800

Same strikes, same individual vols
But 60% difference in price due to correlation!

Why Lower Correlation = Lower Price

High Correlation (ρ = 0.90):
Day 1: BTC +5%, ETH +4% → Basket +4.5%
Day 2: BTC -3%, ETH -3% → Basket -3.0%
Day 3: BTC +7%, ETH +6% → Basket +6.5%

Basket volatility ≈ Individual volatility (amplified moves)

Low Correlation (ρ = 0.30):
Day 1: BTC +5%, ETH -2% → Basket +1.5%
Day 2: BTC -3%, ETH +4% → Basket +0.5%
Day 3: BTC +7%, ETH -1% → Basket +3.0%

Basket volatility < Individual volatility (diversification effect)

Formula for Basket Volatility:

σ_basket = √[w₁²σ₁² + w₂²σ₂² + 2×w₁×w₂×ρ×σ₁×σ₂]

Example:
w₁ = w₂ = 0.5 (equal weights)
σ₁ = 80% (BTC), σ₂ = 90% (ETH)
ρ = 0.85

σ_basket = √[0.5²×0.80² + 0.5²×0.90² + 2×0.5×0.5×0.85×0.80×0.90]
         = √[0.16 + 0.2025 + 0.306]
         = √0.6685
         = 81.8%

High correlation → basket vol ≈ average individual vol

Best-Of Options

Payoff based on the BEST performing asset

Best-Of Call Structure

Best-of Call on BTC and ETH:

Assets:
- Bitcoin: $50,000
- Ethereum: $3,000

Strike: $0 (ATM for both in % terms)
Expiration: 1 year

Payoff = max(BTC_T/BTC_0, ETH_T/ETH_0) - 1

Example at expiration:
BTC: $50,000 → $60,000 (+20%)
ETH: $3,000 → $4,500 (+50%)

Payoff = max(1.20, 1.50) - 1 = 0.50 = 50%

You get the BETTER performer (ETH in this case)

Why Best-Of is Expensive

You win if EITHER asset performs well

Probability Analysis:

Single Asset Call (BTC only):
P(BTC > Strike) = 50%

Best-Of Call (BTC or ETH):
P(BTC > Strike OR ETH > Strike) = ?

If uncorrelated (ρ = 0):
P = 1 - P(both fail) = 1 - (0.5 × 0.5) = 75%

If perfect correlation (ρ = 1):
P = 50% (same as single asset)

Best-of is MORE valuable with LOWER correlation!

Pricing Example

Setup:
BTC: $50,000, σ = 80%
ETH: $3,000, σ = 90%
Strike: ATM for both
Time: 1 year
Correlation: 0.70

Best-of Call Value: $18,500 (expensive!)

Compare to:
BTC call alone: $12,000
ETH call alone: $1,100 (scaled to same notional)

Best-of < BTC + ETH (no free lunch)
But > max(BTC, ETH) (optionality value)

Worst-Of Options

Payoff based on the WORST performing asset

Worst-Of Put Structure

Worst-of Put on BTC and ETH:

Strike: Current prices (ATM)
Expiration: 1 year

Payoff = max(Strike - min(BTC_T, ETH_T), 0)

Example at expiration:
BTC: $50,000 → $45,000 (-10%)
ETH: $3,000 → $2,400 (-20%)

Worst performer: ETH (-20%)
Payoff based on ETH: max($3,000 - $2,400, 0) = $600

You're exposed to the WORST performer

Common Use Case: Principal Protection with Enhanced Yield

Structure: Worst-of Principal Protected Note

Notional: $100,000
Sell worst-of put on BTC/ETH
Collect premium: $8,000

Use premium to:
1. Buy zero-coupon bond: $95,238
2. Buy calls on basket: $4,762

Result:
- Principal protected if both assets stay above strikes
- Enhanced yield from worst-of put premium
- Upside participation

Risk:
- If either asset crashes, you take that loss
- But only if it's the worst performer

Why Worst-Of is Cheaper (to Buy) / Pays More (to Sell)

You lose if EITHER asset performs poorly

Worst-of Put Pricing:

Single Asset Put (BTC):
Premium: $4,000

Worst-of Put (BTC or ETH):
Premium: $6,500 (62% more expensive!)

Why? Higher probability of payout
P(BTC falls OR ETH falls) > P(BTC falls alone)

Rainbow Options

Payoffs depend on RANKING of asset performances

Rainbow Call Example

Rainbow Call on 3 assets:

Assets:
- Bitcoin (BTC)
- Ethereum (ETH)
- Solana (SOL)

Structure: "Best 2 out of 3"
Payoff = (1st performer return + 2nd performer return) / 2

Example:
BTC: +30%
ETH: +50%
SOL: -10%

Ranking: 1st ETH (+50%), 2nd BTC (+30%), 3rd SOL (-10%)
Payoff = (50% + 30%) / 2 = 40%

You get average of top 2 performers
Diversified upside, protected from worst

Rainbow Put (Protective)

"Worst 2 out of 3" Put

Protects against two assets declining
More expensive than single put
Cheaper than worst-of put
Customizable risk/reward

Spread Options

Payoff based on the DIFFERENCE between two assets

Long-Short Spread

BTC-ETH Spread Call:

Payoff = max(BTC_T - ETH_T - Strike, 0)

Current:
BTC: $50,000
ETH: $3,000 (scaled to same units: $3,000 × 16.67 = $50,000)
Spread: $0

Strike: $5,000
Expiration: 90 days

At expiration:
BTC: $55,000
ETH: $3,200 (scaled: $53,333)
Spread: $55,000 - $53,333 = $1,667

Payoff: max($1,667 - $5,000, 0) = $0 (OTM)

If BTC outperforms ETH by >$5,000 → Profit

Use Case: Pair Trading

Thesis: BTC will outperform ETH

Instead of:
- Buy BTC, Short ETH (directional risk)

Use spread option:
- Buy BTC-ETH spread call
- Defined risk (premium paid)
- Pure relative value play
- Correlation matters a lot!

Correlation Breakdown Risk

When correlations change unexpectedly

Historical Example: 2020 COVID Crash

Pre-Crisis Correlations (Feb 2020):
BTC vs Stocks: +0.30 (low)
BTC marketed as "uncorrelated safe haven"

During Crisis (Mar 2020):
BTC vs Stocks: +0.90 (very high!)
Everything crashed together

Impact on Multi-Asset Structures:
Diversification failed exactly when needed
Worst-of options all triggered
Best-of options couldn't save you

Stress Testing for Correlation = 1

ALWAYS test what happens if all assets move together

Worst-of PPN Example:

Normal Times (ρ = 0.70):
BTC and ETH independent enough
Probability both fall 30%: Low (~15%)
Structure seems safe

Crisis (ρ = 1.0):
BTC and ETH move exactly together
Probability both fall 30%: Same as single asset (~25%)
Structure much riskier!

Lesson: Stress test with ρ = 1.0 scenario

Copula Models

Advanced technique for modeling dependency beyond linear correlation

Why Copulas?

Linear correlation doesn’t capture tail dependency

Problem with Correlation:

BTC and ETH normally 70% correlated

But:
- In small moves: 60% correlated
- In medium moves: 70% correlated
- In CRASH: 95% correlated (tail dependency!)

Simple correlation misses this
Copulas model it correctly

Types of Copulas

1. Gaussian Copula (Standard)

Assumes normal distribution of joint moves
Most common in practice
Underestimates tail risk

2. t-Copula (Fat Tails)

Allows for tail dependency
Better models extreme events
More realistic for crypto

3. Clayton Copula (Lower Tail)

Models dependency in crashes
Higher correlation when both assets fall
Good for worst-of puts

4. Gumbel Copula (Upper Tail)

Models dependency in rallies
Higher correlation when both assets rise
Good for best-of calls

Practical Application

Pricing Worst-of Put on BTC/ETH:

Method 1: Simple Correlation
ρ = 0.70
Price: $6,000

Method 2: t-Copula (tail dependency)
Normal ρ = 0.70
Crash ρ = 0.90
Price: $7,500 (25% more expensive!)

The t-Copula captures realistic crash behavior
Simple correlation underprices tail risk

Practical Multi-Asset Strategies

Strategy 1: Diversified Income (Worst-Of Selling)

Structure: Sell worst-of puts on 5 major cryptos
- BTC, ETH, BNB, SOL, ADA
- All 10% OTM
- 30-day expiration

Premium Collected: $10,000 (on $100k notional)

Outcomes:

Best Case: All assets stay above strikes
Keep: $10,000 (10% monthly!)

Likely Case: One underperforms slightly (>-10% but < -20%)
Keep: $10,000 minus small loss
Net: Still positive

Worst Case: Major crash, all fall >10%
Worst performer (say ADA) falls 30%
Loss: $30,000
Net: -$20,000 (after $10k premium)

Risk: Tail events hurt badly
Reward: High income in normal times

Strategy 2: Best-Of Growth (Leveraged Upside)

Structure: Buy best-of call on emerging L1s
- Solana, Avalanche, Polygon
- 1-year ATM

Cost: $15,000
Notional: $100,000 each asset

Outcome:

Best Case: One of them moons (+500%)
Your call: Worth ~$500,000 (on best performer)
Profit: $485,000

Likely Case: Best performer +80%
Your call: Worth ~$80,000
Profit: $65,000

Worst Case: All decline
Your call: Worthless
Loss: $15,000 (limited!)

This is a venture capital-style bet
High risk, asymmetric upside

Strategy 3: Market-Neutral Spread

Structure: BTC-ETH spread collar

View: BTC will outperform ETH, but both may be volatile

Trade:
1. Buy BTC-ETH spread call (profit if BTC > ETH)
2. Sell BTC-ETH spread put (risk if ETH > BTC)
3. Net cost: ~$0 (zero-cost collar)

Payoff:
If BTC outperforms: Spread call profits
If ETH outperforms: Spread put losses
Pure relative value, direction-neutral

Pricing Multi-Asset Options

Monte Carlo Approach (Required)

No analytical solution for most multi-asset options

import numpy as np
 
def price_basket_call(S1, S2, K, T, r, sigma1, sigma2, rho, N=10000):
    """
    Price a basket call option using Monte Carlo
 
    Basket = 0.5*S1 + 0.5*S2
    """
    dt = T
 
    # Cholesky decomposition for correlation
    L = np.array([[1, 0],
                  [rho, np.sqrt(1 - rho**2)]])
 
    payoffs = []
 
    for i in range(N):
        # Generate correlated random numbers
        Z = np.random.standard_normal(2)
        Z_corr = L @ Z
 
        # Simulate final prices
        S1_T = S1 * np.exp((r - 0.5*sigma1**2)*T + sigma1*np.sqrt(T)*Z_corr[0])
        S2_T = S2 * np.exp((r - 0.5*sigma2**2)*T + sigma2*np.sqrt(T)*Z_corr[1])
 
        # Basket value
        basket_T = 0.5*S1_T + 0.5*S2_T
 
        # Payoff
        payoff = max(basket_T - K, 0)
        payoffs.append(payoff)
 
    # Discount average payoff
    option_price = np.exp(-r*T) * np.mean(payoffs)
 
    return option_price
 
# Example
price = price_basket_call(
    S1=50000,    # BTC
    S2=3000,     # ETH
    K=27000,     # Basket strike
    T=0.25,
    r=0.04,
    sigma1=0.80,
    sigma2=0.90,
    rho=0.85,
    N=10000
)
 
print(f"Basket Call Price: ${price:,.2f}")

Common Mistakes

Mistake 1: Ignoring Correlation

❌ Wrong:
Price basket as sum of individual options
Ignore correlation entirely

Result: Massive mispricing

✅ Right:
Explicitly model correlation
Use Cholesky decomposition for simulation
Stress test correlation assumptions

Mistake 2: Using Historical Correlation for Future

❌ Wrong:
Past year BTC-ETH correlation: 0.70
Assume next year: 0.70

Reality: Correlation changes dramatically
Crisis: 0.90+
Bull market: 0.60

✅ Right:
Use implied correlation (from market prices)
Or stress test range (0.50 to 0.95)
Never assume constant correlation

Mistake 3: Underestimating Tail Dependency

❌ Wrong:
Use Gaussian copula (standard)
Underestimates crash correlation

Result: Worst-of puts underpriced

✅ Right:
Use t-copula or Clayton copula
Model higher correlation in tail events
Conservative assumptions

Mistake 4: Forgetting Rebalancing Needs

❌ Wrong:
Set basket weights at inception
Never rebalance

Problem: After 1 month, BTC +20%, ETH -10%
Weights now 60/40 instead of 50/50

✅ Right:
Rebalance periodically
Or use "quanto" structure (fixed notional each asset)
Account for rebalancing costs

Practice Exercise: Price a Worst-Of Put

Given

Worst-of Put on Bitcoin and Ethereum

BTC: $50,000, σ = 80%
ETH: $3,000, σ = 90%
Strike: ATM for both
Time: 90 days
Risk-free rate: 4%
Correlation: 0.75

Use Monte Carlo (10,000 paths)

Click for solution code

def price_worst_of_put(S1, S2, K1, K2, T, r, sigma1, sigma2, rho, N=10000):
    dt = T
 
    # Cholesky for correlation
    L = np.array([[1, 0],
                  [rho, np.sqrt(1 - rho**2)]])
 
    payoffs = []
 
    for i in range(N):
        Z = np.random.standard_normal(2)
        Z_corr = L @ Z
 
        # Final prices
        S1_T = S1 * np.exp((r - 0.5*sigma1**2)*T + sigma1*np.sqrt(T)*Z_corr[0])
        S2_T = S2 * np.exp((r - 0.5*sigma2**2)*T + sigma2*np.sqrt(T)*Z_corr[1])
 
        # Returns
        ret1 = (S1_T - K1) / K1
        ret2 = (S2_T - K2) / K2
 
        # Worst performer
        worst_return = min(ret1, ret2)
 
        # Payoff (on notional, say $100k)
        notional = 100000
        if worst_return < 0:
            payoff = -worst_return * notional
        else:
            payoff = 0
 
        payoffs.append(payoff)
 
    option_price = np.exp(-r*T) * np.mean(payoffs)
    return option_price
 
price = price_worst_of_put(
    S1=50000, S2=3000,
    K1=50000, K2=3000,
    T=90/365, r=0.04,
    sigma1=0.80, sigma2=0.90,
    rho=0.75, N=10000
)
 
print(f"Worst-of Put: ${price:,.2f}")
 
# Expected: ~$6,000-$7,500
# Higher correlation → Lower price (diversification fails)

Key Takeaways

1. Multi-asset structures depend critically on correlation

Lower correlation = more diversification = cheaper baskets
Higher correlation = less diversification = expensive baskets
Correlation ≠ constant (stress test!)

2. Best-of options are expensive, worst-of are risky

Best-of: Pay premium for optionality (cherry-pick winner)
Worst-of: Collect premium for tail risk (exposed to weakest link)

3. Correlation breaks down in crises

All assets move together in crashes (ρ → 1.0)
Diversification fails when you need it most
Always stress test worst case

4. Monte Carlo required for pricing

No closed-form solutions for most structures
Must simulate correlated paths (Cholesky)
Use appropriate copulas for tail risk

5. Applications span risk management to speculation

Diversified hedging (rainbow puts)
Enhanced income (worst-of selling)
Leveraged bets (best-of calls)
Pair trading (spread options)

What’s Next?

You’ve mastered multi-asset structures! You now understand:

✅ Basket options and correlation impact
✅ Best-of and worst-of mechanics
✅ Rainbow and spread options
✅ Copula models for dependency
✅ Practical multi-asset strategies

Ready for path-dependent exotics?

Continue to: Barrier Options & Exotics →

Learn knock-in/knock-out barriers, Asian options, lookback options, and more complex structures.

Additional Resources

Code Examples:

Full Python implementations on GitHub
Correlation matrix calculations
Multi-asset Monte Carlo pricer
Copula modeling examples

Further Reading:

Correlation trading strategies
Multi-asset risk management
Quanto options (currency hedging)
Dispersion trading

Next Module: Barrier Options & Exotics →

Related Topics:

Monte Carlo - Simulation foundation
Volatility - Vol surface across assets
Portfolio Risk Management - Managing multi-asset portfolios