Case Study: Codes in the Wild

Error-Control Strategies and Performance completed the tools for judging a code from the outside, which are its rate, its bit and word error rates at each noise level, its coding gain, and its place in a reliability budget counted in FIT. Distance, Detection and Correction supplied the guarantee underneath those numbers, that a code of minimum distance $d$ detects $d - 1$ errors, corrects $t = \lfloor (d-1)/2 \rfloor$, and handles $t$ errors and $e$ erasures together whenever $2t + e < d$.

The codes in those chapters were kept small on purpose, and no probe has sent pictures home from Neptune with them. This chapter visits eight systems in which codes carry real traffic, from the memories of early computers to the 5G radio in a phone. Each visit names the code, checks its numbers with the tools already built, and points ahead to the Part that teaches it.

None of the visits is a full treatment. A finite field appears here as 256 symbols with some arithmetic, and a convolutional code as a shift register with two outputs, both waiting for the Parts that define them. Meeting them early shows what problem each design answers, so that the algebra, when it comes, has a job to do.

Every number in the chapter is recomputed by ch10_case_study_codes_in_the_wild.py in the python/ folder of the companion repository ecc-book-lab, and the charts are drawn by ch10_charts.py in the same folder.

Table 1 lists the systems in order, with each code's rate and the Part that teaches it.

01.Parity in Early Memories

Take the byte 10110010. It holds four 1s, so an even-parity memory stores a ninth bit of 0 beside it and keeps the count of 1s in the nine bits even. If one bit flips while the byte sits in memory, the count becomes five, the check on the next read fails, and the hardware knows the byte is wrong. It does not know which bit is wrong, and if two bits flip the count is even again and the damage passes unseen.

That is the single parity code of Distance, Detection and Correction, with $n = 9$, $k = 8$ and $d = 2$, so it detects one error and corrects none. Many computers of the 1950s and 1960s kept such a bit beside each character or byte of memory and checked it on every read, and a failed check usually stopped the machine [1]. A 64-bit word stored as eight bytes then occupies 72 bits, a rate of $8/9 = 0.889$ and a check overhead of $8/64 = 12.5\%$.

How much protection that buys depends on how often bits flip. Suppose each of the $n$ bits of a group flips independently with probability $p$, as on the binary symmetric channel of Channels, Signals and Likelihoods.

Single parity raises an alarm exactly when the count is odd, with probability $1 - P_{\text{even}}$, and is silently wrong when the count is even but not zero, with probability $P_{\text{even}} - (1-p)^n$. For small $p$ the alarm rate is close to $np$ and the silent rate close to $\binom{n}{2} p^2$, the chance of exactly two flips. For a 9-bit group that is $9p$ against $36p^2$. A memory word of eight such groups raises an alarm about $72p$ times per read and fails silently about $8 \times 36 p^2 = 288 p^2$ times per read, and the worked example Byte Parity against SEC-DED in 72 Bits puts numbers on both.

Figure 1 shows the alternative that replaced it. The same 72 bits can hold 64 data bits and 8 check bits of a SEC-DED code, in which each check bit covers its own subset of the whole word rather than one byte. One flip is then located and corrected, and two are detected. The next section builds the idea from Hamming's original code, and Memory Codes after Hsiao returns to the 72-bit word. Part XI, ECC in Memory, Storage and Links, treats parity where it is still used, on buses, in caches and across links, wherever an alarm can simply trigger a retry.

02.Hamming's Code at Bell Labs

Richard Hamming's 1950 paper [1] starts from large computing machines, in which a single failure can stop or spoil a long computation. Parity could only stop the machine. Hamming asked for check bits that would also say where the error was, and his answer for four data bits is still the first code most students meet.

Number seven bit positions from 1 to 7. The data bits $d_3, d_5, d_6, d_7$ go in positions 3, 5, 6 and 7, and check bits go in positions 1, 2 and 4, the powers of two. Each check bit is the XOR of the data bits whose position, written in binary, has a 1 where the check bit's position does, so $p_1 = d_3 \oplus d_5 \oplus d_7$, $p_2 = d_3 \oplus d_6 \oplus d_7$ and $p_4 = d_5 \oplus d_6 \oplus d_7$.

