Combining strategies into one book

01A book of strategies

A book of strategies is a weighted sum of return streams. If stream i earns r_i,t in excess of cash and the book holds weight w_i in it, the book earns r_t = w₁r_1,t + … + w_n r_n,t, the weighted sum of the streams’ returns, and its variance is w′Σw, where Σ is the covariance matrix of the streams.

We use four public streams as stand-ins for strategies, from the Kenneth R. French Data Library, daily from 3 September 1927 to 31 August 2026: the US market in excess of T-bills, and the size, value and momentum factors, each a long-short paper portfolio that pays no costs of its own (see the caution at the end).^1,2,3 To do the same with your own strategies, build each one’s daily return over cash on a common calendar, with the same cost model; estimate risks on the period all of them share; shrink the covariance matrix towards a simple target, as Ledoit and Wolf propose, when streams are many and history short; and deflate every backtested Sharpe ratio for the search behind it, as Running backtests at scale describes, before it enters any of the calculations below.⁴

02Correlation depends on how it is measured

Momentum’s daily returns are positively autocorrelated, so the variance of its monthly returns is 45% higher than twenty-one independent days would give: its volatility from monthly returns, 15.2%, is well above the 12.9% that daily returns imply, and its Sharpe ratio is lower. Annualising a daily Sharpe ratio by the square root of time assumes independent returns, an assumption Lo showed can overstate the annual figure by a large margin.⁵ Correlations move further still:

Over the whole sample the market and the size factor are negatively correlated day by day and clearly positively correlated month by month (since 2000 the daily correlation has been positive, 0.16, though still well below the monthly). The explanation is old: small stocks trade less often, so their prices react to market news a day or more late, and daily returns miss the co-movement that arrives with a lag. Scholes and Williams and Dimson corrected betas for exactly this, and Lo and MacKinlay modelled it formally.^6,7,8 Value and momentum, on the other hand, stay negatively correlated at every frequency, the pattern Asness, Moskowitz and Pedersen found across markets and asset classes.⁹

When a decision flips

The frequency matters because it changes decisions. Adding a small amount of a stream B to a book A raises the book’s Sharpe ratio exactly when B’s Sharpe ratio exceeds its correlation with the book times the book’s own:

A stream with no return of its own clears that hurdle only if it is negatively correlated with the book; an uncorrelated stream with no return always dilutes, and a positively correlated one needs a Sharpe ratio of at least ρ times the book’s to pay its way. The market and the size factor show how a change of frequency can turn the verdict around.

03Diversification in the tails

Correlation summarises co-movement across all days, calm and violent alike, and the violent ones decide how much a book can lose. Longin and Solnik found that the correlation between international equity markets rises in bear markets but not in bull markets, and Ang and Chen found the same asymmetry between US stock portfolios and the market.^10,11 Measuring it takes care: correlation computed over volatile periods alone is biased upwards even when the true correlation never changes, as Forbes and Rigobon showed for “contagion”.¹² A simpler check is to count. On the days when one stream is in its worst 5%, how often is the other in its worst 5% too, against what a normal distribution with the same correlation would give?

Every pair shares its worst periods more often than its correlation implies: from about twice as often (market and size, monthly: 32% against 15%) to 11 times as often (value and momentum, monthly: 7 of 60 months, where a normal distribution gives 0.6, so the top of the range rests on few events). The market and momentum are negatively correlated month by month (−0.31), and a normal distribution would put both in their worst 5% in 0.9% of the market’s worst months; in the data it happened in 5 of 60. Part of this is common volatility: in turbulent periods every stream makes large moves of either sign, and on the market’s worst 5% of days momentum was in its best 5% on 26% of them. Dividing each stream by its own recent volatility first shrinks the excess but leaves a large part of it: for the market and momentum, daily, the share is then 27% against 8% for a normal distribution. A combination sized on correlation alone holds more tail risk than its covariance matrix admits, and stress tests should replay the joint history.

04Allocation rules

