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 is named after its inventors: Bahl, Cocke, Jelinek and Raviv. This algorithm is critical to modern iteratively-decoded error-correcting codes, including turbo codes and low-density parity-check codes.

Steps involved

Based on the trellis:

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

Variations

SBGT BCJR

Berrou, Glavieux and Thitimajshima simplification.

Log–MAP BCJR

The Log–MAP algorithm is a log-domain implementation of the BCJR (MAP) decoder. By working with log-likelihoods it avoids numerical underflow and turns probability multiplications into additions. In the log domain, the forward–backward recursions use the Jacobian logarithm ("max-star") identity $\ln (e^x+e^y)=\max (x,y)+\ln (1+e^{-|x-y|})$, which yields the same a-posteriori log-likelihood ratios (LLRs) as the original MAP/BCJR algorithm when applied to the branch metrics.

In practice, the small correction term $\ln (1+e^{-|x-y|})$ is implemented via a short look-up table or a piecewise-linear approximation; working in the log domain also simplifies normalization of the forward/backward state metrics. Log–MAP decoders that output extrinsic LLRs are widely used as the soft-input/soft-output components in iterative (turbo) decoders.

A common lower-complexity variant is **Max-Log-MAP**, which approximates the Jacobian logarithm by dropping the correction term (i.e., using $\ln (e^x+e^y)\approx \max (x,y)$). This reduces complexity at the cost of a small performance loss relative to Log-MAP/MAP; the gap can be narrowed with constant/linear corrections or by scaling the extrinsic information ("normalized/scaled Max-Log-MAP"), typically recovering a few-tenths of a dB depending on the code and SNR.

Windowed BCJR

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.

Implementations

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

See also

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

External links

• 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