"The Alpha Formula" Mean Reversion Strategy [by CabedoVestment]

Integrating Bonds into the Mean Reversion Strategy with "The Alpha Formula"

In "The Alpha Formula," the concept of mean reversion plays a central role in navigating market trends. One of the key elements in this strategy is using market regime indicators, like the 126-day Rate of Change (ROC), to determine when to shift asset allocations. The ROC indicator helps identify periods when equities may be overbought or oversold, signaling the potential for a mean reversion.

But what happens when the ROC suggests it's time to step out of equities? This is where bonds come into play.

When the market regime ROC indicates that staying out of equities is the optimal decision, investors can turn to bonds as a stabilizing asset class. Bonds, especially during periods of heightened market volatility or downturns, can offer lower risk and steady returns. By incorporating bonds into the portfolio during these times, the mean reversion strategy not only aims to reduce risk but also capitalizes on the potential for bond price appreciation as equities retreat.

In essence, the bond allocation acts as a hedge, preserving capital while positioning the portfolio to take advantage of future opportunities when the market eventually reverts to its mean. This integration of bonds into the strategy allows for a more balanced and adaptive approach, ensuring that the portfolio remains flexible and resilient in the face of shifting market conditions.

By following this approach, investors can effectively implement the mean reversion strategy described in "The Alpha Formula," while making use of bonds as a protective measure when the ROC indicates that it’s time to step away from the stock market.

Using intermediate bonds, in risk off scenarios when their short-term momentum (21 days) is positive and higher than cash's momentum, contributes to improve returns by more than 1% by maintaining almost the same level of the average risk.