For the data 1011, $d_3 = 1$, $d_5 = 0$, $d_6 = 1$ and $d_7 = 1$, so $p_1 = 1 \oplus 0 \oplus 1 = 0$, $p_2 = 1 \oplus 1 \oplus 1 = 1$ and $p_4 = 0 \oplus 1 \oplus 1 = 0$. The codeword, read from position 1 to position 7, is 0110011. Suppose the channel flips position 5, so 0110111 arrives. The receiver lists the positions that hold a 1, which are 2, 3, 5, 6 and 7, and XORs them in binary, $010 \oplus 011 \oplus 101 \oplus 110 \oplus 111 = 101$. The result, called the syndrome, is 5 in binary, and flipping position 5 back restores the codeword.

The same bookkeeping gives the minimum distance. If two words each have position-XOR 0, so does their bitwise XOR, because a position where both words hold a 1 drops out of the combined list and also cancels between the two separate XORs. The code is therefore closed under addition, so the distance between codewords $c$ and $c'$ is the weight of the codeword $c \oplus c'$, and the minimum distance is the least weight of a nonzero codeword. Listing all 16 codewords gives one of weight 0, seven of weight 3, seven of weight 4 and one of weight 7, so $d = 3$ and the code corrects one error, as Distance, Detection and Correction promised for $d = 3$.

Figure 2 shows what that buys. Four data bits sent bare over $\text{BSC}(p)$ fail with probability $1 - (1-p)^4$, which is 0.0394 at $p = 0.01$. The Hamming code fails only when two or more of its seven bits flip, with probability

which is 0.00203 at $p = 0.01$, 19.4 times smaller. Three-fold repetition of each data bit does slightly better, 0.00119, but spends 12 bits rather than 7, a rate of 0.333 against 0.571. Both coded curves fall with slope 2 on the logarithmic axes, because both need two flips in the wrong places to fail.

Why seven bits? With $r$ check bits the syndrome takes $2^r$ values. One value must mean no error, and each of the $n = k + r$ positions needs its own value so that a single error can be located, so

Three check bits allow $k + 3 + 1 \le 8$, so $k \le 4$, and the $(7,4)$ code meets the bound with nothing to spare, which Part II will call a perfect code. Seven check bits protect up to $2^7 - 1 - 7 = 120$ data bits, while six protect only $2^6 - 1 - 6 = 57$, so a 64-bit word needs seven. One further bit holding the parity of all the others turns every codeword of odd weight into one of even weight. The XOR of two even-weight words has even weight, so every distance is now even, and since it was at least 3 it becomes at least 4. That extended code corrects one error and detects two, and with $64 + 7 + 1 = 72$ bits it fits the same 72 bits as byte parity. Part II, Linear Block Codes, develops these codes and the bound in full.

03.The Mariner Reed–Muller Code

In 1969 the probes Mariner 6 and Mariner 7 flew past Mars and sent pictures home over a high-rate channel of 16,200 bits per second [2]. The data were cut into 6-bit pieces, and each piece was sent as one of 64 codewords of 32 bits.

The codewords are easiest to see as functions. Number the 32 positions $x = 0, 1, \ldots, 31$ and write each position in binary as $x_5 x_4 x_3 x_2 x_1$, with $x_1$ the lowest bit. A message is six bits $a_0, a_1, \ldots, a_5$, and the codeword bit at position $x$ is

With only $a_1 = 1$, the bit at $x$ is $x_1$, which alternates, so the codeword begins 01010101. With only $a_2 = 1$, it begins 00110011. Over the full 32 positions those two words differ in 16 places, and that is no accident.

The sum of two such functions is again one of them, so the code is closed under addition, and as in Hamming's Code at Bell Labs the minimum distance is the least nonzero weight, $d = 16$. The code corrects $t = 7$ errors in 32 bits at a rate of $6/32 = 0.1875$. It is the first-order Reed–Muller code of length 32, from the papers of Reed and of Muller in 1954 [3] [4], and the JPL engineers called it biorthogonal. Written with $+1$ for a 0 and $-1$ for a 1, the 32 codewords with $a_0 = 0$ are mutually orthogonal vectors, since two of them differ in 16 places and agree in 16, and the other 32 codewords are their negatives.

Orthogonality is what makes decoding practical. A receiver can correlate the 32 received signal values against each of the 32 orthogonal patterns, take the pattern with the largest correlation in size, and read $a_0$ from its sign.

