Reliability-Output Viterbi Algorithm (ROVA)

• ROVA is a MAP extension of the Viterbi algorithm that computes the exact posterior probability for the decoded codeword, enabling precise reliability detection.
• Its extension to tail-biting codes (TB ROVA) eliminates termination overhead, significantly reducing complexity and enhancing throughput in short-blocklength regimes.
• ROVA supports adaptive variable-length feedback coding by accurately determining word-correct probabilities, thereby outperforming conventional CRC-based methods.

The Reliability-Output Viterbi Algorithm (ROVA) is a maximum a posteriori (MAP) extension of the classical Viterbi algorithm, providing an exact computation of the posterior probability that the maximum-likelihood (ML) path recovered by the Viterbi decoder corresponds to the transmitted codeword. ROVA enables reliability-based error detection by quantifying the confidence in each decoded word, which is highly valuable for variable-length coding with feedback, especially in short-blocklength and low-latency communication regimes. Extensions of ROVA to tail-biting convolutional codes (TB ROVA) have enabled efficient, termination-free, and high-throughput coding schemes for both binary symmetric channels (BSC) and additive white Gaussian noise (AWGN) channels, frequently outperforming traditional CRC-based detection and even achieving throughput above the random-coding lower bound for variable-length feedback (VLF) codes at modest blocklengths (Williamson et al., 2014, Williamson et al., 2013, Williamson et al., 2013).

1. Foundations and Mathematical Formulation

ROVA operates on the trellis representation of a convolutional code, which enables the ML decoding path to be efficiently found via the standard (min-sum or max-log) Viterbi algorithm. Unlike the classical Viterbi decoder, which returns only the ML codeword, ROVA additionally computes the posterior probability $P(\hat{\mathbf X} \mid {\mathbf Y})$ that the ML codeword $\hat{\mathbf X}$ is correct given the received sequence $\mathbf Y$.

For a known start and end state $s$ and under equiprobable codewords, the posterior is given by: $$P(\hat{\mathbf X}^L \mid \mathbf Y^L) = \frac{f(\mathbf Y^L \mid \hat{\mathbf X}^L)}{\sum_{\mathbf X'} f(\mathbf Y^L \mid \mathbf X')}$$ where $f(\mathbf Y^L \mid \mathbf X^L)$ is the channel likelihood. The denominator encompasses a sum over all valid codewords, which is typically intractable except via a trellis-based recursion available to convolutional encoders (Williamson et al., 2013). ROVA constructs this sum in the log-domain alongside the usual path-metric maximization, computing the required quantities for each trellis state at every time step.

The algorithm maintains:

• $\Gamma_n(s)$: the max-log path metric for state $s$ at time $n$ (Viterbi path).
• $\Sigma_n(s)$: the log-sum-exponential (sum of likelihoods of all paths into $\hat{\mathbf X}$0).

Final quantities are

$\hat{\mathbf X}$1

where $\hat{\mathbf X}$2 is the max path metric over final states and $\hat{\mathbf X}$3 is the log-sum over all ending states (Williamson et al., 2013).

2. Extension to Tail-Biting Convolutional Codes

Tail-biting convolutional codes (TBCC) eliminate the need for explicit trellis termination by enforcing circular paths, i.e., the initial and final register state are identical. This avoids rate loss due to termination bits, which otherwise penalize performance at short blocklengths (Williamson et al., 2014).

In the tail-biting context, the initial/final state is unknown a priori. TB ROVA addresses this with several algorithmic strategies:

• Exact TB-ROVA: For each candidate start state $\hat{\mathbf X}$4, the known-state ROVA is executed, identifying the ML codeword and its word-correct probability $\hat{\mathbf X}$5. The final reliability is marginalized over all start states according to their likelihoods (Williamson et al., 2013).
• TB-SEA + ROVA: The Tail-Biting State-Estimation Algorithm (TB-SEA) first computes the posterior over start/end states in a forward pass. The ROVA is then run on the MAP start state, dramatically reducing computational complexity (Williamson et al., 2014, Williamson et al., 2013).
• Approximate methods and PRC: Fricke–Hoeher’s approximate ROVA and Post-Decoding Reliability Computation (PRC) allow further complexity reductions or compatibility with arbitrary decoders at the expense of exactness or trellis memory (Williamson et al., 2013).

These developments allow TB ROVA to compute exact word-correct probabilities within a small factor of the conventional Viterbi decoder’s complexity, circumventing the exponential cost of brute-force marginalization (Williamson et al., 2014).

3. Algorithmic Workflow and Complexity

A comparative summary of standard Viterbi decoding and ROVA is as follows:

Algorithm	Key Steps	Output
Standard Viterbi	Forward max-metric pass, traceback	ML codeword
ROVA	Forward max-metric pass (ML path);	ML codeword, posterior word-correct
	Simultaneous log-sum recursion	probability $\hat{\mathbf X}$6
TB ROVA (SEA+ROVA)	TB-SEA pass (MAP start state), then ROVA	ML codeword for best start, reliability

