For years, the hedge fund industry has wrapped its operations in an almost mystical veil of secrecy. Cryptic formulas, servers sitting inches from exchange matching engines, and PhDs in theoretical physics charging 2% management and 20% performance fees for what they swear is pure magic: the elusive alpha.

A few months ago, a remarkable manuscript landed on my desk: 151 Trading Strategies, written by Zura Kakushadze (theoretical physicist and former Wall Street quant director) and Juan Andrés Serur (finance professor and quantitative strategist). The document is a full-blown encyclopedia: over 360 pages and 550 mathematical formulas detailing, in plain language and algorithmic formulas, the 151 most widely used trading strategies across modern markets. It covers equities, options, ETFs, fixed income, foreign exchange, commodities, structured credit, weather derivatives, and crypto assets.

The backstory behind the paper is worth noting. Originally intended as an academic book with Palgrave Macmillan, the authors ran into total disinterest from the publisher's editorial staff. The publisher expected them to design their own cover, introduced over a hundred typesetting blunders into the LaTeX equations, and leaked confidential appendices into public previews. Fed up with the usual treatment from academic publishers, Kakushadze and Serur cancelled the publishing contract and posted the entire PDF on SSRN with a clean closing statement: Innovate. Disrupt. Spread the knowledge.

As finance professor Jim Kyung-Soo Liew put it in the opening remarks: by giving away the exact recipe for the secret sauce, they proved that what many funds sell as exclusive alpha is nothing more than packaged systematic beta. The mystery is gone.

The Four Pillars Behind Any Strategy

When confronted with 550 differential equations, covariance matrices, and quadratic optimizations, getting intimidated is normal. Yet, once you strip away the mathematical armor and examine the economic reality underneath, nearly every strategy in the document runs on four fundamental drivers:

  1. Momentum: Buying what has rallied hard and selling (or shorting) what has plunged. Financial markets take weeks or months to fully absorb shifting fundamentals and earnings surprises, creating persistent medium-term trends.
  2. Mean Reversion: Anything stretched too far in the short term tends to snap back toward its center. Over daily or intraday horizons, liquidity squeezes and panic bursts trigger temporary overreactions that self-correct.
  3. Carry: Collecting a steady yield simply for holding or financing an asset against another. This appears clearly in foreign exchange (buying high-yielding currencies funded by low-rate ones) or across the futures curve via roll yield (contango and backwardation).
  4. Relative Value and Statistical Arbitrage: Pairing two economically linked or cointegrated assets (two firms in the same sector, an ETF against its constituent basket, or credit spreads) and betting that an abnormal price spread will eventually narrow.

Once you grasp these four building blocks, quantitative trading stops looking like black magic and begins looking like plumbing: moving capital where supply and demand are temporarily misaligned.

Down to Earth: Mean Reversion with Internal Bar Strength (IBS)

To see this in practice rather than theory, look at one of the setups detailed in Section 4.4 of the paper (page 64): mean reversion in equity ETFs using Internal Bar Strength (IBS).

Retail technical analysis often relies on drawing subjective trend lines on candlestick charts. Quantitative models discard that subjectivity in favor of measurable, testable math. IBS is an exact arithmetic metric calculated directly from a single session's daily bar:

$$IBS = \frac{\text{Close} - \text{Low}}{\text{High} - \text{Low}}$$

Where:

  • Close: Final settled price of the session.
  • Low: Lowest price recorded during the day.
  • High: Highest price reached during the day.

The result is always a number between 0 and 1:

  • IBS = 0: The asset closed pinned to its session low (peak selling pressure).
  • IBS = 1: The asset closed at its session high (peak buying pressure).
  • IBS = 0.5: The close landed exactly midway through the daily range.

A quick numerical example: suppose an ETF trades between $98 and $102 (a $4 intraday range). If it finishes the session at $98.50:

$$IBS = \frac{98.50 - 98}{102 - 98} = \frac{0.50}{4} = 0.125$$

The resulting value (0.125) indicates that price finished in the lower 12.5% of its range, well below the oversold threshold.

The empirical intuition is straightforward. On broad, liquid index ETFs like the S&P 500 (SPY), a day that closes pinned against the floor usually reflects end-of-day institutional dumping or intraday stop-runs. In an underlying market with a long-term upward bias, this short-term exhaustion creates an asymmetric probability of a rebound over the following sessions.