Five rules cover most practice, and four of them need no expected returns. Equal weight gives each stream the same capital and needs no estimates at all. Inverse volatility gives each the same risk if the streams were uncorrelated. Equal risk contribution, often called risk parity, chooses weights so that each stream contributes the same share of the book’s variance, where stream i’s share is w_i(Σw)_i / w′Σw; Maillard, Roncalli and Teïletche showed that its volatility always lies between the minimum-variance portfolio’s and equal weight’s.¹³ Choueifaty and Coignard’s maximum-diversification portfolio maximises the ratio of the weighted average of the streams’ volatilities to the portfolio’s.¹⁴ Mean-variance optimisation, the fifth, also uses expected returns.

def inverse_vol(cov: np.ndarray) -> np.ndarray:
    """Weights proportional to 1 / sigma_i: equal risk if the streams were uncorrelated."""
    w = 1.0 / np.sqrt(np.diag(cov))
    return w / w.sum()


def equal_risk(cov: np.ndarray, sweeps: int = 200, tol: float = 1e-12) -> np.ndarray:
    """Equal risk contribution (Maillard, Roncalli and Teiletche 2010) by cyclical coordinate
    descent on min 0.5 y'Sy - sum(ln y_i) / k, whose solution, normalised, equalises
    w_i (S w)_i. Each step solves one coordinate's quadratic exactly."""
    k = len(cov)
    y = inverse_vol(cov) / np.sqrt(inverse_vol(cov) @ cov @ inverse_vol(cov))
    for _ in range(sweeps):
        prev = y.copy()
        for i in range(k):
            a = cov[i] @ y - cov[i, i] * y[i]
            y[i] = (-a + np.sqrt(a * a + 4.0 * cov[i, i] / k)) / (2.0 * cov[i, i])
        if np.max(np.abs(y - prev)) < tol:
            break
    else:       # out of sweeps: strongly negative correlations can need more; say so if it matters
        w = y / y.sum()
        rc = w * (cov @ w) / (w @ cov @ w)
        if np.max(np.abs(rc - 1.0 / k)) > 1e-6:
            warnings.warn(f"equal_risk: risk contributions still unequal after {sweeps} sweeps")
    return y / y.sum()


def risk_contributions(w: np.ndarray, cov: np.ndarray) -> np.ndarray:
    """Each stream's share of the book's variance: w_i (S w)_i / w'Sw (they sum to one)."""
    return w * (cov @ w) / (w @ cov @ w)

The rules differ less in return than in where the risk sits. With equal capital and monthly rebalancing, the market, the most volatile stream, carries 54% of the book’s forecast risk on average. Inverse volatility brings its share down to 23%, and equal risk contribution to 25%. Measured on monthly returns, the three books’ Sharpe ratios are 0.74, 0.74 and 0.69. Equal risk did a little worse here, and the market’s share of the risk does not explain it: inverse volatility gave the market even less and matched equal weights, and in the out-of-sample test below equal risk did best. The gap is within the noise of a Sharpe ratio over this span. A rule that ignores expected returns is robust to their estimation error, and pays for it when one stream really is better.

Mean-variance, and why its inputs are the problem

Markowitz’s optimisation is optimal for known inputs and fragile for estimated ones.¹⁵ Michaud called mean-variance optimisers “estimation-error maximizers”, because they bet hardest on the streams whose returns are most overestimated, and DeMiguel, Garlappi and Uppal found that across fourteen models none beat equal weights out of sample consistently.^16,17 Our four streams show the mechanism. Re-estimating the weights each January from the previous ten years of monthly returns, from 1937, and scaling each year’s book to 10% expected volatility (so these figures are not comparable with the daily simulations above), the out-of-sample Sharpe ratios were close: 0.92 for mean-variance, 0.91 for equal weights, 0.88 for inverse volatility and 0.92 for equal risk, differences well inside the sampling error of a Sharpe ratio over this span. The weights were not close. Per unit of gross exposure, mean-variance swung between −0.35 and 0.68, shorting a stream in some years and loading on it in others, and changed its weights 6 times as much from year to year as equal risk did. Four streams and ten-year windows are an easy case; with more streams or shorter histories the estimation error grows and the balance tips further towards the simple rules.

05A volatility target on the book