Tausworthe, Easterling and Spear put the saving in decibels. At the system's operating error rate, uncoded transmission would have needed $E_b/N_0 = 5.20$ dB, while the coded system needed 3.00 dB. In the language of Error-Control Strategies and Performance that is a coding gain of 2.20 dB, a factor of $10^{0.22} = 1.66$ in transmitter power. Uncoded BPSK at 5.20 dB has bit error probability $Q\bigl(\sqrt{2E_b/N_0}\bigr) = 5 \times 10^{-3}$, which locates that operating point.

Figure 3 shows the same code with hard decisions on $\text{BSC}(p)$, where a decoder that corrects up to 7 errors fails only on 8 or more,

At $p = 0.05$ that is 0.000139, against 0.2649 for the 6 bits sent bare and 0.00693 for five-fold repetition in 30 bits, which The Mariner Code against Five-Fold Repetition works out. Part II teaches Reed–Muller codes of every order with their fast Hadamard decoder, and Part VI explains why correlating soft values beats deciding each bit first.

04.Voyager and Concatenated Codes

The two Voyager probes, launched in 1977, flew past Jupiter and Saturn, and Voyager 2 went on to Uranus and Neptune [5]. Received power falls with the square of distance, so each encounter was harder to hear than the last, and the coding changed along the way.

The inner code throughout was a convolutional code of constraint length 7 and rate 1/2. Each data bit enters a 7-bit shift register, and two output bits are formed as the parities of the register under two masks, 1111001 and 1011011, written in octal as 171 and 133. A single 1 entering an empty register, followed by zeros, produces the 14 output bits 11 10 11 11 00 01 11, of weight 10. No input that leaves the all-zero register state and returns to it produces a lighter output, so the code's free distance, the convolutional counterpart of minimum distance, is 10. The ground decoded it with Viterbi's algorithm [6], which works on soft decisions and, when it errs, tends to err in short bursts.

At Jupiter and Saturn an outer Golay code sat around the convolutional code [5], giving an overall rate of $1/2 \times 1/2 = 0.25$. For Uranus and Neptune the outer code became a Reed–Solomon code [7], RS$(255,223)$, from an experimental encoder on board. Its symbols are bytes, treated as elements of a field of 256 elements that Part III builds. Each codeword holds 223 data bytes and 32 check bytes, a rate of 0.875 and a check overhead of $32/223 = 14.3\%$. Its minimum distance is $n - k + 1 = 33$, the most any code of that length and dimension can have, as Part V proves, so it corrects 16 wrong bytes in each codeword. A Viterbi burst a few bits long usually lands in one or two bytes, so a byte code counts it as one or two errors rather than many. The overall rate is

Bursts longer than a byte or two are handled by interleaving. With interleaving depth $I$, the encoder fills $I$ Reed–Solomon codewords and sends their bytes in rotation, one from each codeword in turn, so neighboring bytes on the channel belong to different codewords. A burst of $b$ consecutive bytes then contains at most $\lceil b/I \rceil$ bytes of any one codeword, since that codeword's bytes sit $I$ apart. Each codeword survives while $\lceil b/I \rceil \le 16$, that is while

At depth 5 a burst of 80 bytes, 640 bits, is cleared, and at depth 8 one of 128 bytes, 1,024 bits. Figure 4 draws the whole chain.

Ludwig and Taylor report what the outer code bought. A Viterbi output with a bit error rate of about $5 \times 10^{-3}$ left the Reed–Solomon decoder at about $10^{-6}$. A Reed–Solomon decoder also nearly always knows when it has failed. McEliece and Swanson showed [8] that when a codeword carries more errors than the decoder can correct, the chance that it decodes to a wrong codeword rather than reporting failure is less than $1/t!$, which for $t = 16$ is $1/16! = 4.78 \times 10^{-14}$, and they computed it for this code as below $3 \times 10^{-14}$. A link whose words fail at $10^{-5}$ therefore hands on a wrong word without a flag at a rate below $3 \times 10^{-19}$.

This chain, Reed–Solomon outside, interleaver, convolutional code inside, became the CCSDS standard for deep-space telemetry [9], which allows interleaving depths up to 8 and a lighter RS$(255,239)$ of rate 0.937. Part VII builds the inner code, Part V the outer one, and Part VI explains why a soft inner decoder and a hard outer one pair so well.

