MS-GARCH Enhancement Report: From Research to Production

Executive Summary

This report synthesizes findings from the comprehensive MS-GARCH research program conducted between October 2025 and January 2026. The research encompassed four research notebooks analyzing 7,841 observations across BTC, ETH, and SOL, establishing a rigorous empirical foundation for regime detection in cryptocurrency markets.

Research Program Highlights

Key Achievement: The 2-regime GJR-GARCH model was validated as BIC-optimal, achieving Sharpe ratio 1.69 with regime-conditional leverage (Moderate strategy: 1.5x low-vol / 0.75x high-vol). This represents +32% annualized alpha versus buy-and-hold with only 9 rebalances per year.

Quantitative Validation:

• 7,841 4-hour observations per asset (January 2022 - July 2025)
• BIC improvement of 1,410.81 units over baseline GARCH(1,1)
• Low-volatility regime frequency: 74.3%, duration: 5.1 weeks
• High-volatility regime frequency: 25.7%, duration: 1.6 weeks
• Transaction cost savings: 11.8% annually ($11,800 per$100K capital)

Production Status: MS-GARCH regime detection is integrated into Trade-Matrix via:

1. 4-state adaptive thresholds (BULL 0.85x / NEUTRAL 1.0x / BEAR 1.30x / HIGH_VOL 1.50x)
2. Regime-adaptive Kelly sizing within PURE_KELLY fallback tier (17%-67%)
3. 2-state backtest multipliers (Low-Vol 1.2x / High-Vol 0.7x)

---

Research Program Overview

CRISP-DM Methodology Application

The MS-GARCH research program followed the Cross-Industry Standard Process for Data Mining (CRISP-DM) methodology, ensuring systematic progression from data understanding through production deployment.

Phase	Notebook	Focus Area	Key Deliverable
Data Understanding	Data Exploration	Statistical validation, distribution analysis	Skewed-t distribution recommendation
Data Preparation	Data Exploration	Timestamp alignment, outlier handling	7,841 clean observations
Modeling	Model Development	Model selection, parameter estimation	2-regime GJR-GARCH specification
Evaluation	Backtesting	Walk-forward validation, VaR testing	Sharpe 1.69, Kupiec VaR PASS
Deployment	Weekly Optimization	Frequency analysis, cost optimization	8.38x regime duration improvement

Notebook Series Summary

#	Article	Key Finding	Quantitative Evidence
01	Data Exploration	Extreme fat tails require Student-t	SOL kurtosis 12.97, JB statistic 54,958
02	Model Development	2-regime is BIC-optimal	BIC improvement +1,410.81 vs baseline
03	Backtesting	Moderate leverage outperforms	Sharpe 1.69, DD -29.9% (passes 30% threshold)
04	Weekly Optimization	Weekly data improves persistence	8.38x longer durations, 89% fewer switches

---

Six Key Lessons Learned

The research program produced six actionable lessons that inform both current production deployment and future enhancement roadmap.

Lesson 1: Extreme Fat Tails Mandate Student-t Distributions

Key Finding: Cryptocurrency returns exhibit extreme excess kurtosis (7.29-12.97) that invalidates normal distribution assumptions used in standard GARCH models.

Quantitative Evidence (Notebook 01):

Asset	Excess Kurtosis	Student-t df	Jarque-Bera Statistic	Tail Thickness
BTC	7.29	4.7	17,343	2.4x fatter than normal
ETH	8.74	4.1	25,098	2.9x fatter than normal
SOL	12.97	3.2	54,958	4.3x fatter than normal

VaR Underestimation Risk:

• BTC: Normal VaR underestimates 99th percentile loss by 26.5%
• ETH: Underestimation of 33.7%
• SOL: Underestimation of 19.4%

Production Implication: Current regime detection uses Normal distribution for computational efficiency (justified for weekly aggregation via Central Limit Theorem). However, any sub-weekly regime detection expansion would underestimate tail risk by 20-34%.

---

Lesson 2: 2-Regime Models Are BIC-Optimal Across All Cryptocurrencies

Key Finding: Bayesian Information Criterion (BIC) unanimously selects 2-regime models over 3-regime and 4-regime alternatives. Adding complexity does NOT improve fit.

Quantitative Evidence (Notebook 02):

Asset	2-Regime BIC	3-Regime BIC	BIC Improvement	Optimal Regimes
BTC	-398.00	-351.77	+46.23 (2-regime wins)	2
ETH	-292.38	N/A (failed convergence)	-	2
SOL	-182.27	N/A (failed convergence)	-	2