A volatility target on the whole book, the portfolio version of the rule in Volatility targeting, scales every weight by the ratio of target to forecast book volatility, σ_target / √(w′Σ̂w), within a leverage cap. Moreira and Muir found that scaling factor portfolios by their recent variance raised their Sharpe ratios, though Cederburg and co-authors found the gain hard to capture out of sample across a wider set of strategies.^18,19 With equal weights, a 10% target and a cap of 3×, the monthly Sharpe ratio rises from 0.74 to 0.92, and with equal risk from 0.69 to 0.87. Most of that came before 1963: for equal risk, from 0.51 to 0.69 in 1927–1962, from 1.14 to 1.18 in 1963–1999 and from 0.58 to 0.63 since 2000. The gain over the whole sample is as large as the earliest era’s, larger than the later ones’, because part of it comes from holding risk steadier from one era to the next rather than from timing within an era.

It costs leverage. The targeted equal-risk book averaged 2.5× gross exposure and sat at its cap of 3× on 10% of days, which in a real account means margin, financing spreads and short-borrow fees that these paper returns do not pay. Gross exposure here counts each long-short factor at its net weight; in stocks, a weight of 0.7 in a factor is 0.7 long and 0.7 short, so the book’s gross stock positions averaged about 4.5× its capital, and the short side would pay borrow fees too. Charged a spread of 1% a year on the exposure above 1×, its monthly Sharpe ratio falls from 0.87 to 0.74, close to the untargeted 0.69, and that spread, charged on the net exposure, understates the cost.

It also delivers more risk than it aims for when risk is measured monthly. On daily returns the book’s volatility was 9.0%, a little under the target; on monthly returns it was 11.9%, 19% above the 10% intended. Part of the gap is the autocorrelation that separates daily from monthly correlations, which makes daily risk forecasts too low. Estimating the covariance from overlapping five-day returns, which captures the lagged co-movement, brings the monthly figure down to 11.4%, still above target, at the price of more turnover (3.7× against 2.9× a year) and a slightly lower Sharpe ratio (0.84). Longer windows do no better: with 10- and 21-day returns the monthly figure is 11.4% and 11.5%. The rest of the overshoot is not lagged co-movement that a longer window can capture, and the practical remedy is a lower target.

def simulate(r: pd.DataFrame, rule: str = "equal_risk", every: str = "M", span: int = 125,
             target: float | None = None, cap: float = 3.0, band: float = 0.10, cost: float = 0.0005,
             start: int = 252, periods=None, days: int = 1) -> dict:
    """The book, day by day. At each close: on a rebalance day the base weights reset to the
    rule's (from the covariance forecast up to that close); otherwise they drift. With a
    volatility target, the whole book is scaled by min(cap / gross, target / forecast book
    volatility), re-traded only when the scale moves more than `band` of itself. The weights
    decided at a close earn the next day's returns; costs are charged on everything traded."""
    x = r.to_numpy()
    t, k = x.shape
    per = np.asarray(sessions_per_year(r.index) if periods is None else np.full(t, periods), float)
    cov = ewma_cov(x, span, days=days)
    reb = rebalance_days(r.index, every)
    held = np.zeros(k)                 # weights earning today's return (decided at the last close)
    base = np.zeros(k)                 # the unscaled book the scale multiplies
    scale = 1.0
    ret, traded_s, gross_s = (np.zeros(t) for _ in range(3))
    w_hist, rc_hist = np.zeros((t, k)), np.zeros((t, k))
    for i in range(t):
        # 1. today's P&L on what was held from the last close
        traded = traded_s[i - 1] if i > 0 else 0.0
        pnl = held @ x[i]
        ret[i] = pnl - cost * traded
        # 2. drift: each stream's slice grows with its own return, the book with its total
        growth = 1.0 + pnl
        drifted = held * (1.0 + x[i]) / growth if growth > 0 else held
        if i < start - 1:
            continue
        # 3. decide at this close for tomorrow
        if not base.any() or reb[i]:
            base = RULES[rule](cov[i])
        else:
            base = drifted / scale if scale > 0 else base
        limit = cap / np.abs(base).sum()           # the leverage cap binds whatever the band says
        if target is not None:
            s_new = min(limit, target / np.sqrt(base @ cov[i] @ base * per[i]))
            if not held.any() or reb[i] or abs(s_new - scale) > band * scale:
                scale = s_new
            scale = min(scale, limit)
        else:
            scale = min(1.0, limit)
        new = scale * base
        traded_s[i] = np.abs(new - drifted).sum()
        held = new
        w_hist[i] = held
        gross_s[i] = np.abs(held).sum()
        rc_hist[i] = risk_contributions(held, cov[i])
    s = slice(start, t)
    return {"index": r.index[s], "ret": ret[s], "traded": traded_s[start - 1:t - 1],
            "gross": gross_s[start - 1:t - 1], "weights": w_hist[start - 1:t - 1], "risk": rc_hist[start - 1:t - 1]}

