Rebalancing Strategies

Portfolio rebalancing methodologies — when, how, and how much to trade.

When to Activate

• User needs to decide how often and by what rules to rebalance a portfolio
• Comparing calendar vs threshold vs tactical rebalancing
• Minimizing rebalancing costs (transaction costs, taxes, market impact)
• Implementing tax-aware rebalancing with tax-loss harvesting
• Analyzing the rebalancing premium and drift tolerance

Core Concepts

Why Rebalance?

Portfolios drift from target weights as assets generate different returns. Without rebalancing:

• Risk profile changes — a 60/40 portfolio can drift to 75/25 after a bull market
• Factor exposures shift unintentionally
• Risk parity portfolios lose their equal-risk-contribution property

The rebalancing premium is a small but real return benefit from systematically selling winners and buying losers in a mean-reverting environment. Estimated at 0.15-0.50% annually for diversified multi-asset portfolios (Willenbrock, 2011).

Rebalancing Approaches

The Cost-Drift Tradeoff

Every rebalance incurs costs:

• Explicit costs: commissions, bid-ask spreads
• Market impact: price movement caused by trading
• Tax costs: realized capital gains (for taxable accounts)
• Opportunity cost: time and attention

But drift also has costs:

• Risk budget violation: portfolio risk exceeds target
• Tracking error: deviation from policy benchmark
• Regulatory/mandate breaches: violating IPS constraints

The optimal strategy minimizes total cost = trading costs + drift penalty.

Methodology

Step 1: Measure Drift

import numpy as np
import pandas as pd

def compute_drift(current_weights, target_weights):
    """
    Multiple drift metrics:
    - Max absolute drift: max single-asset deviation
    - Sum absolute drift: total deviation (related to turnover needed)
    - Weighted drift: risk-adjusted deviation using volatility
    """
    diff = current_weights - target_weights
    metrics = {
        'max_drift': np.abs(diff).max(),
        'sum_drift': np.abs(diff).sum(),
        'rms_drift': np.sqrt((diff ** 2).mean()),
        'largest_overweight': diff.idxmax(),
        'largest_underweight': diff.idxmin()
    }
    return metrics

def drift_over_time(prices, target_weights, start_date):
    """Track portfolio drift without rebalancing."""
    returns = prices.pct_change()
    weights = target_weights.copy()

    drift_history = []
    for date, ret in returns.iterrows():
        # Update weights based on returns
        portfolio_value = (weights * (1 + ret)).sum()
        weights = weights * (1 + ret) / portfolio_value
        drift_history.append({
            'date': date,
            **compute_drift(weights, target_weights)
        })

    return pd.DataFrame(drift_history)

Step 2: Calendar Rebalancing

def calendar_rebalance(prices, target_weights, frequency='quarterly'):
    """
    Rebalance to target weights on fixed dates.
    frequency: 'monthly', 'quarterly', 'semi-annual', 'annual'
    """
    returns = prices.pct_change().dropna()
    rebal_dates = get_rebalance_dates(returns.index, frequency)

    weights = target_weights.copy()
    portfolio_returns = []
    turnover_history = []

    for date, ret in returns.iterrows():
        # Daily portfolio return
        port_ret = (weights * ret).sum()
        portfolio_returns.append(port_ret)

        # Update weights
        weights = weights * (1 + ret) / (1 + port_ret)

        # Rebalance on scheduled dates
        if date in rebal_dates:
            turnover = np.abs(weights - target_weights).sum() / 2  # one-way
            turnover_history.append({'date': date, 'turnover': turnover})
            weights = target_weights.copy()

    return pd.Series(portfolio_returns, index=returns.index), turnover_history

Step 3: Threshold Rebalancing

def threshold_rebalance(prices, target_weights, threshold=0.05,
                        partial=False, rebal_to='target'):
    """
    Rebalance when any asset drifts beyond threshold.

    partial: if True, only rebalance back to threshold edge (not target)
    rebal_to: 'target' (full) or 'edge' (partial, reduces trading)
    """
    returns = prices.pct_change().dropna()
    weights = target_weights.copy()
    portfolio_returns = []
    rebal_events = []

    for date, ret in returns.iterrows():
        port_ret = (weights * ret).sum()
        portfolio_returns.append(port_ret)
        weights = weights * (1 + ret) / (1 + port_ret)

        # Check if any asset breaches threshold
        drift = np.abs(weights - target_weights)
        if drift.max() > threshold:
            if rebal_to == 'target':
                new_weights = target_weights.copy()
            elif rebal_to == 'edge':
                # Partial rebalance: bring back to threshold edge
                new_weights = weights.copy()
                for asset in weights.index:
                    if weights[asset] > target_weights[asset] + threshold:
                        new_weights[asset] = target_weights[asset] + threshold * 0.5
                    elif weights[asset] < target_weights[asset] - threshold:
                        new_weights[asset] = target_weights[asset] - threshold * 0.5
                new_weights = new_weights / new_weights.sum()

            turnover = np.abs(weights - new_weights).sum() / 2
            rebal_events.append({'date': date, 'turnover': turnover})
            weights = new_weights

    return pd.Series(portfolio_returns, index=returns.index), rebal_events