Table 2 follows the downlink rate through Voyager 2's four encounters, from Table 6-1 of Ludwig and Taylor. The expected rates scale Jupiter's 115,200 bits per second by the drop in received power the table gives, factors of 1/4, 1/13 and 1/36, which is 28,800, 8,862 and 3,200 bits per second, rounded in the table to about 29,000 and 9,000 for the first two. The achieved rates were 1.5, 3.3 and 6.8 times the expected rates in the table. Saturn had the same code and ground antennas as Jupiter, and Ludwig and Taylor credit its gain to the set of rates available and to differences in priorities and margins, calling the comparison approximate. At Uranus and Neptune two things changed together. The Reed–Solomon code replaced the Golay code, and the ground antennas were enlarged and arrayed so that their signals could be added, so the larger factors belong to both, as Figure 5 notes. The worked example Voyager's Expected Rates checks the factors against the distances.

05.The Compact Disc

Philips and Sony launched the compact disc in 1982 [10], and its error correction had to survive what listeners do to discs, fingerprints, dust and scratches. Those do not flip scattered bits. They wipe out a stretch of track, and with it every bit in a run of consecutive frames.

Stereo audio at 44,100 samples per second per channel, with 16 bits per sample, is $44{,}100 \times 16 \times 2 = 1{,}411{,}200$ bits per second, or 176,400 bytes. The disc groups six stereo samples, 24 bytes, into a frame. The error-correcting encoder adds 8 check bytes, making 32, so its rate is $24/32 = 0.75$. A control byte joins them, each byte becomes 14 channel bits plus 3 merging bits under the modulation called EFM, and a 24-bit synchronization pattern with its 3 merging bits starts the frame, $27 + 17 + 32 \times 17 = 588$ channel bits in all [11]. At 7,350 frames per second the disc delivers 4,321,800 channel bits per second, of which only $192/588 = 32.7\%$ are audio.

Figure 6 shows the encoder, called cross-interleaved Reed–Solomon coding, or CIRC. The 24 audio bytes enter the C2 encoder, RS$(28,24)$, which adds 4 bytes. The 28 bytes then pass through delay lines, byte $i$ held back by $4i$ frames, from 0 up to 108. The C1 encoder, RS$(32,28)$, adds 4 more bytes across each outgoing frame. Both codes have $d = n - k + 1 = 5$. The two codes see the data in different arrangements, C1 across the 32 bytes of one outgoing frame, and C2 across bytes taken from 28 different frames.

The player runs the two codes in reverse. The C1 decoder checks each frame, corrects small damage, and when a frame looks badly hit it marks all of that frame's bytes as erasures. After the delays are undone, each C2 codeword is gathered from 28 frames spread 4 apart over 109 frames.

Distance, Detection and Correction showed that a code of distance $d$ fills $e$ erasures whenever $e < d$, so C2 fills up to 4. A burst is therefore survivable while $\lceil B/4 \rceil \le 4$, that is up to $B = 16$ frames, which is $16/7{,}350 = 2.18$ ms of music and, at the disc's track speed of 1.2 to 1.4 m/s, 2.6 to 3.0 mm of track. Figure 7 draws the staircase. The real encoder also delays alternate bytes by one frame after C1, which splits a short burst between two C1 words, and before C2 delays and reorders audio bytes by two frames, which helps the player conceal what it cannot correct [11]. This model leaves both out. Part IV treats bursts and interleavers in general, and Part V decodes errors and erasures together.

06.QR Codes

A QR code is a grid of dark and light squares called modules. The smallest, version 1, is $21 \times 21 = 441$ modules, and each version adds 4 to the side, so version $v$ is $17 + 4v$ modules wide, 57 for version 10 and 177 for version 40, the largest [12]. In version 1 the three finder squares in the corners with their light borders, the timing lines between them, the format information and one fixed dark module use 233 modules, leaving 208 for data, which is 26 codewords of 8 bits.

Those 26 codewords form one Reed–Solomon codeword over bytes. The maker of the symbol picks one of four error-correction levels, L, M, Q and H, which split the 26 into data and check codewords as Table 3 shows [13]. A Reed–Solomon code with $n - k$ check symbols has minimum distance $n - k + 1$, as Part V proves, so by the rule $2t + e < d$ of Distance, Detection and Correction it handles $t$ errors and $e$ erasures together whenever