Judging a combination at equal risk

A book with more leverage earns more and loses more, so comparing raw returns or drawdowns rewards whichever book took more risk. The fair comparison scales each book, after the fact, to the same volatility, measured at the frequency the book will be held. At 10% monthly volatility, the equal-weight book without a target returned 7.2% a year in excess of T-bills with a worst drawdown of −46.2%; with the volatility target, 9.0% and −42.1%, before any financing spread. As run, the targeted book’s raw return was 11.0% a year, most of it bought with leverage. The same yardstick applies to any overlay, including one that cuts exposure after a drawdown: compare it with a plain scaling of the same book to the same volatility, never with the unscaled book.

06A portfolio laboratory

The lab runs the whole combination in the browser: choose the streams, the rule, the rebalancing calendar, a volatility target for the book and a leverage cap, and compare the result with equal weights at equal risk. Covariances are exponentially weighted with a span of 125 days and use only data up to each close; weights drift between rebalances; every unit traded costs the chosen amount. No financing spread is charged.

07Rebalancing, turnover and netting

Between rebalances weights drift with performance, and rebalancing buys back what fell and sells what rose. For these streams the calendar mattered little to the Sharpe ratio and a great deal to turnover: equal risk rebalanced monthly turned over 0.79 times its capital a year, quarterly 0.54 and annually 0.27, with monthly Sharpe ratios of 0.69, 0.70 and 0.69. The worst drawdown at equal risk moved more, from −46.2% with quarterly rebalancing to −56.0% with annual. Equal weights need less trading because only drift moves them. A no-trade band, as in Volatility targeting, is the usual refinement.

When strategies trade the same instruments, the book should trade the difference between the sum of their targets and what it holds, never each strategy’s own difference. The saving depends on how often the strategies disagree. In the example below, strategy A sells market exposure as strategy B buys it, and only the difference reaches the market.

def net_orders(current: dict, targets: dict[str, dict]) -> dict:
    """Netting: the book trades the difference between the SUM of the strategies' targets and
    what it holds, not each strategy's own difference. Returns both, per instrument."""
    # A strategy that holds something but has no targets any more is closing out: its target is zero.
    strategies = sorted(set(targets) | {k.split(":")[0] for k in current})
    names = sorted({n for t in targets.values() for n in t} | {k.split(":")[1] for k in current})
    total = {n: sum(t.get(n, 0.0) for t in targets.values()) for n in names}
    per_strategy = {s: {n: targets.get(s, {}).get(n, 0.0) - current.get(f"{s}:{n}", 0.0) for n in names} for s in strategies}
    gross_separate = sum(abs(v) for d in per_strategy.values() for v in d.values())
    held = {n: sum(current.get(f"{s}:{n}", 0.0) for s in strategies) for n in names}
    net = {n: total[n] - held[n] for n in names}
    return {"net": net, "per_strategy": per_strategy, "gross_separate": gross_separate,
            "gross_net": sum(abs(v) for v in net.values())}

Building strategies from components measures the same effect inside one strategy, where two components that trade the market rarely trade on the same day and netting saves little. In both places, charge costs on what the book trades and attribute them back to the strategies in proportion to what each asked to trade, so a strategy whose order was crossed internally still pays its share.

08A checklist

1. Measure volatility and correlation at the frequency the book is held, and check them at a lower one; distrust any decision that changes between the two.
2. Count joint worst days as well as measuring correlation, and stress the book on the joint history.
3. Prefer rules that need no expected returns (equal weight, inverse volatility, equal risk) unless expected returns are known far better than usual.
4. Apply a book-level volatility target with a leverage cap, and check the volatility it delivers on monthly returns and its Sharpe ratio after financing.
5. Judge every change at equal risk, and remember that leverage has costs a paper backtest does not pay.
6. Net orders across strategies before trading, and rebalance no more often than the risk requires.