BCJR algorithm

The Bahl-Cocke-Jelinek-Raviv (BCJR) algorithm is an algorithm for maximum a posteriori decoding of error correcting codes defined on trellises (principally convolutional codes). The algorithm was introduced in 1974 by Lalit R. Bahl, John Cocke, Frederick Jelinek and Josef Raviv, whose surnames give it its name. It applies to both linear block codes and convolutional codes.^[1]

BCJR-based decoders provide soft outputs, which express the relative probabilities of possible symbol values. They are used as component decoders in iterative turbo decoding.^[2]

The algorithm combines a forward pass and a backward pass through the trellis. Let ${\displaystyle S_{k}}$ denote the encoder state at time ${\displaystyle k}$, and ${\displaystyle y_{1}^{N}=(y_{1},\ldots ,y_{N})}$ the received sequence. Its metrics are

${\displaystyle {\begin{aligned}\alpha _{k}(s)&=P(S_{k}=s,y_{1}^{k}),\\\beta _{k}(s)&=P(y_{k+1}^{N}\mid S_{k}=s),\\\gamma _{k}(s',s)&=P(S_{k}=s,y_{k}\mid S_{k-1}=s').\end{aligned}}}$

For continuous observations, the corresponding probability densities are used. The branch metric ${\displaystyle \gamma _{k}}$ incorporates the channel observation and the prior probability of the transition.

The forward and backward recursions are

${\displaystyle \alpha _{k}(s)=\sum _{s'}\alpha _{k-1}(s')\gamma _{k}(s',s),}$

${\displaystyle \beta _{k-1}(s')=\sum _{s}\gamma _{k}(s',s)\beta _{k}(s).}$

Initialisation reflects the available information about the encoder's initial and final states. The posterior probability of a transition is proportional to

${\displaystyle P(S_{k-1}=s',S_{k}=s\mid y_{1}^{N})\propto \alpha _{k-1}(s')\gamma _{k}(s',s)\beta _{k}(s).}$

Summing over transitions associated with a particular input symbol and normalising gives that symbol's posterior probability.^[3]

Based on the trellis:

• Compute forward probabilities ${\displaystyle \alpha }$
• Compute backward probabilities ${\displaystyle \beta }$
• Compute smoothed probabilities based on other information (i.e. noise variance for AWGN, bit crossover probability for binary symmetric channel)

The simplified Berrou-Glavieux-Thitimajshima (SBGT) algorithm retains the structure of the BGT formulation while removing redundant divisions from its forward and backward recursions.^[3]

The Log-MAP algorithm performs the BCJR calculations in the logarithmic domain. This replaces probability multiplications with additions and reduces numerical difficulties associated with very small probabilities. When evaluated exactly, Log-MAP is equivalent to the probability-domain MAP algorithm. Max-Log-MAP simplifies the calculations further by approximating a logarithm of a sum of exponentials with the largest exponent; this approximation can reduce decoding accuracy.^[2]

The distinction is expressed by the identity

${\displaystyle \ln(e^{x}+e^{y})=\max(x,y)+\ln(1+e^{-|x-y|}).}$

Log-MAP retains the correction term ${\displaystyle \ln(1+e^{-|x-y|})}$, whereas Max-Log-MAP omits it.^[4]

A modified version that processes the trellis in segments to reduce computational complexity and memory requirements. This approach is particularly useful for very long sequences where full trellis storage becomes impractical. The windowed version maintains near-optimal performance while significantly lowering latency and hardware resource utilization in implementations.^[5]

• Susa framework implements BCJR algorithm for forward error correction codes and channel equalization in C++.

• Forward–backward algorithm
• Maximum a posteriori (MAP) estimation
• Hidden Markov model

• The online textbook: Information Theory, Inference, and Learning Algorithms, by David J.C. MacKay, discusses the BCJR algorithm in chapter 25.
• The implementation of BCJR algorithm in Susa signal processing framework