Viterbi Algorithm

Unlike greedy approaches that make locally optimal state assignments at each time step, the Viterbi algorithm computes the globally optimal sequence of regimes. It uses a trellis structure to recursively compute the maximum probability of ending in each state at time t, storing backpointers to reconstruct the full path. This ensures the decoded regime sequence is the single most probable explanation of the observed market data under the model.

A naive brute-force evaluation of all possible state sequences would require O(N^T) operations, where N is the number of regimes and T is the sequence length—computationally intractable for any realistic financial time series. The Viterbi algorithm exploits the Markov property and optimal substructure to reduce this to O(N²T). This quadratic scaling in the number of states makes it feasible to decode regimes on tick-level or daily data spanning decades.

The algorithm operates on a trellis diagram with time steps as columns and hidden states as rows. At each time step t, it computes:

• Maximum path probability to each state j: δ_t(j) = max_i [δ_{t-1}(i) · a_{ij}] · b_j(o_t)
• Backpointer to the preceding state: ψ_t(j) = argmax_i [δ_{t-1}(i) · a_{ij}] where a_{ij} is the transition probability from state i to j, and b_j(o_t) is the emission probability of observation o_t given state j. After reaching the final time step, the algorithm traces back through the stored pointers to reconstruct the optimal path.

In practice, multiplying many probabilities smaller than 1 leads to arithmetic underflow in floating-point arithmetic. The standard implementation operates entirely in the log domain, converting products into sums:

• log δ_t(j) = max_i [log δ_{t-1}(i) + log a_{ij}] + log b_j(o_t) This transformation preserves the ordering of path probabilities while ensuring numerical stability for sequences with thousands of observations, which is essential for high-frequency financial applications.

The Viterbi algorithm performs hard decoding—it returns a single deterministic state sequence. This contrasts with the Forward-Backward algorithm, which performs soft decoding by computing the posterior probability of being in each state at each time step. In regime-switching trading models, hard decoding is preferred when the strategy requires a definitive regime classification to trigger specific allocation rules. Soft decoding is used when uncertainty quantification is needed for risk management.

The statistical framework that the Viterbi algorithm operates upon. An HMM assumes the market is governed by unobservable (hidden) states—such as bull, bear, or sideways regimes—that emit observable returns. The Viterbi algorithm solves the decoding problem: given a fitted HMM and a sequence of price data, what is the single most likely path of hidden states that generated it?

The Viterbi algorithm is a classic example of dynamic programming applied to a trellis structure. It avoids the exponential complexity of enumerating all possible state sequences by recursively computing the maximum probability path to each state at each time step. Key steps include:

• Initialization: Set the probability of starting in each state.
• Recursion: At each time step, for each state, select the predecessor that maximizes the joint probability.
• Backtracking: Reconstruct the optimal path using stored pointers.

A critical input to the Viterbi algorithm that governs the switching dynamics between regimes. This stochastic matrix defines the probability of transitioning from one hidden state to another. For example, a high self-transition probability (e.g., 0.95) implies regime persistence, meaning the algorithm will heavily penalize frequent state switches unless strongly supported by the observed data.

These two algorithms serve distinct purposes in the HMM lifecycle:

• Baum-Welch Algorithm: An Expectation-Maximization (EM) procedure used for training—estimating the HMM's parameters (transition and emission probabilities) from data when the state sequence is unknown.
• Viterbi Algorithm: Used for inference—decoding the most likely state sequence given an already-trained model and a new observation sequence. Viterbi provides a hard assignment of states, while Baum-Welch computes soft posterior probabilities.

The Viterbi algorithm transforms raw price data into a discrete sequence of regime labels. A quantitative strategist uses this decoded path to:

• Segment historical data into distinct volatility or trend clusters for backtesting.
• Identify the current regime in real-time to switch between trading strategies (e.g., trend-following in bull markets vs. mean-reversion in range-bound markets).
• Calculate regime-conditional metrics like the Regime-Conditional Value-at-Risk (Regime-CVaR).

The Viterbi algorithm runs in O(T × N²) time, where T is the length of the observation sequence and N is the number of hidden states. This linear scaling with time makes it highly efficient for processing long financial time series. The space complexity is O(T × N) to store the backpointers required for the final backtracking step, making it feasible for high-frequency decoding on streaming data.