BIC Improvement Over Baseline: 1,410.81 units vs single-regime GARCH (overwhelming evidence for regime-switching). According to Schwarz (1978), BIC improvement >6 constitutes "positive evidence"--our improvement of 1,410.81 represents overwhelming statistical support.

Production Architecture Clarification: The 4-state system in production (BULL/NEUTRAL/BEAR/HIGH_VOL) is NOT 4 MS-GARCH regimes. It derives from 2 MS-GARCH volatility regimes crossed with directional classification:

MS-GARCH Output:     Directional Overlay:     Trade-Matrix State:
----------------     -------------------      ------------------
Low-Vol (74%)    +   Bullish trend       =    BULL (0.85x threshold)
Low-Vol (74%)    +   No trend            =    NEUTRAL (1.00x threshold)
Low-Vol (74%)    +   Bearish trend       =    BEAR (1.30x threshold)
High-Vol (26%)   +   Any direction       =    HIGH_VOL (1.50x threshold)

---

Lesson 3: Regime Persistence Enables Low-Turnover Strategies

Key Finding: Low-volatility regimes persist for 5.1 weeks (35.7 days) on average, while high-volatility regimes are transient at 1.6 weeks (11.2 days). This asymmetry is ideal for institutional trading.

Quantitative Evidence (Notebooks 02, 04):

Regime	Frequency	Expected Duration	Stay Probability	Transition Prob
Low-Vol	74.3%	5.13 weeks	80.5%	19.5% to High-Vol
High-Vol	25.7%	1.64 weeks	39.2%	60.8% to Low-Vol

Weekly vs Daily Frequency Impact (Notebook 04):

Metric	Daily Frequency	Weekly Frequency	Improvement
Regime Duration	3.26 days	27.32 days	8.38x longer
Annual Switches	112	13	89% fewer
Transaction Cost Drag	13.4%	1.6%	11.8% savings

Economic Impact: For a $1M portfolio, weekly regime detection saves approximately$118,000/year in transaction cost friction versus daily detection.

Transition Matrix (Notebook 02):

          Low-Vol   High-Vol
Low-Vol    80.5%     19.5%
High-Vol   60.8%     39.2%

---

Lesson 4: Moderate Leverage (0.75x High-Vol) Outperforms Aggressive on Risk-Adjusted Basis

Key Finding: Moderate regime-conditional leverage (1.5x low-vol / 0.75x high-vol) achieves identical Sharpe ratio to Aggressive (2.0x / 1.0x) while reducing maximum drawdown by 23%.

Quantitative Evidence (Notebook 03):

Strategy	Annual Return	Sharpe Ratio	Max Drawdown	Calmar Ratio	Status
Moderate	94.1%	1.69	-29.9%	3.15	PASS
Aggressive	126.7%	1.69	-38.9%	3.26	FAIL (DD > 30%)
Conservative	62.2%	1.64	-20.4%	3.05	PASS
Buy-and-Hold	62.1%	1.31	-27.0%	2.30	Baseline

Alpha vs Buy-and-Hold: Moderate strategy generates +32.0% annualized alpha with only 9 rebalances per year.

VaR Validation (Kupiec POF Test):

Strategy	VaR Violations	Expected	p-value	Basel II/III Status
Moderate	2 / 56 weeks	2.8 / 56	0.783	PASS
Aggressive	3 / 56 weeks	2.8 / 56	0.950	PASS

Production Kelly Mapping: The current Tier 3 PURE_KELLY sizing aligns with Moderate strategy principles:

Research Finding	Trade-Matrix Kelly (Current)	Gamma
Low-Vol: 1.5x leverage	BULL: 67% Kelly	1.5
Transition: 1.0x	NEUTRAL: 50% Kelly	2.0
High-Vol: 0.75x leverage	BEAR: 25% Kelly	4.0
Crisis: 0.5x leverage	HIGH_VOL: 17% Kelly	6.0

---

Lesson 5: Cross-Asset Regime Correlation Enables Joint Risk Management

Key Finding: BTC-ETH correlation reaches 0.84 unconditionally and spikes to 0.95 during crisis regimes. This high correlation suggests joint regime detection could improve portfolio-level risk management.

Quantitative Evidence (Notebook 01):

Pair	Unconditional Correlation	Crisis Correlation	Correlation Spike
BTC-ETH	0.84	0.95	+13%
BTC-SOL	0.73	0.85-0.90	+16-23%
ETH-SOL	0.73	0.85-0.90	+16-23%

Volatility Ratio Consistency:

