Forward Error Correction (FEC)

Forward Error Correction: Fixing Errors Without Retransmission

Forward Error Correction is a technique that enables a receiver to correct transmission errors without requesting retransmission from the sender. This capability is essential in scenarios where retransmission is impossible or impractical — deep-space communication (where round-trip delay is hours), broadcasting (one-to-many transmission), and real-time systems (where delay is unacceptable). FEC adds carefully structured redundancy that allows the receiver to not only detect errors but actually reconstruct the original data.

Why "Forward"?

The word "forward" distinguishes FEC from backward error correction (retransmission/ARQ). In ARQ, when an error is detected, the receiver sends a request backward to the transmitter asking for the data again. In FEC, all the information needed for correction travels forward with the data — the receiver fixes errors independently.

Think of it this way: if you are giving someone driving directions by radio, ARQ would be them calling back saying "I missed that — repeat the last instruction." FEC would be you saying each instruction three slightly different ways so they can figure out the correct version even if one version gets garbled.

The Fundamental Trade-off

FEC operates on a fundamental principle: adding redundancy reduces the effective data rate but improves reliability:

Code rate: R = k/n (k information bits encoded into n total bits, n > k) Redundancy: (n-k)/n = 1 - R

A rate 1/2 code doubles the transmitted bits — half carry data, half carry protection. This halves throughput but can provide 5-10 dB of coding gain.

Coding gain measures the SNR reduction achieved by FEC:

• Coding gain = (Eb/N₀ without coding) - (Eb/N₀ with coding) for same BER
• Typical values: 3-10 dB depending on code complexity and rate

A 6 dB coding gain means the transmitter needs 4× less power for the same error rate — or equivalently, the link range doubles (since power decreases as distance²).

Block Codes for FEC

Block codes divide data into fixed-size blocks and encode each independently:

Hamming Codes: The simplest FEC — correct single errors, detect double errors.

• (7,4) Hamming: 4 data bits + 3 parity bits, corrects 1 error
• Minimum distance dmin = 3, correction capability t = 1
• Low complexity but limited correction power

BCH Codes (Bose-Chaudhuri-Hocquenghem):

• Family of cyclic codes with flexible error correction capability
• Can be designed to correct any specified number of errors t
• Used in flash memory (NAND) error correction

Reed-Solomon Codes:

• Operate on multi-bit symbols (bytes) rather than individual bits
• Excellent for burst errors — corrects entire corrupted symbols
• RS(255,223): 223 data bytes + 32 parity bytes, corrects up to 16 symbol errors
• Used in CDs, DVDs, QR codes, deep-space, and digital TV

Convolutional Codes for FEC

Unlike block codes, convolutional codes process data as a continuous stream:

• Encoded with a shift register (memory)
• Decoded with Viterbi algorithm (optimal) or sequential decoding
• Typical: rate 1/2, constraint length 7 — provides ~5 dB coding gain
• Used in 2G (GSM), WiFi, satellite communication

Turbo Codes: Near-Shannon Performance

Turbo codes (1993) achieved performance within 0.5 dB of Shannon capacity:

• Two parallel convolutional encoders separated by an interleaver
• Iterative soft-decision decoding
• After 8-10 iterations, approach theoretical limits
• Used in 3G (UMTS), 4G (LTE), and deep-space missions

LDPC Codes: The Modern Standard

Low-Density Parity-Check codes (Gallager, 1962, rediscovered in 1990s):

• Defined by a sparse parity-check matrix
• Decoded iteratively using belief propagation
• Can be designed to approach Shannon capacity within 0.1 dB
• Used in WiFi 802.11n/ac/ax, 5G NR, DVB-S2, 10GBASE-T Ethernet

Polar Codes: The Newest Addition

Polar codes (Arıkan, 2009) provably achieve Shannon capacity:

• Based on channel polarization principle
• Decoded with successive cancellation (list) decoding
• Adopted in 5G NR for control channels
• Computationally efficient for moderate block lengths

Concatenated Codes

Combining two codes in series provides very powerful FEC:

Serial concatenation: Outer code (e.g., Reed-Solomon) + Inner code (e.g., convolutional):

• Inner code corrects most random errors
• Outer code handles remaining burst errors after inner decoding
• Example: Voyager 2 uses rate 1/2 convolutional (inner) + RS(255,223) (outer)

Parallel concatenation (Turbo codes): Two convolutional codes with interleaver between them.

Hard Decision vs. Soft Decision FEC

Hard decision: Demodulator outputs definite 0/1 bits; decoder works with binary values. Soft decision: Demodulator outputs confidence levels (log-likelihood ratios); decoder exploits this extra information.

Soft-decision decoding gains 2-3 dB over hard-decision — like getting a "free" increase in coding gain simply by using better information from the demodulator.

Interleaving: Spreading Burst Errors

Most FEC codes work best against random (scattered) errors. Burst errors (consecutive corrupted bits from fading) can overwhelm any code. Interleaving solves this by rearranging bit order before transmission:

1. Write data into matrix by rows
2. Read out by columns (scrambles bit order)
3. Transmit column-by-column
4. Burst error corrupts consecutive transmitted bits
5. After de-interleaving: errors are scattered across many code words
6. FEC now easily corrects the distributed errors

Applications

Key Takeaways

1. FEC adds structured redundancy so the receiver can correct errors without retransmission — essential for broadcast, real-time, and deep-space links.
2. Coding gain measures the power savings FEC provides — typically 3-10 dB, equivalent to reducing required transmitter power by 2-10×.
3. Modern capacity-approaching codes (LDPC, Turbo, Polar) operate within 0.5 dB of Shannon's theoretical limit.
4. Soft-decision decoding provides 2-3 dB additional gain by exploiting demodulator confidence information.
5. Interleaving converts burst errors into scattered random errors that FEC can handle effectively.
6. The choice of FEC involves trade-offs between coding gain, complexity, latency, and code rate (throughput reduction).