The complexity for terminated codes is $\hat{\mathbf X}$7 per pass. TB ROVA, either by TB-SEA + ROVA or by PRC, maintains complexity of $\hat{\mathbf X}$8 additions/multiplications per stage for state estimation, plus a standard ROVA pass (Williamson et al., 2013, Williamson et al., 2014). Exact TB-ROVA requires $\hat{\mathbf X}$9 full ROVA passes, but this is avoided by using TB-SEA + ROVA or PRC.

In practice, for moderate constraint lengths ($\mathbf Y$0), TB-SEA + ROVA nearly halves the addition operations and reduces multiplications to one-third of brute-force enumeration (Williamson et al., 2013).

4. Role in Short-Blocklength Feedback Coding

ROVA and TB ROVA underpin reliability-based variable-length feedback (VLF) coding schemes. Upon each decoding attempt (e.g., after every received symbol or every incremental group), the decoder computes $\mathbf Y$1. Decoding is terminated (transmitter sends ACK) as soon as $\mathbf Y$2, where $\mathbf Y$3 is the target undetected word-error probability (Williamson et al., 2014, Williamson et al., 2013).

This decision feedback not only enables adaptive-length transmissions but also delivers reliability without consuming any extra bits (in contrast to CRC). At short blocklengths, CRC overhead can amount to 10–20% or more of the effective rate, and the actual undetected error may exceed the safety threshold unless over-provisioned (Williamson et al., 2014).

Simulation results demonstrate that TB ROVA-based decision feedback allows throughput to surpass the finite-blocklength random-coding lower bound for VLF codes (Polyanskiy et al. 2011), especially for average blocklengths below 100 bits. For example, a 64-state TBCC with TB ROVA on the BSC achieves $\mathbf Y$4 bpcu at mean blocklength $\mathbf Y$5 bits—exceeding random-coding lower bounds in that regime (Williamson et al., 2014, Williamson et al., 2013).

5. Comparative Performance and Empirical Results

Empirical analysis highlights the advantages of ROVA and its TB extension in ultra-reliable low-latency communication:

• AWGN and BSC Channels: For $\mathbf Y$6 and blocklengths $\mathbf Y$7 bits, TBCCs used with TB ROVA outperform CRC-based retransmission (both in rate and undetected error). Notably, 16-bit CRCs are particularly costly at short blocklengths, reducing the achievable rate by approximately 20% for $\mathbf Y$8 bits (Williamson et al., 2014).
• Complexity-Performance Tradeoffs: TB-SEA + ROVA and Approximate TB-ROVA offer significant complexity reductions compared to brute-force enumeration. PRC can be used with any decoder to yield exact reliability with increased trellis bookkeeping (Williamson et al., 2013).
• Latencies and Throughput: For both BSC ($\mathbf Y$9) and BI-AWGN (2 dB, $s$0 bits/use) channels, simulation shows that TB ROVA-based schemes track or exceed the random-coding VLF lower bound up to $s$1 symbols, with rates as high as $s$2 bpcu at optimal blocklength (Williamson et al., 2014, Williamson et al., 2013).

6. Applications, Limitations, and Extensions

The primary application domain for ROVA and its extensions is short-blocklength, feedback-driven communication: variable-length hybrid ARQ, ultra-reliable low-latency communications (URLLC), and other scenarios where tight reliability constraints and low overhead are critical.

Limitations include:

• Exponential dependency on constraint length $s$3, shared with all trellis-based decoding.
• Diminishing returns for convolutional codes as blocklengths exceed approximately twice the traceback depth; here, LDPC or turbo codes with message-passing reliability may become preferable (Williamson et al., 2013).

Extensions to grouped decoding intervals (decoding every $s$4 symbols), integration with arbitrary tail-biting decoders via PRC, and further algorithmic refinements (e.g., approximate ROVA, puncturing optimization) are possible and explored in the cited works (Williamson et al., 2013, Williamson et al., 2014, Williamson et al., 2013).

7. Significance and Theoretical Impact

ROVA, originally introduced by Raghavan and Baum, and its tail-biting extensions, constitute efficient, optimal reliability-measurement mechanisms for convolutional codes. By enabling tight, error-probability-controlled stopping rules without sacrificing bits to error-detecting redundancy, they allow rate-efficient, ultra-low-latency operation in regimes where conventional coding is rate-inefficient or inflexible. The empirical observation that TB ROVA-based feedback schemes outperform Polyanskiy’s random-coding VLF lower bounds at short blocklengths demonstrates the practical impact of MAP reliability estimation and convolutional encoder structure in the finite-blocklength regime (Williamson et al., 2014, Williamson et al., 2013).

A plausible implication is that ROVA-derived reliability can generally enhance the efficiency and accuracy of hybrid ARQ, variable-length feedback, or anytime coding systems when the underlying code structure permits trellis-based recursions.

---

References: (Williamson et al., 2014): Variable-length Convolutional Coding for Short Blocklengths with Decision Feedback (Williamson et al., 2013): Reliability-output Decoding of Tail-biting Convolutional Codes (Williamson et al., 2013): Reliability-based Error Detection for Feedback Communication with Low Latency