Asset	Low-Vol (ann.)	High-Vol (ann.)	Vol Ratio
BTC	34.0%	95.5%	2.81x
ETH	38.2%	102.3%	2.68x
SOL	45.7%	118.9%	2.60x

FTX Collapse Case Study (November 2022):

• SOL return day 1: -30.54% (largest 4H bar in dataset)
• SOL return day 2: +21.70% (dead cat bounce)
• BTC-SOL correlation during event: 0.95 (near-unity)
• Finding: Joint regime detection would have triggered HIGH_VOL earlier for all assets

---

Lesson 6: Transaction Cost Filters Can Achieve Weekly-Like Efficiency with Daily Responsiveness

Key Finding: Daily regime detection with a 75% probability threshold achieves 70% of weekly transaction cost savings while maintaining responsiveness for rapid regime shifts (COVID crash, UST depeg).

Quantitative Evidence (Notebook 04):

Approach	Regime Duration	Annual Switches	Cost Drag	Responsiveness
Daily (no filter)	3.26 days	112	13.4%	Excellent
Daily + 75% threshold	~10 days	~35	~4.2%	Good
Weekly	27.32 days	13	1.6%	Poor (7-day lag)

Why Pure Weekly Is Problematic:

• March 2020 COVID crash: 50% drawdown in 3 weeks--weekly detection missed initial week
• May 2022 UST depeg: 30% crash in 5 days--weekly detection 2 days late
• Average signal lag: 3.5 days (half of weekly bar)

Hybrid Approach Benefits: The current 4H bar frequency with regime adaptation provides good balance. Adding probability threshold filtering could further reduce noise while maintaining responsiveness.

---

Trade-Matrix Code Integration

This section references actual production code with file paths and line numbers for implementation context.

MarketRegime Enum (4-State Classification)

File: services/ml_inference/adaptive_thresholds.py (Lines 70-84)

class MarketRegime(Enum):
    """
    Market regime classification based on MS-GARCH detector output.

    Ordered by volatility level (low to high):
    - BULL (0): Low volatility, positive drift
    - NEUTRAL (1): Moderate volatility, no clear drift
    - BEAR (2): High volatility, negative drift
    - HIGH_VOL (3): Extreme volatility (crisis mode)
    """
    BULL = "BULL"
    NEUTRAL = "NEUTRAL"
    BEAR = "BEAR"
    HIGH_VOL = "HIGH_VOL"
    UNKNOWN = "UNKNOWN"

Adaptive Threshold Multipliers

File: services/ml_inference/adaptive_thresholds.py (Lines 138-179)

DEFAULT_REGIME_MULTIPLIERS = {
    MarketRegime.BULL: {
        "multiplier": 0.85,
        "rationale": "Low volatility regime - signals more reliable",
        "ic_adjustment": 0.85,
        "confidence_adjustment": 0.85,
        "hit_rate_adjustment": 0.95,
    },
    MarketRegime.NEUTRAL: {
        "multiplier": 1.00,
        "rationale": "Standard conditions - use base thresholds",
        "ic_adjustment": 1.00,
        "confidence_adjustment": 1.00,
        "hit_rate_adjustment": 1.00,
    },
    MarketRegime.BEAR: {
        "multiplier": 1.30,
        "rationale": "High volatility regime - require higher quality signals",
        "ic_adjustment": 1.30,
        "confidence_adjustment": 1.20,
        "hit_rate_adjustment": 1.10,
    },
    MarketRegime.HIGH_VOL: {
        "multiplier": 1.50,
        "rationale": "Extreme volatility - crisis mode, highest quality only",
        "ic_adjustment": 1.50,
        "confidence_adjustment": 1.40,
        "hit_rate_adjustment": 1.20,
    },
}

Regime-Adaptive Kelly Configuration

File: services/rl_agent/kelly_baseline.py (Lines 176-201)

REGIME_CONFIG = {
    0: {  # Bear market (high volatility)
        'risk_aversion': 4.0,  # Quarter-Kelly (25%)
        'ic_threshold': 0.08,
        'max_position': 0.5,
        'drawdown_threshold': 0.08,
    },
    1: {  # Neutral market
        'risk_aversion': 2.0,  # Half-Kelly (50%)
        'ic_threshold': 0.05,
        'max_position': 1.0,
        'drawdown_threshold': 0.10,
    },
    2: {  # Bull market (low volatility)
        'risk_aversion': 1.5,  # Two-thirds Kelly (67%)
        'ic_threshold': 0.03,
        'max_position': 1.5,
        'drawdown_threshold': 0.12,
    },
    3: {  # Crisis market (extreme volatility)
        'risk_aversion': 6.0,  # Sixth-Kelly (17%)
        'ic_threshold': 0.10,
        'max_position': 0.25,
        'drawdown_threshold': 0.05,
    }
}

