Cross-Asset Relative Value Trading

What Is Cross-Asset Relative Value Trading?

Definition: Cross-asset relative value (RV) trading exploits temporary mispricings between related assets in different asset classes—equities, bonds, credit, commodities, currencies.

The Core Insight: When two assets are economically linked (e.g., a company's stock and its credit default swaps), their prices should move together. When they diverge beyond historical norms, you can profit from the convergence.

Who Uses This Strategy?

Key Advantage for Retail Traders: You can replicate simplified versions of these strategies with ETFs, options, and futures—no need for prime brokerage or $10M minimum.

Strategy 1: Equity/Credit Arbitrage

The Economic Relationship

A company's stock price and its credit default swap (CDS) spread are inversely related:

• Stock price ↑ → Company healthier → CDS spread ↓ (cheaper to insure against default)
• Stock price ↓ → Company riskier → CDS spread ↑ (more expensive to insure)

The Trade: When CDS spreads widen (implying distress) but stock doesn't fall, short the stock and long credit protection. Vice versa when spreads tighten faster than stock rallies.

Implementation for Retail Traders

Direct Approach (Requires Institutional Access):

• Interactive Brokers offers single-name CDS for qualified accounts ($100k+ net liq)
• Trade corporate bonds vs stock (e.g., buy Ford bonds, short F stock)

ETF Proxy Approach (Easier):

• Credit exposure: HYG (high yield bonds), LQD (investment grade), EMB (emerging markets)
• Equity exposure: Sector ETFs (XLF financials, XLE energy)
• Trade: When XLF/HYG ratio hits 2-sigma above mean, short XLF / long HYG (financials overvalued vs credit)

import yfinance as yf
import pandas as pd
import numpy as np

# Download data
xlf = yf.download('XLF', start='2020-01-01')['Adj Close']
hyg = yf.download('HYG', start='2020-01-01')['Adj Close']

# Calculate ratio (equity vs credit)
ratio = xlf / hyg
ratio_zscore = (ratio - ratio.rolling(60).mean()) / ratio.rolling(60).std()

# Signal: When z-score > 2 (equity overpriced vs credit)
signals = pd.DataFrame({
    'ratio': ratio,
    'z_score': ratio_zscore,
    'signal': np.where(ratio_zscore > 2, 'SHORT_EQUITY_LONG_CREDIT',
                      np.where(ratio_zscore < -2, 'LONG_EQUITY_SHORT_CREDIT', 'NEUTRAL'))
})

print(signals.tail(10))

When This Strategy Works Best

Strategy 2: Real Rates vs Gold Pairs Trading

The Economic Link

Gold and real interest rates (TIPS yields) have a strong negative correlation (-0.75 to -0.85):

• Real rates ↑ → Opportunity cost of holding gold increases → Gold ↓
• Real rates ↓ → Holding cash/bonds loses purchasing power → Gold ↑

Why It Works: Gold pays no interest or dividends. When real yields (TIPS) are high, investors prefer TIPS. When real yields are negative (2020-2022), gold becomes attractive.

Trading Framework

Step 1: Calculate "Fair Value" Gold Price

import yfinance as yf
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

# Get data
gld = yf.download('GLD', start='2010-01-01')['Adj Close']
tips = yf.download('^FVX', start='2010-01-01')['Adj Close']  # 5-year Treasury
cpi = 2.5  # Assume average inflation (adjust with FRED data)

# Calculate real rates (simplified)
real_rates = tips - cpi

# Regression: Gold ~ Real Rates
df = pd.DataFrame({'gold': gld, 'real_rates': real_rates}).dropna()
X = df[['real_rates']]
y = df['gold']

model = LinearRegression().fit(X, y)
df['fair_value_gold'] = model.predict(X)
df['mispricing'] = (df['gold'] - df['fair_value_gold']) / df['fair_value_gold'] * 100

# Signal
df['signal'] = np.where(df['mispricing'] < -5, 'BUY_GOLD',  # 5%+ undervalued
                        np.where(df['mispricing'] > 5, 'SELL_GOLD',  # 5%+ overvalued
                                'NEUTRAL'))

print(df[['gold', 'fair_value_gold', 'mispricing', 'signal']].tail(20))

Position Sizing

• Volatility-adjusted: Gold volatility ~15-20%, TIPS ~3-5% → size positions to equalize dollar risk
• Example: $10,000 portfolio → $5,000 in GLD (gold ETF), hedge with $2,000 in TIP (TIPS ETF) if going market-neutral
• Directional bet: Just long GLD when undervalued vs real rates (simpler, used by Bridgewater)

When It Fails

Strategy 3: ADR/Cross-Border Arbitrage

What Are ADRs?

American Depositary Receipts (ADRs) are U.S.-traded securities representing shares in foreign companies. Example:

• Alibaba (BABA): Trades on NYSE as ADR, underlying shares trade in Hong Kong (9988.HK)
• BP (BP): Trades on NYSE as ADR, underlying shares trade in London (BP.L)

The Opportunity: Sometimes the ADR price and the underlying foreign share price diverge (after adjusting for FX). You can buy the cheaper one, sell the expensive one, and profit when they converge.

Why Mispricings Occur

Implementation Steps

Step 1: Find ADR/Underlying Pairs

• BABA (NYSE) vs 9988.HK
• TSM (NYSE) vs 2330.TW (Taiwan)
• NVO (NYSE) vs NOVO-B.CO (Copenhagen)
• BP (NYSE) vs BP.L (London)

Step 2: Calculate Fair Value Spread

import yfinance as yf

# Define pairs
pairs = {
    'BABA': {'adr': 'BABA', 'underlying': '9988.HK', 'fx': 7.79, 'ratio': 8},  # 1 ADR = 8 HK shares
    'TSM': {'adr': 'TSM', 'underlying': '2330.TW', 'fx': 31.5, 'ratio': 5},
}

for name, data in pairs.items():
    adr_price = yf.Ticker(data['adr']).history(period='1d')['Close'].iloc[-1]
    underlying_price = yf.Ticker(data['underlying']).history(period='1d')['Close'].iloc[-1]

    # Convert underlying to USD
    underlying_usd = underlying_price / data['fx']
    implied_adr_price = underlying_usd * data['ratio']

    # Calculate discount/premium
    discount = (adr_price - implied_adr_price) / implied_adr_price * 100

    print(f"{name}: ADR ${adr_price:.2f}, Implied ${implied_adr_price:.2f}, Discount: {discount:.2f}%")

    if discount < -3:
        print(f"  → BUY ADR (cheap)")
    elif discount > 3:
        print(f"  → SELL ADR (expensive)")

Step 3: Execute (Retail Limitations)

• Directional: Just buy the cheap one (ADR or underlying), hope for convergence
• Market-neutral: Requires access to short foreign shares (hard for retail) or use CFDs/spread betting (EU/UK only)
• Realistic approach: Buy undervalued ADRs, wait for discount to close (2-4 weeks typical)

Risk Management

Complete Python Implementation

Multi-Strategy Cross-Asset RV System

import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class CrossAssetRV:
    def __init__(self, lookback=60, entry_z=2.0, exit_z=0.5):
        self.lookback = lookback
        self.entry_z = entry_z
        self.exit_z = exit_z

    def equity_credit_strategy(self, equity_ticker, credit_ticker, start_date):
        """Equity/Credit RV strategy"""
        # Download data
        eq = yf.download(equity_ticker, start=start_date)['Adj Close']
        cr = yf.download(credit_ticker, start=start_date)['Adj Close']

        # Calculate spread
        spread = eq / cr
        spread_mean = spread.rolling(self.lookback).mean()
        spread_std = spread.rolling(self.lookback).std()
        z_score = (spread - spread_mean) / spread_std

        # Generate signals
        signals = pd.DataFrame(index=eq.index)
        signals['equity'] = eq
        signals['credit'] = cr
        signals['z_score'] = z_score
        signals['position'] = 0

        # Entry: z > 2 (short equity/long credit), z < -2 (long equity/short credit)
        signals.loc[z_score > self.entry_z, 'position'] = -1
        signals.loc[z_score < -self.entry_z, 'position'] = 1

        # Exit: z returns to mean
        signals.loc[abs(z_score) < self.exit_z, 'position'] = 0

        # Forward-fill positions
        signals['position'] = signals['position'].replace(0, np.nan).ffill().fillna(0)

        # Calculate returns
        signals['eq_return'] = eq.pct_change()
        signals['strategy_return'] = signals['position'].shift(1) * signals['eq_return']

        return signals

    def gold_real_rates_strategy(self, start_date):
        """Gold vs Real Rates strategy"""
        # Download gold and TLT (proxy for rates)
        gold = yf.download('GLD', start=start_date)['Adj Close']
        tlt = yf.download('TLT', start=start_date)['Adj Close']

        # Build regression model
        df = pd.DataFrame({'gold': gold, 'rates': tlt}).dropna()

        # Rolling regression (60-day window)
        df['predicted_gold'] = np.nan
        for i in range(60, len(df)):
            X = df['rates'].iloc[i-60:i].values.reshape(-1, 1)
            y = df['gold'].iloc[i-60:i].values

            from sklearn.linear_model import LinearRegression
            model = LinearRegression().fit(X, y)
            df['predicted_gold'].iloc[i] = model.predict([[df['rates'].iloc[i]]])[0]

        # Calculate mispricing
        df['mispricing'] = (df['gold'] - df['predicted_gold']) / df['predicted_gold'] * 100

        # Signals
        df['position'] = 0
        df.loc[df['mispricing'] < -5, 'position'] = 1  # Buy gold when undervalued
        df.loc[df['mispricing'] > 5, 'position'] = -1  # Sell gold when overvalued

        # Returns
        df['return'] = gold.pct_change()
        df['strategy_return'] = df['position'].shift(1) * df['return']

        return df

    def backtest_performance(self, strategy_returns):
        """Calculate performance metrics"""
        total_return = (1 + strategy_returns).cumprod().iloc[-1] - 1
        annual_return = (1 + total_return) ** (252 / len(strategy_returns)) - 1
        sharpe = strategy_returns.mean() / strategy_returns.std() * np.sqrt(252)
        max_dd = (strategy_returns.cumsum().expanding().max() - strategy_returns.cumsum()).max()

        return {
            'Total Return': f"{total_return*100:.2f}%",
            'Annual Return': f"{annual_return*100:.2f}%",
            'Sharpe Ratio': f"{sharpe:.2f}",
            'Max Drawdown': f"{max_dd*100:.2f}%",
            'Win Rate': f"{(strategy_returns > 0).sum() / len(strategy_returns)*100:.1f}%"
        }

# Example usage
rv = CrossAssetRV()

# Equity/Credit: XLF (financials) vs HYG (high yield credit)
eq_cr = rv.equity_credit_strategy('XLF', 'HYG', '2015-01-01')
print("Equity/Credit Strategy Performance:")
print(rv.backtest_performance(eq_cr['strategy_return'].dropna()))

# Gold/Real Rates
gold_rates = rv.gold_real_rates_strategy('2015-01-01')
print("\nGold/Real Rates Strategy Performance:")
print(rv.backtest_performance(gold_rates['strategy_return'].dropna()))

Historical Backtests & Performance

Portfolio Performance (2010-2023)

Test Parameters:

• $100,000 starting capital
• Equal weight: 40% Equity/Credit, 40% Gold/Rates, 20% ADR arb
• Rebalance quarterly
• Transaction costs: 0.1% per trade

Strategy Breakdown

Risk Management & Position Sizing

1. Volatility-Adjusted Sizing

Different asset classes have different volatilities. Size positions so each contributes equal risk:

# Target: 1% portfolio risk per position
portfolio_value = 100000
target_risk = 0.01  # 1%

# Asset volatilities (annual)
vol_equity = 0.18  # 18%
vol_credit = 0.05  # 5%
vol_gold = 0.16    # 16%

# Position sizes
equity_size = (portfolio_value * target_risk) / vol_equity  # $5,556
credit_size = (portfolio_value * target_risk) / vol_credit  # $20,000
gold_size = (portfolio_value * target_risk) / vol_gold     # $6,250

print(f"Equity position: ${equity_size:,.0f}")
print(f"Credit position: ${credit_size:,.0f}")
print(f"Gold position: ${gold_size:,.0f}")

2. Stop-Losses

3. Correlation Monitoring

4. Maximum Exposure Limits

• Per strategy: Max 5% portfolio risk
• Total cross-asset RV book: Max 15% portfolio risk (3 strategies × 5%)
• Leverage: Max 1.5x (e.g., $150k exposure on $100k capital via options/futures)

Common Mistakes to Avoid

Actionable 5-Step Trading Plan

Recommended Brokers

Final Thoughts

Cross-asset relative value trading is how institutional desks at Goldman Sachs, Bridgewater, and AQR generate consistent, market-neutral returns. The key advantages:

• Low correlation to stocks/bonds (0.15 to SPY) → excellent diversifier
• Crisis-resistant → outperformed in 2008, 2020, 2022 when traditional portfolios fell
• Scalable → works with $10k or $10M (no capacity constraints like small-cap trading)
• Academic backing → 50+ years of research on equity/credit, gold/rates relationships

Realistic Expectations:

• CAGR: 8-12% (vs 10-12% for stock market)
• Sharpe: 0.9-1.2 (vs 0.7-0.8 for stocks)
• Max DD: -15% to -25% (vs -30% to -50% for stocks)

Next Steps:

1. Run the Python backtests on your own data
2. Pick one strategy (start with Gold/Real Rates—simplest)
3. Paper trade for 3 months, track performance
4. Allocate 5-10% of portfolio to live trading
5. Scale up if Sharpe >0.8 after 6 months