Level M, for example, uses 16 data codewords and 10 check codewords, a rate of $16/26 = 0.615$. Ten check codewords could correct 5 wrong codewords at unknown places, or fill 10 at known places, though in version 1 the standard reserves part of that, so 1-M corrects 4.

DENSO WAVE, which created the QR code, rates the four levels as restoring about 7, 15, 25 and 30 percent of codewords [14]. The bound $\lfloor (n-k)/2 \rfloor$ gives 11.5, 19.2, 23.1 and 30.8 percent of 26. The ratings are approximate figures meant for every version. In its smallest symbols the standard holds a few check codewords back to guard against decoding to a wrong message, 3 at level L, 2 at M and 1 at Q and H in version 1, so version 1 corrects $(7-3)/2 = 2$ codewords at level L and $(10-2)/2 = 4$ at level M, which are $7.7\%$ and $15.4\%$ [13]. At level Q it corrects 6, which is $6/26 = 23.1\%$, a little below the rated 25%. That reserve makes the decoder report failure rather than guess wrong.

Larger versions split their codewords into several Reed–Solomon blocks and interleave the blocks' bytes across the symbol, so a smudge in one corner is shared among blocks rather than concentrated in one, the same defense as the compact disc's delay lines. The room left for a message follows from the data codewords. In byte mode a 4-bit mode indicator and an 8-bit character count come first, so version 1 at level M carries $\lfloor (128 - 12)/8 \rfloor = 14$ bytes. Part V builds these codes and their decoders, and Part III, Finite Fields and Their Arithmetic, the byte arithmetic under them.

07.Memory Codes after Hsiao

A SEC-DED code is easiest to describe by its check matrix $H$, with one row per check bit and one column per stored bit. Column $j$ is the syndrome that a single flip at position $j$ produces, as the binary number $j$ was for Hamming's code. Correcting one error needs the 72 columns to be distinct and nonzero. Detecting two needs the XOR of any two columns to be neither zero nor equal to a column, so that a double error is never mistaken for a single one.

In 1970 M. Y. Hsiao of IBM proposed choosing every column with an odd number of 1s [15].

For 64 data bits and 8 check bits Hsiao's recipe takes the 8 columns of weight 1 for the check bits themselves, all $\binom{8}{3} = 56$ columns of weight 3, and 8 columns of weight 5, which makes 72. The matrix holds 216 ones, exactly 27 in each row. Each syndrome bit is therefore the XOR of 27 bits, which a tree of two-input XOR gates finishes in $\lceil \log_2 27 \rceil = 5$ levels. The extended Hamming code of Hamming's Code at Bell Labs, built from the lightest columns that work, needs 258 ones, because its overall parity row covers all 72 bits and takes $\lceil \log_2 72 \rceil = 7$ levels. Hsiao's matrix saves 42 ones, 16%, and two gate levels on the slowest path, which matters because the check runs on every read from memory. The same recipe gives a $(39,32)$ code for 32-bit words with 103 ones.

Codes of this kind became the usual protection for server memory, which stores each 64-bit word in 72 bits [15], as Figure 1 showed. Field studies have since found memory errors in large server fleets to be far more common than laboratory estimates suggested [16], which pushed designs beyond single-bit correction toward codes that survive the loss of a whole memory chip. Part II derives the extended Hamming and Hsiao codes, and Part XI, ECC in Memory, Storage and Links, follows memory protection from there.

08.5G New Radio

The 5G New Radio standard, 3GPP TS 38.212 [17], uses three families of codes. User data travel in low-density parity-check (LDPC) codes, introduced by Gallager in 1962 [18]. Control messages use polar codes, introduced by Arıkan in 2009 [19], with mother codes of length up to 512 on the downlink and 1,024 on the uplink. The shortest control messages, 3 to 11 bits, use a $(32,K)$ block code, and blocks that fail are resent under hybrid ARQ.