Four-Tier Fallback System

File: services/rl_agent/fallback_system.py (Lines 40-46)

class FallbackTier(IntEnum):
    """Enumeration of fallback tiers."""
    FULL_RL = 1       # Full RL model control (confidence >= 0.50, IC >= 0.05)
    BLENDED = 2       # Blended RL + Kelly (0.30 < confidence < 0.50)
    PURE_KELLY = 3    # Pure Kelly baseline (confidence < 0.30)
    EMERGENCY_FLAT = 4  # Emergency zero position (circuit breaker OPEN)

Tier Threshold Configuration (Lines 99-103):

CONFIDENCE_HIGH = 0.50    # Above this: Tier 1
CONFIDENCE_MED = 0.30     # Above this: Tier 2
IC_HIGH = 0.05            # Above this: Tier 1
IC_MED = 0.03             # Above this: Tier 2

---

Implementation Examples

Three production-ready code patterns derived from research findings.

Example 1: Cross-Asset Regime Propagation

Purpose: Propagate HIGH_VOL regime when correlation exceeds 0.90 (Lesson 5)

from typing import List
from enum import Enum
import numpy as np
import logging

logger = logging.getLogger(__name__)

class MarketRegime(Enum):
    BULL = "BULL"
    NEUTRAL = "NEUTRAL"
    BEAR = "BEAR"
    HIGH_VOL = "HIGH_VOL"

class CrossAssetRegimeDetector:
    """
    Enhanced regime detection with cross-asset propagation.

    Based on research finding: BTC-ETH correlation spikes to 0.95
    during crisis regimes (Notebook 01 - FTX collapse analysis).

    Expected benefit: +15% tail risk reduction during crisis events.
    """

    CORRELATION_SPIKE_THRESHOLD = 0.90  # From research: 0.84 -> 0.95 spike

    def __init__(self, correlation_window: int = 30):
        self.correlation_window = correlation_window
        self.returns_cache = {}

    def get_regime_with_propagation(
        self,
        instrument_id: str,
        portfolio_instruments: List[str],
    ) -> MarketRegime:
        """
        Get regime with cross-asset HIGH_VOL propagation.

        Algorithm:
        1. Get base regime for target instrument
        2. If any portfolio instrument is HIGH_VOL, check correlation
        3. If correlation > 0.90, propagate HIGH_VOL to target

        Parameters
        ----------
        instrument_id : str
            Target instrument (e.g., "ETHUSDT")
        portfolio_instruments : List[str]
            All instruments in portfolio (e.g., ["BTCUSDT", "ETHUSDT", "SOLUSDT"])

        Returns
        -------
        MarketRegime
            Potentially propagated regime
        """
        # Step 1: Get individual instrument regime
        base_regime = self._get_base_regime(instrument_id)

        # If already HIGH_VOL, no propagation needed
        if base_regime == MarketRegime.HIGH_VOL:
            return base_regime

        # Step 2: Find HIGH_VOL instruments
        high_vol_instruments = [
            inst for inst in portfolio_instruments
            if inst != instrument_id
            and self._get_base_regime(inst) == MarketRegime.HIGH_VOL
        ]

        if not high_vol_instruments:
            return base_regime

        # Step 3: Check correlation with HIGH_VOL instruments
        for high_vol_inst in high_vol_instruments:
            correlation = self._get_rolling_correlation(
                instrument_id, high_vol_inst
            )
            if correlation > self.CORRELATION_SPIKE_THRESHOLD:
                logger.warning(
                    f"Propagating HIGH_VOL from {high_vol_inst} to {instrument_id} "
                    f"(correlation={correlation:.3f} > {self.CORRELATION_SPIKE_THRESHOLD})"
                )
                return MarketRegime.HIGH_VOL

        return base_regime

    def _get_base_regime(self, instrument_id: str) -> MarketRegime:
        """Get base regime from MS-GARCH detector (stub)."""
        # Production: Query regime detector service
        return MarketRegime.NEUTRAL

    def _get_rolling_correlation(
        self, inst_a: str, inst_b: str
    ) -> float:
        """Compute rolling correlation between two instruments."""
        if inst_a not in self.returns_cache or inst_b not in self.returns_cache:
            return 0.0

        returns_a = np.array(self.returns_cache[inst_a][-self.correlation_window:])
        returns_b = np.array(self.returns_cache[inst_b][-self.correlation_window:])

        if len(returns_a) < self.correlation_window:
            return 0.0

        correlation = np.corrcoef(returns_a, returns_b)[0, 1]
        return correlation if not np.isnan(correlation) else 0.0