The operational rules are crisp:

  • Long entry: Buy at the close if IBS < 0.2 (the market settled in the bottom 20% of its daily range).
  • Exit: Sell at the close once IBS > 0.8 (the price has recovered into the top 20% of its daily range).

Practical Python Implementation with Friction Controls

In real-world quantitative engineering, any backtest that omits transaction costs and slippage is a fantasy. In Appendix A, Kakushadze and Serur explicitly model linear execution drag assuming a baseline penalty of 10 basis points (0.10% per executed trade).

Here is a vectorized implementation of the IBS setup using Python and Pandas:

import numpy as np
import pandas as pd

def backtest_ibs_strategy(df, fee_bps=10):
    """
    df must contain columns: 'open', 'high', 'low', 'close'
    fee_bps: transaction cost in basis points per turnover (10 bps = 0.001)
    """
    data = df.copy()

    # 1. Compute Internal Bar Strength (IBS)
    bar_range = data['high'] - data['low']
    # Prevent division by zero on flat days
    bar_range = bar_range.replace(0, np.nan)
    data['ibs'] = (data['close'] - data['low']) / bar_range

    # 2. Signal generation
    data['signal'] = 0
    data.loc[data['ibs'] < 0.2, 'signal'] = 1   # Buy signal
    data.loc[data['ibs'] > 0.8, 'signal'] = -1  # Exit signal

    # State tracking (1 = long, 0 = cash)
    position = 0
    positions = []

    for sig in data['signal']:
        if sig == 1:
            position = 1
        elif sig == -1:
            position = 0
        positions.append(position)

    data['position'] = positions

    # 3. Daily returns and execution delay
    # To prevent lookahead bias, positions established at today's close
    # only realize tomorrow's market return (delay-1)
    data['market_return'] = data['close'].pct_change()
    data['strategy_return'] = data['position'].shift(1) * data['market_return']

    # 4. Frictional drag: commissions and slippage on each position turnover
    trades = data['position'].diff().abs()
    cost_per_dollar = fee_bps / 10000.0
    data['friction'] = trades * cost_per_dollar

    data['net_return'] = data['strategy_return'] - data['friction']

    # Performance summary
    total_pnl = (1 + data['net_return'].dropna()).prod() - 1
    sharpe = np.sqrt(252) * (data['net_return'].mean() / data['net_return'].std())

    print(f"Net cumulative return: {total_pnl * 100:.2f}%")
    print(f"Annualized Sharpe ratio: {sharpe:.2f}")

    return data

The critical line here is data['position'].shift(1). If you collect the return on the same bar that determines the close without shifting the array, you fall into what the authors warn against: an in-sample cheat, pretending you traded at a price that required the entire session to conclude before it could even be calculated.

The Pitfalls Where Most People Fail

Reading 151 recipes does not make you a master chef. Most engineers and retail quants who attempt to take paper strategies into live production fail on three specific hurdles:

The 'Delay-0' Mirage

It is trivial to build flattering backtests on a computer. If your signal depends on the 4:00 PM closing price and you pretend you were filled at that exact closing print, your simulation is broken. In the real world, you either submit a Market-On-Close (MOC) order minutes before the bell or wait to trade the next morning at the open (what the authors call a delay-1 strategy). As soon as you step away from instantaneous theoretical fills into realistic execution delays, paper gains shrink dramatically.

The Friction Tax

The code in the paper makes this clear: if a system turns over frequently chasing edges of 15 to 20 basis points, a broker taking 5 to 10 basis points in commissions and bid-ask spread wipes out the edge completely. The market rarely defeats you through bad predictions; it beats you down with friction.

Overfitting and Black Boxes

In sections 3.17 and 18.2, the paper covers machine learning methods like artificial neural networks (ANN) and k-nearest neighbors (KNN). The authors deliver a clear warning on page 92: fancy does not equal better.

When you calibrate an intricate model with dozens of free parameters against historical prices, it simply memorizes market noise. Once deployed out-of-sample with real capital, the performance collapses. As noted when analyzing Bitcoin's internal architecture, resilient systems rely on transparent, directly verifiable mechanics rather than gratuitous architectural complexity.

The true gift of 151 Trading Strategies is not a turnkey cash machine. Its real value is serving as an unfiltered reality check: it pulls back the curtain on Wall Street's mythology, documents the math openly, and hands you the statistical discipline needed to test ideas with engineering rigor.