An NR LDPC code is built from a small base graph, a matrix of 0s and 1s, by replacing each 1 with a $Z_c \times Z_c$ identity matrix whose columns are cyclically shifted, and each 0 with a block of zeros. The lifting size $Z_c$ comes from the 51 values $a \cdot 2^j \le 384$ with $a$ in $\{2, 3, 5, 7, 9, 11, 13, 15\}$, from 2 to 384, so one pair of base graphs serves blocks of almost any size. Base graph 1 has 22 information columns and serves code blocks up to $22 \times 384 = 8{,}448$ bits at a lowest rate of $22/66 = 1/3$. Base graph 2 has 10 information columns, serves blocks up to 3,840 bits, and reaches rate $10/50 = 1/5$. The denominators are 66 and 50 rather than the full widths of the graphs because the first $2Z_c$ information bits are never sent.

A transport block of $A$ bits first gains a CRC, 16 bits when $A \le 3{,}824$ and 24 bits above that, giving $B$ bits. Base graph 2 is chosen for small blocks and low rates, when $A \le 292$, or $A \le 3{,}824$ with code rate $R \le 0.67$, or $R \le 0.25$, and base graph 1 otherwise. The lifting size is the smallest $Z_c$ with $K_b Z_c \ge B$, where $K_b$ is 22 for base graph 1 and between 6 and 10 for base graph 2 depending on $B$. The code block then holds $22 Z_c$ or $10 Z_c$ bits, the shortfall filled with zero bits that the decoder knows and the transmitter never sends.

After encoding, the $N = 66 Z_c$ or $50 Z_c$ coded bits sit in a circular buffer, drawn in Figure 8. Each transmission reads its bits clockwise from a starting point set by its redundancy version $rv$, wrapping past the end. For base graph 2, with a buffer of $N_{cb}$ bits, the start is

which for the full buffer, $N_{cb} = 50 Z_c$, is simply $0$, $13Z_c$, $25Z_c$ and $43Z_c$. Base graph 1 uses 17, 33 and 56 over 66 in the same way. A first transmission at rv0 sends mostly information bits and the first parity bits. If the receiver fails and asks again, the next version starts elsewhere and brings parity the receiver has not seen, and the receiver combines both transmissions into one stronger code of lower rate. That is the type-II hybrid ARQ, or incremental redundancy, of Error-Control Strategies and Performance. Parts IX and X build LDPC and polar codes and their decoders.

The $(32,K)$ code for the shortest messages is defined by a table of 11 basis sequences of length 32. Its first sequence is all 1s, and across the 32 positions the next five take all 32 patterns of five bits. For $K = 6$ the code is therefore the set of words $a_0 \oplus a_1 x_1 \oplus \cdots \oplus a_5 x_5$ with the positions in another order, the code of The Mariner Reed–Muller Code again, with $d = 16$. Adding basis sequences to carry more bits lowers the distance to 12 for $K = 7$ to 10, and to 10 for $K = 11$. A code that carried pictures from Mars in 1969 thus carries a phone's shortest control messages in the 5G standard.

09.Looking Ahead

Each of the eight designs matched its code to the errors it expected. Memories with rare, independent flips moved from parity to a SEC-DED code chosen for speed. Deep-space links paired a soft inner decoder with a byte-level outer code and spread the bursts between them. The compact disc and the QR code expect damage in patches and answer with Reed–Solomon codes over bytes and with interleaving, and 5G adapts its code to the block size and the channel with every transmission. Every number in the chapter followed from the tools of the first Part, distance, the binomial tail, coding gain and erasures, while the codes themselves were taken on trust.

The next chapter stops taking error rates on trust. It builds a channel simulator in Python for the binary symmetric, erasure and Gaussian channels, runs repetition and parity codes through it, and checks the measured error rates and their confidence intervals against the closed forms of the earlier chapters. The chapter after it puts a parity generator and checker into hardware. Part II then opens the first family met here, linear block codes, starting from the Hamming codes of Hamming's Code at Bell Labs.

10.Worked Examples

11.Exercises

References