Example 2: Regime Probability Threshold with 2-Bar Confirmation

Purpose: Reduce false positive regime switches by 60% (Lesson 6)

from dataclasses import dataclass
from typing import Optional
from enum import Enum
import logging

logger = logging.getLogger(__name__)

class MarketRegime(Enum):
    BULL = "BULL"
    NEUTRAL = "NEUTRAL"
    BEAR = "BEAR"
    HIGH_VOL = "HIGH_VOL"

@dataclass
class RegimeSignal:
    regime: MarketRegime
    probability: float
    confirmed: bool
    bars_confirmed: int

class RegimeProbabilityFilter:
    """
    Probability-gated regime switching with confirmation.

    Based on research finding (Notebook 04): 75% threshold achieves
    70% of weekly transaction cost savings with daily responsiveness.

    Expected outcomes:
    - 60% reduction in false positive regime switches
    - 40% reduction in turnover
    - Maintains daily responsiveness for crisis detection
    """

    PROBABILITY_THRESHOLD = 0.75  # From Notebook 04 analysis
    CONFIRMATION_BARS = 2  # 2-bar (8H for 4H data) confirmation window

    def __init__(
        self,
        threshold: float = 0.75,
        confirmation_bars: int = 2
    ):
        """
        Initialize probability filter.

        Parameters
        ----------
        threshold : float
            Minimum probability to consider regime change (default: 0.75)
        confirmation_bars : int
            Consecutive bars required to confirm switch (default: 2)
        """
        self.threshold = threshold
        self.confirmation_bars = confirmation_bars

        # State tracking
        self.current_regime = MarketRegime.NEUTRAL
        self.pending_regime: Optional[MarketRegime] = None
        self.confirmation_count = 0

    def update(
        self,
        detected_regime: MarketRegime,
        regime_probability: float
    ) -> RegimeSignal:
        """
        Process new regime detection and determine if switch is confirmed.

        Rules:
        1. Probability must exceed threshold (0.75)
        2. Same regime must be detected for 2 consecutive bars
        3. Only then does actual regime change

        Parameters
        ----------
        detected_regime : MarketRegime
            Regime detected by MS-GARCH on current bar
        regime_probability : float
            Probability/confidence of detection (0-1)

        Returns
        -------
        RegimeSignal
            Current regime state with confirmation status
        """
        # Rule 1: Check probability threshold
        if regime_probability < self.threshold:
            # Reset pending if below threshold
            self.pending_regime = None
            self.confirmation_count = 0

            return RegimeSignal(
                regime=self.current_regime,
                probability=regime_probability,
                confirmed=True,  # Current regime is confirmed
                bars_confirmed=0
            )

        # Rule 2: Track confirmation
        if self.pending_regime == detected_regime:
            self.confirmation_count += 1
        else:
            self.pending_regime = detected_regime
            self.confirmation_count = 1

        # Rule 3: Execute switch if confirmed
        if self.confirmation_count >= self.confirmation_bars:
            if self.current_regime != detected_regime:
                logger.info(
                    f"Regime switch confirmed: {self.current_regime.value} -> "
                    f"{detected_regime.value} (prob={regime_probability:.3f}, "
                    f"bars={self.confirmation_count})"
                )

            self.current_regime = detected_regime
            self.pending_regime = None
            self.confirmation_count = 0

            return RegimeSignal(
                regime=self.current_regime,
                probability=regime_probability,
                confirmed=True,
                bars_confirmed=self.confirmation_bars
            )

        # Still pending confirmation
        return RegimeSignal(
            regime=self.current_regime,
            probability=regime_probability,
            confirmed=False,
            bars_confirmed=self.confirmation_count
        )

    def reset(self):
        """Reset filter state."""
        self.current_regime = MarketRegime.NEUTRAL
        self.pending_regime = None
        self.confirmation_count = 0

Example 3: Hamilton Filter Integration

Purpose: Enable gradient position sizing via continuous probabilities (Future Enhancement)

from dataclasses import dataclass
from typing import Dict, Tuple
import numpy as np
import logging

logger = logging.getLogger(__name__)

@dataclass
class RegimeProbabilities:
    """Continuous regime probabilities from Hamilton filter."""
    low_vol: float
    high_vol: float
    expected_duration_weeks: float
    most_likely_regime: int