namespace QuantConnect.Algorithm.CSharp
{
    public class ConnorsMeanReversionStrategy : QCAlgorithm
    {
        private const int RsiPeriodBUY = 4;
        private const int RsiPeriod = 2;
        private const int LookbackPeriod = 100;
        private const decimal MaxPortfolioRisk = 0.1m;
        private const int PortfolioStockSize = 10;
        private RateOfChange _spyROC126;
        private RateOfChange _bilROC21;
        private RateOfChange _iefROC21;
        private Dictionary<Symbol, RelativeStrengthIndex> _RSIIndicatorBUY = new Dictionary<Symbol, RelativeStrengthIndex>();
        private Dictionary<Symbol, RelativeStrengthIndex> _RSIIndicator = new Dictionary<Symbol, RelativeStrengthIndex>();
        private Dictionary<Symbol, StandardDeviation> _volatilityIndicator = new Dictionary<Symbol, StandardDeviation>();
        private Dictionary<Symbol, RateOfChange> _ROC4Indicator = new Dictionary<Symbol, RateOfChange>();
        public override void Initialize()
        {
            SetStartDate(1998, 1, 1);
            SetEndDate(DateTime.Now);
            SetCash(100000);
            var spy = AddEquity("SPY", Resolution.Daily);
            _spyROC126 = ROC(spy.Symbol, 126, Resolution.Daily);
            SetBenchmark(spy.Symbol);
            var bil = AddEquity("BIL", Resolution.Daily);
            var ief = AddEquity("IEF", Resolution.Daily);
            _bilROC21 = ROC("BIL",21,Resolution.Daily);
            _iefROC21 = ROC("IEF",21,Resolution.Daily);
            var history = History("BIL", 21, Resolution.Daily);
            foreach (TradeBar tradeBar in history)
            {
                _bilROC21.Update(tradeBar.EndTime, tradeBar.Close);
            }
            history = History("IEF", 21, Resolution.Daily);
            foreach (TradeBar tradeBar in history)
            {
                _iefROC21.Update(tradeBar.EndTime, tradeBar.Close);
            }
            UniverseSettings.Resolution = Resolution.Daily;
            SetUniverseSelection(new QC500UniverseSelectionModel());
            SetWarmUp(LookbackPeriod);
            Schedule.On(DateRules.Every(DayOfWeek.Monday), TimeRules.AfterMarketOpen("SPY", 0), ExecuteMondaySelling);
            Schedule.On(DateRules.Every(DayOfWeek.Monday), TimeRules.AfterMarketOpen("SPY", 1), ExecuteMondayTrading);
            Schedule.On(DateRules.EveryDay(), TimeRules.AfterMarketClose("SPY", 0), ExecuteDailySelling);
        }
        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            if (changes.AddedSecurities.Count > 0)
            {
                foreach (Security security in changes.AddedSecurities)
                {
                    if (!_RSIIndicator.ContainsKey(security.Symbol) && security.Symbol.Value != "SPY" && security.Symbol.Value != "BIL" && security.Symbol.Value != "IEF")
                    {
                        var symbol = security.Symbol;
                        var rsi = new RelativeStrengthIndex(RsiPeriod, MovingAverageType.Wilders);
                        var consolidator = new TradeBarConsolidator(CalendarType.Weekly);
                        RegisterIndicator(symbol, rsi, consolidator);
                        var rsiHistory = IndicatorHistory(rsi, symbol, LookbackPeriod, Resolution.Daily);
                        _RSIIndicator.Add(symbol, rsi);
                        var stdDev = new StandardDeviation(LookbackPeriod);
                        RegisterIndicator(security.Symbol, stdDev, Resolution.Daily);
                        var stdDevHistory = IndicatorHistory(stdDev, security.Symbol, LookbackPeriod, Resolution.Daily);
                        _volatilityIndicator.Add(security.Symbol, stdDev);
                        var roc4 = new RateOfChange(4);
                        var consolidator2 = new TradeBarConsolidator(CalendarType.Weekly);
                        RegisterIndicator(security.Symbol, roc4, consolidator2);
                        var roc4History = IndicatorHistory(roc4, symbol, LookbackPeriod, Resolution.Daily);
                        _ROC4Indicator.Add(security.Symbol, roc4);
                    }
                }
            }
            if (changes.RemovedSecurities.Count > 0)
            {
                foreach (var security in changes.RemovedSecurities)
                {
                    if (security.Invested)
                    {
                        Liquidate(security.Symbol);
                    }
                    if (_RSIIndicator.ContainsKey(security.Symbol))
                    {
                        _RSIIndicator.Remove(security.Symbol);
                        _RSIIndicatorBUY.Remove(security.Symbol);
                        _volatilityIndicator.Remove(security.Symbol);
                        _ROC4Indicator.Remove(security.Symbol);
                    }
                }
            }
        }
        private void ExecuteMondayTrading()
        {
            if (IsWarmingUp) return;
            if (_spyROC126 > 0)
            {
                SetHoldings("IEF", 0);
                var candidates = new List<Symbol>();
                var volatilityDict = new Dictionary<Symbol, decimal>();
                foreach (var symbol in _RSIIndicator.Keys)
                {
                    var currentPrice = Securities[symbol].Price;
                    if (currentPrice <= 0) continue;
                    var rsi = _RSIIndicator[symbol];
                    if (rsi.Current.Value < 20)
                    {
                        candidates.Add(symbol);
                        var stdDev100 = _volatilityIndicator[symbol].Current.Value;
                        volatilityDict[symbol] = stdDev100;
                    }
                }
                var selectedStocks = volatilityDict
                    .Where(x => candidates.Contains(x.Key))
                    .OrderBy(x => x.Value)
                    .Take(PortfolioStockSize)
                    .Select(x => x.Key)
                    .ToList();
                if (selectedStocks.Count > 0)
                {
                    int currentCount = Portfolio.Values.Count(v => v.Invested);
                    foreach (var symbol in selectedStocks)
                    {
                        if (currentCount < PortfolioStockSize)
                        {
                            SetHoldings(symbol, MaxPortfolioRisk);
                            currentCount++;
                        }
                    }
                }
            }
            else
            {
                if (_iefROC21 > _bilROC21 && _iefROC21 > 0)
                {
                    SetHoldings("IEF", 1);
                }
            }
        }
        private void ExecuteMondaySelling()
        {
            foreach (var symbol in Portfolio.Keys.ToList())
            {
                if (symbol != "IEF")
                {
                    if (_RSIIndicator.TryGetValue(symbol, out var rsi))
                    {
                        if (rsi.Current.Value > 80)
                        {
                            Liquidate(symbol);
                        }
                    }
                }
            }
        }
        public void ExecuteDailySelling()
        {
            foreach (var symbol in Portfolio.Keys.ToList())
            {
                if (symbol != "IEF")
                {
                    var currentPrice = Securities[symbol].Price;
                    var entryPrice = Portfolio[symbol].AveragePrice;
                    if (currentPrice < entryPrice * 0.9m)
                    {
                        Liquidate(symbol);
                    }
                }
            }
        }
    }
}

Will there be a Python version anytime?