1. [1]Hamming, Richard W. (1950). “Error Detecting and Error Correcting Codes.” Bell System Technical Journal, 29(2), pp. 147–160. doi:10.1002/j.1538-7305.1950.tb00463.x
2. [2]Tausworthe, Robert C. and Easterling, Mahlon F. and Spear, A. J. (1969). “A High-Rate Telemetry System for the Mariner Mars 1969 Mission.” JPL Technical Report 32-1354 (NASA-CR-100550), Jet Propulsion Laboratory. https://ntrs.nasa.gov/citations/19690012788
3. [3]Reed, Irving S. (1954). “A Class of Multiple-Error-Correcting Codes and the Decoding Scheme.” Transactions of the IRE Professional Group on Information Theory, 4(4), pp. 38–49. doi:10.1109/TIT.1954.1057465
4. [4]Muller, David E. (1954). “Application of Boolean Algebra to Switching Circuit Design and to Error Detection.” Transactions of the IRE Professional Group on Electronic Computers, EC-3(3), pp. 6–12. doi:10.1109/IREPGELC.1954.6499441
5. [5]Ludwig, Roger and Taylor, Jim (2002). “Voyager Telecommunications.” DESCANSO Design and Performance Summary Series, Article 4, Jet Propulsion Laboratory. March 2002. https://descanso.jpl.nasa.gov/DPSummary/Descanso4--Voyager_new.pdf
6. [6]Viterbi, Andrew J. (1967). “Error Bounds for Convolutional Codes and an Asymptotically Optimum Decoding Algorithm.” IEEE Transactions on Information Theory, 13(2), pp. 260–269. doi:10.1109/TIT.1967.1054010
7. [7]Reed, Irving S. and Solomon, Gustave (1960). “Polynomial Codes over Certain Finite Fields.” Journal of the Society for Industrial and Applied Mathematics, 8(2), pp. 300–304. doi:10.1137/0108018
8. [8]McEliece, Robert J. and Swanson, Laif (1986). “On the Decoder Error Probability for Reed-Solomon Codes.” TDA Progress Report 42-84, Jet Propulsion Laboratory. Covers October to December 1985. https://ntrs.nasa.gov/citations/19860013319
9. [9]Consultative Committee for Space Data Systems “TM Synchronization and Channel Coding.” CCSDS 131.0-B-5, Blue Book. Issue 5. https://public.ccsds.org/Pubs/131x0b5.pdf
10. [10]Immink, Kees A. Schouhamer (1998). “The Compact Disc Story.” Journal of the Audio Engineering Society, 46(5), pp. 458–465. https://www.aes.org/e-lib/browse.cfm?elib=12144
11. [11]Ecma International (1996). “Data Interchange on Read-Only 120 mm Optical Data Disks (CD-ROM).” Standard ECMA-130, 2nd edition. https://ecma-international.org/publications-and-standards/standards/ecma-130/
12. [12]DENSO WAVE “Information Capacity and Versions of the QR Code.” QRcode.com. Read 2026-11-14. https://www.qrcode.com/en/about/version.html
13. [13]ISO/IEC (2015). “Information Technology, Automatic Identification and Data Capture Techniques, QR Code Bar Code Symbology Specification.” ISO/IEC 18004:2015. https://www.iso.org/standard/62021.html
14. [14]DENSO WAVE “Error Correction Feature.” QRcode.com. Read 2026-11-13. https://www.qrcode.com/en/about/error_correction.html
15. [15]Hsiao, M. Y. (1970). “A Class of Optimal Minimum Odd-weight-column SEC-DED Codes.” IBM Journal of Research and Development, 14(4), pp. 395–401. doi:10.1147/rd.144.0395
16. [16]Schroeder, Bianca and Pinheiro, Eduardo and Weber, Wolf-Dietrich (2009). “DRAM Errors in the Wild: A Large-Scale Field Study.” In Proceedings of the Eleventh International Joint Conference on Measurement and Modeling of Computer Systems (SIGMETRICS '09), pp. 193–204. doi:10.1145/1555349.1555372
17. [17]3GPP (2017). “NR; Multiplexing and Channel Coding.” 3GPP Technical Specification 38.212. First issued in Release 15; later releases revise it. https://www.3gpp.org/dynareport/38212.htm
18. [18]Gallager, Robert G. (1962). “Low-Density Parity-Check Codes.” IRE Transactions on Information Theory, 8(1), pp. 21–28. doi:10.1109/TIT.1962.1057683
19. [19]Arikan, Erdal (2009). “Channel Polarization: A Method for Constructing Capacity-Achieving Codes for Symmetric Binary-Input Memoryless Channels.” IEEE Transactions on Information Theory, 55(7), pp. 3051–3073. doi:10.1109/TIT.2009.2021379