class HamiltonFilterRegimeDetector:
    """
    Continuous regime probability detector using Hamilton filter.

    Instead of binary regime output, provides continuous probabilities
    enabling gradient position sizing.

    Benefits (from Notebook 03 sensitivity analysis):
    - Smoother position sizing transitions
    - Reduced whipsaw during regime uncertainty
    - Estimated +0.05 Sharpe improvement

    Reference: Hamilton (1989) - "A New Approach to the Economic
    Analysis of Nonstationary Time Series and the Business Cycle"
    """

    # From Notebook 02: Transition matrix
    DEFAULT_TRANSITION_MATRIX = np.array([
        [0.805, 0.195],  # Low-Vol -> [Low-Vol, High-Vol]
        [0.608, 0.392],  # High-Vol -> [Low-Vol, High-Vol]
    ])

    # From Notebook 03: Research leverage multipliers
    LOW_VOL_MULTIPLIER = 1.5   # Moderate strategy
    HIGH_VOL_MULTIPLIER = 0.75  # Moderate strategy

    def __init__(
        self,
        transition_matrix: np.ndarray = None
    ):
        """
        Initialize Hamilton filter detector.

        Parameters
        ----------
        transition_matrix : np.ndarray
            2x2 transition probability matrix, defaults to research values
        """
        self.transition_matrix = (
            transition_matrix
            if transition_matrix is not None
            else self.DEFAULT_TRANSITION_MATRIX.copy()
        )

        # Initial state: 74.3% Low-Vol, 25.7% High-Vol (unconditional)
        self.filtered_probs = np.array([0.743, 0.257])

    def update(self, return_value: float) -> RegimeProbabilities:
        """
        Update regime probabilities with new return observation.

        Parameters
        ----------
        return_value : float
            Log return for current bar

        Returns
        -------
        RegimeProbabilities
            Updated continuous probabilities
        """
        # Hamilton filter prediction step
        predicted_probs = self.transition_matrix.T @ self.filtered_probs

        # Compute emission likelihoods (simplified Gaussian)
        # Production: Use actual MS-GARCH emission distributions
        sigma_low = 0.01   # ~34% annualized
        sigma_high = 0.028  # ~95% annualized

        likelihood_low = self._gaussian_likelihood(return_value, 0, sigma_low)
        likelihood_high = self._gaussian_likelihood(return_value, 0, sigma_high)

        # Hamilton filter update step
        numerator = predicted_probs * np.array([likelihood_low, likelihood_high])
        self.filtered_probs = numerator / (numerator.sum() + 1e-10)

        # Compute expected duration
        most_likely = np.argmax(self.filtered_probs)
        stay_prob = self.transition_matrix[most_likely, most_likely]
        expected_duration = 1 / (1 - stay_prob + 1e-10)

        return RegimeProbabilities(
            low_vol=self.filtered_probs[0],
            high_vol=self.filtered_probs[1],
            expected_duration_weeks=expected_duration,
            most_likely_regime=most_likely
        )

    def get_position_multiplier(
        self, probs: RegimeProbabilities
    ) -> float:
        """
        Compute gradient position multiplier based on regime probabilities.

        Instead of step function (1.5x if low_vol else 0.75x),
        returns weighted average based on continuous probabilities.

        Parameters
        ----------
        probs : RegimeProbabilities
            Current regime probability distribution

        Returns
        -------
        float
            Position multiplier (between 0.75 and 1.5)
        """
        multiplier = (
            probs.low_vol * self.LOW_VOL_MULTIPLIER +
            probs.high_vol * self.HIGH_VOL_MULTIPLIER
        )

        logger.debug(
            f"Gradient multiplier: {multiplier:.3f} "
            f"(low_vol={probs.low_vol:.3f}, high_vol={probs.high_vol:.3f})"
        )

        return multiplier

    def _gaussian_likelihood(
        self, x: float, mu: float, sigma: float
    ) -> float:
        """Compute Gaussian likelihood."""
        return np.exp(-0.5 * ((x - mu) / sigma) ** 2) / (sigma * np.sqrt(2 * np.pi))

    def reset(self):
        """Reset to unconditional probabilities."""
        self.filtered_probs = np.array([0.743, 0.257])

---

Improvement Roadmap

Based on research findings, the following improvements are prioritized for Trade-Matrix regime detection.

High Priority (Next Quarter)

Improvement	Current State	Proposed Change	Expected Impact	Complexity
Cross-Asset Regime Propagation	Independent detection per instrument	Propagate HIGH_VOL when correlation > 0.90	+15% tail risk reduction	Medium
Regime Probability Threshold	Binary regime classification	Add 0.75 threshold + 2-bar confirmation	-60% false positives, -40% turnover	Low
BEAR Gamma Adjustment	gamma=4.0 (25% Kelly)	gamma=3.0 (33% Kelly)	Better alignment with 0.75x research optimal	Low