Step 4: Optimal Rebalancing (Cost Minimization)

import cvxpy as cp

def optimal_rebalance(current_weights, target_weights, sigma,
                      tcost_bps=10, risk_aversion=1.0, tax_rates=None):
    """
    Optimal rebalance minimizing: drift_penalty + trading_cost + tax_cost.
    """
    n = len(current_weights)
    w = cp.Variable(n)
    trades = w - current_weights

    # Drift penalty: tracking error from target
    drift_penalty = risk_aversion * cp.quad_form(w - target_weights, sigma)

    # Transaction cost: proportional to trade size
    tcost = tcost_bps / 10000 * cp.norm(trades, 1)

    # Tax cost (if applicable)
    if tax_rates is not None:
        # Simplified: tax cost proportional to sales of appreciated positions
        tax_cost = sum(
            tax_rates[i] * cp.pos(-trades[i]) * max(0, unrealized_gain[i])
            for i in range(n)
        )
    else:
        tax_cost = 0

    objective = cp.Minimize(drift_penalty + tcost + tax_cost)
    constraints = [cp.sum(w) == 1, w >= 0]

    prob = cp.Problem(objective, constraints)
    prob.solve()
    return w.value

Step 5: Tax-Aware Rebalancing

def tax_loss_harvest(current_weights, cost_basis, current_prices,
                     target_weights, wash_sale_window=30):
    """
    Rebalance with tax-loss harvesting:
    1. Identify positions with unrealized losses
    2. Sell losers to realize losses (tax benefit)
    3. Replace with correlated substitute (avoid wash sale)
    4. Rebalance remaining positions toward target
    """
    unrealized_gains = (current_prices - cost_basis) / cost_basis

    harvest_candidates = []
    for i, gain in enumerate(unrealized_gains):
        if gain < -0.05:  # at least 5% loss to justify trading
            harvest_candidates.append({
                'asset': i,
                'loss': gain * current_weights[i],
                'substitute': find_substitute(i)  # correlated but not "substantially identical"
            })

    # Prioritize by tax benefit (loss size * tax rate)
    harvest_candidates.sort(key=lambda x: x['loss'])

    return harvest_candidates

def find_substitute(asset_idx):
    """
    Find a substitute asset that:
    1. Has high correlation (>0.95) with original
    2. Is not "substantially identical" (IRS wash sale rule)
    3. Maintains portfolio factor exposure
    Example: swap one S&P 500 ETF for another (SPY -> IVV)
    """
    pass

Examples

Comparing Rebalancing Frequencies

# Backtest calendar rebalancing at different frequencies
for freq in ['monthly', 'quarterly', 'annual']:
    returns, turnover = calendar_rebalance(prices, target_weights, freq)
    ann_return = (1 + returns).prod() ** (252/len(returns)) - 1
    ann_turnover = sum(t['turnover'] for t in turnover) / (len(returns)/252)
    net_return = ann_return - ann_turnover * 0.001  # 10bps round-trip cost
    print(f"{freq}: return={ann_return:.2%}, turnover={ann_turnover:.1%}, "
          f"net={net_return:.2%}")

Typical finding: quarterly rebalancing captures most of the rebalancing premium with reasonable turnover. Monthly adds cost, annual allows excessive drift.

Setting Threshold Bands

Rules of thumb for threshold width:

• Tight (2-3%): for institutional mandates with strict tracking error limits
• Medium (5%): good default for multi-asset portfolios
• Wide (10%+): for taxable accounts where trading cost is high
• Asymmetric: wider bands for illiquid assets, tighter for liquid ones

# Asset-specific thresholds based on volatility and liquidity
thresholds = {
    'US_Equity': 0.03,      # liquid, moderate vol
    'Intl_Equity': 0.04,    # slightly less liquid
    'EM_Equity': 0.05,      # less liquid, higher vol
    'US_Bonds': 0.02,       # low vol, drift slowly
    'Real_Estate': 0.07,    # illiquid, wider band
}

Quality Gate

• Rebalancing strategy matches account type (taxable vs tax-exempt has very different optimal rules)
• Transaction costs included in all rebalancing comparisons
• Threshold bands set with reference to asset volatility and liquidity
• Tax-loss harvesting avoids wash sale violations (30-day rule)
• Partial rebalancing considered for high-cost environments
• Drift monitoring includes risk-adjusted metrics, not just weight deviation
• Cash flows used as rebalancing opportunities (deposit into underweight assets)
• Backtest covers multiple market regimes (trending markets penalize rebalancing)
• Rebalancing premium estimate is realistic (0.15-0.50%, not inflated)
• Operational feasibility verified — daily threshold monitoring requires infrastructure