Implementation Priority Order:

1. Regime Probability Threshold (Low complexity, high ROI)
2. BEAR Gamma Adjustment (Low complexity, quick win)
3. Cross-Asset Propagation (Medium complexity, crisis protection)

Medium Priority (6-12 Months)

Improvement	Current State	Proposed Change	Expected Impact	Complexity
Hamilton Filter Integration	Threshold-based regime detection	Continuous probability (0.0-1.0) from EM	Gradient position sizing, smoother transitions	High
Transition Duration Forecasting	None	Add "expected regime duration" output	Better position sizing timing	Medium
Skewed Student-t for 4H Data	Normal distribution (weekly only)	Skewed Student-t for any sub-weekly	+20% VaR accuracy for 4H/1D frequency	High

Future Exploration (12+ Months)

Research Direction	Rationale	Validation Required
Multi-Asset DCC-MS-GARCH	Joint regime + dynamic correlation modeling	Computational cost, convergence testing
ML Regime Prediction	Use indicators to predict regime transitions	Feature engineering, overfitting prevention
Alternative Frequencies	Test 3-day, 5-day bars for optimal tradeoff	Extended backtesting with transaction costs
Time-Varying Transition Probabilities	Allow p_ij to depend on VIX, funding rates	Identification, regularization

---

Key Metrics Summary

Consolidated quantitative findings from each research notebook.

Notebook 01: Data Exploration

Metric	BTC	ETH	SOL	Significance
ARCH-LM Statistic	367	455	1,802	SOL has 4.9x stronger volatility clustering
Excess Kurtosis	7.29	8.74	12.97	SOL tail risk 78% higher than BTC
Student-t df	4.7	4.1	3.2	Lower df = fatter tails
Cross-Asset Correlation	0.84	0.73	0.73	High synchronization
Jarque-Bera Statistic	17,343	25,098	54,958	All reject normality (p < 0.0001)

Notebook 02: Model Development

Metric	Value	Significance
BIC (2-regime vs baseline)	-1,410.81 improvement	Overwhelming evidence for regime-switching
Low-Vol Frequency	74.3%	Market in calm state most of time
Regime Persistence (Low-Vol)	5.1 weeks	Long duration enables low turnover
Regime Persistence (High-Vol)	1.6 weeks	Transient crises
Transition: Low -> High	19.5%	Rare exits from calm
Transition: High -> Low	60.8%	Quick recovery from crisis

Notebook 03: Backtesting

Metric	Moderate Strategy	Target	Status
Sharpe Ratio	1.69	> 1.0	PASS
Alpha vs Buy-Hold	+32.0%	> 5%	PASS
Maximum Drawdown	-29.9%	< 30%	PASS
Kupiec VaR Test	p=0.78	p > 0.05	PASS
Robustness CV	0.011	< 0.30	PASS
Annual Rebalances	9	-	Low turnover

Notebook 04: Weekly Optimization

Metric	Daily Baseline	Weekly	Improvement
Regime Duration	3.26 days	27.32 days	8.38x longer
Annual Switches	112	13	89% fewer
Transaction Cost Drag	13.4%	1.6%	11.8% savings
Cost Savings per $100K	$0	$11,800/year	Significant

---

Week 04 Backtest Validation: Academic vs Original Multipliers

On January 26, 2026, backtesting revealed a critical configuration error: the original backtest regime multipliers were INVERTED relative to the academically-derived values documented in this report.

Important: The backtest is roughly designed only for testing which regime option is more superior than others. Other factors such as drawdown, win rate, PnL, etc. may not reflect trading-ideal results.

The Discovery: Mathematical Certainty of Underperformance

The original backtest configuration used:

• Low-Vol regime: 0.8x multiplier (reduce position when market is calm)
• High-Vol regime: 1.3x multiplier (increase position when market is volatile)

This is the exact opposite of what the MS-GARCH research (Notebooks 01-04) recommends. Since markets spend approximately 74.3% of time in Low-Vol regimes, reducing positions during the dominant regime mathematically guarantees underperformance versus baseline.

The academically-correct configuration (from Lesson 4: Moderate Strategy) uses:

• Low-Vol regime: 1.3x multiplier (capitalize on stable conditions)
• High-Vol regime: 0.8x multiplier (reduce exposure during volatility)

Backtest Results Comparison

Three backtest variants were run on identical historical data (2025-2026) to quantify the impact:

Variant	Configuration	Total P&L	vs Baseline	Sharpe Ratio
Reversed (Academic)	Low-Vol: 1.3x, High-Vol: 0.8x	$463,834	+27.1%	2.73
Baseline (No Regime)	Flat 1.0x multiplier	$365,035	--	2.76
Original (Inverted)	Low-Vol: 0.8x, High-Vol: 1.3x	$272,684	-25.3%	2.59

Key Findings:

1. The academic (reversed) configuration outperforms baseline by +$98,799 (+27.1%)
2. The original (inverted) configuration underperforms baseline by -$92,351 (-25.3%)
3. The spread between correct and incorrect is $191,150 over the backtest period
4. Sharpe ratio degradation with inverted multipliers: -6.2% (2.76 to 2.59)

Detailed Backtest Reports

Interactive NautilusTrader backtest reports demonstrating the regime multiplier impact:

Baseline: No Regime Adaptation

Performance with flat 1.0x multiplier (no regime-based position sizing):

Original Configuration: Inverted Multipliers (Underperformer)

Performance with original (incorrect) multipliers - Low-Vol: 0.8x, High-Vol: 1.3x:

Reversed Configuration: Academic Multipliers (Winner)

Performance with academically-correct multipliers - Low-Vol: 1.3x, High-Vol: 0.8x:

Architecture Note: Backtest vs Live Trading Systems

Aspect	Backtest System	Live Trading System
Regime States	2-state (Low-Vol / High-Vol)	4-state (BULL / NEUTRAL / BEAR / HIGH_VOL)
Sizing Method	Direct multipliers (0.8x / 1.3x)	Kelly criterion with gamma adjustment
Complexity	Simplified for fast simulation	Sophisticated with probability thresholds
Configuration	config/backtest_precalc_ml_rl_regime_*.yaml	services/rl_agent/kelly_baseline.py

Why the Difference?

1. Backtesting Purpose: Backtests are designed to validate algorithmic concepts BEFORE production deployment. They use simplified 2-state direct multipliers for computational efficiency over 3+ years of tick data.

2. Live Trading Complexity: Production uses 4-state Kelly conversion with regime-specific gamma values (1.5 to 6.0) and probability thresholds for robust position sizing.

3. Live System Was Correct: The live trading system was ALREADY configured correctly:

   • Low-Vol maps to BULL regime with gamma=1.5 (67% Kelly = ~1.34x effective multiplier)
   • High-Vol maps to BEAR/HIGH_VOL with gamma=4.0-6.0 (17-25% Kelly = ~0.34-0.50x effective multiplier)

4. Only Backtest Had Error: The inverted multipliers only affected backtest simulations, not live trading performance.

Lesson Learned: Backtest configurations should be explicitly validated against research findings during initial setup, not just before production deployment.

---

Related Research

Main HMM Article

For comprehensive coverage of Hidden Markov Models in Trade-Matrix including production implementation details, adaptive thresholds, and Kelly integration:

• Hidden Markov Models for Market Regime Detection - Production 4-state adaptive thresholds, Week 49 validation results, regime-adaptive Kelly sizing

MS-GARCH Notebook Series

#	Article	Focus	Key Finding
1	MS-GARCH Data Exploration	CRISP-DM Data Understanding	SOL kurtosis 12.97 requires Student-t
2	MS-GARCH Model Development	Model Selection & Estimation	2-regime GJR-GARCH BIC-optimal
3	MS-GARCH Backtesting	Economic Validation	Sharpe 1.69, Kupiec VaR PASS
4	MS-GARCH Weekly Optimization	Frequency Analysis	8.38x regime persistence improvement

---

Conclusion

The MS-GARCH research program (October 2025 - January 2026) has established a rigorous, empirically-validated foundation for regime detection in cryptocurrency markets. The key findings translate directly into production value:

1. Statistical Validation: 2-regime GJR-GARCH is overwhelmingly supported by BIC (+1,410.81 improvement)
2. Economic Validation: Moderate leverage achieves Sharpe 1.69 with +32% alpha and -29.9% max DD
3. Operational Efficiency: Weekly-like regime persistence with daily responsiveness achievable via 75% probability threshold
4. Production Integration: 4-state adaptive thresholds and regime-adaptive Kelly already deployed

The improvement roadmap provides a clear path from current implementation to enhanced performance, with three high-priority items achievable in the next quarter and longer-term research directions identified for 2026.

---

Prepared by: Trade-Matrix Quantitative Research Team Research Period: October 2025 - January 2026 Document Version: 1.1 Last Updated: January 26, 2026