Bounds on Codes
November 16, 202652 min readbeginner
Fifteen wires, every pair of words at distance d. How many words fit? The chapter proves the Hamming, Singleton, Plotkin, Griesmer and Gilbert–Varshamov bounds, states the Elias bound and tests them on real codes.
Most chapters of this part built codes. This chapter asks instead what no construction can ever produce.
Picture a designer with 15 wires. Each clock cycle the wires carry one 15-bit word, and the receiver has to tell the allowed words apart even after some wires flip. If every two allowed words differ in at least positions, the receiver can correct up to flipped wires, as Distance, Detection and Correction showed. More allowed words carry more data, so the designer wants as many as possible. How many can 15 wires hold at distance 3, at distance 5, or at distance 9?
An upper bound proves that no code, however clever, has more words than some number. A lower bound proves that some code has at least some number of words, sometimes without naming the code. When an upper bound meets a code someone has built, the search at that length and distance is over. The chapter proves five bounds, states a sixth, and evaluates all of them at length 15 beside the codes that earlier chapters built.
Every number in the chapter is recomputed by ch27_bounds_on_codes.py in the python/ folder of the companion repository ecc-book-lab, and the charts are drawn by ch27_charts.py in the same folder. The GNU Octave twin ch27_bounds_on_codes.m prints the same lines, as The Octave Route explains.
01.Fifteen Wires and a Distance
Start with what the earlier chapters already supply at length 15. The Hamming code of Hamming Codes and Perfect Codes has codewords at distance 3. The even-weight code, every word with an even number of ones, has codewords at distance 2. The repetition code has 2, the all-zeros word and the all-ones word, at distance 15. Between these the earlier chapters say little. Is there a code of length 15 with distance 5 and 256 codewords? One with distance 9 and 8 codewords? Trying every set of words is hopeless, since there are words to choose from and far more sets of them.
Two arguments drive almost every bound in the chapter, and Figure 1 draws both on a grid where the distance between two dots is the number of steps between them. On the left the codewords sit three steps apart, so a ball of radius one step around each of them, the codeword together with its neighbors, never touches another ball. Counting the words inside the balls caps how many codewords there can be, which is a packing argument. On the right no further dot can join the code without coming within two steps of a codeword, so balls of radius two steps reach every dot. Counting again shows that the code cannot be too small, which is a covering argument.
Some bounds speak about every code and some only about linear codes, and the difference between the two already matters at length 8.
02.The Largest Code for a Length and a Distance
A linear code of dimension has codewords, so every linear code of length and distance at least shows that . The chapter writes with square brackets when the question is whether a linear code with those parameters exists at all, and keeps for codes already built.
Proof. Two different words differ in at least one position, so all words together form a code of distance 1. Two words at distance differ in every position, the first included, so the codewords of a code of distance all have different first symbols and there are at most of them. The words that repeat one symbol times reach that number. For distance 2, delete the last position from every codeword of a binary code. Two codewords that became equal would have differed only in that position, at distance 1, which the code forbids. So the shortened words are distinct words of length and number at most . The even-weight code reaches that number. Its first bits are free and the last bit makes the count of ones even, and two even-weight words cannot differ in exactly one position, since flipping one bit changes the parity.
Modifying and Combining Codes extended a linear code by an overall parity bit and punctured one by deleting a position. The same two moves work for any binary code, linear or not, and together they tie each odd distance to the even distance above it.
Proof. Take a binary code of length and distance , and append to each codeword the XOR of its bits. Every extended word has even weight. The distance between two words and equals , where has a 1 exactly where both and do, so the distance between two even-weight words is even. Appending a bit never lowers a distance, so two extended codewords lie at an even distance of at least the odd number , which means at least . That gives . In the other direction, delete the last position of every codeword of a code of length and distance . Each distance drops by at most 1, so the words stay distinct and lie at distance at least , which gives .
A few small values follow from a bound and a code that meets it. At length 5 the four words 00000, 10101, 01111 and 11010 lie at distance at least 3 from one another, and the XOR of any two of them is a third, so they form a linear code. At length 6 the shortened Hamming code with generator rows 100011, 010101 and 001110 has 8 codewords at distance 3, and at length 7 the Hamming code has 16. Upper bounds proved later in the chapter show that none of the three can grow, the Plotkin bound for the first two and the Hamming bound for the third. So , and .
Length 8 breaks the pattern, because there a nonlinear code beats every linear one. The extended Hamming code has 16 codewords at distance at least 3, and no linear code does better, because an code would put disjoint balls of radius 1, each holding words, into a space of words, and . Yet a nonlinear code of length 8 with 20 codewords at distance 3 exists. The script stores one, found by a computer search, and checks all 190 pairs of its words. Proving that 21 words cannot fit takes heavier tools than this chapter's. The table of Best, Brouwer, MacWilliams, Odlyzko and Sloane [1] and Brouwer's online table of small binary codes [2] list even distances only, and record the value as , which the extension identity turns into .
03.The Hamming Bound Again
The packing argument of Figure 1 is the oldest bound of all [3], and Hamming Codes and Perfect Codes proved it in the section The Sphere-Packing Bound.
Proof. The balls of radius around the codewords are disjoint, each holds words, and together they fit inside the words of the space, as The Sphere-Packing Bound in Hamming Codes and Perfect Codes showed.
For binary words of length 15 the ball sizes for from 0 to 7 are 1, 16, 121, 576, 1941, 4944, 9949 and 16384. A distance allows , so distances 3 and 4 share the ball of radius 1, distances 5 and 6 the ball of radius 2, and so on. Dividing by the ball and taking the largest power of 2 at or below the result gives the largest dimension a linear code could have. It is 11 at and 4, 8 at and 6, 5 at and 8, 4 at and 10, 2 at and 12, and 1 from there to 15. At the ball has radius 0 and the bound allows , the whole space, which is no help at all.
The bound is sharp at small distances and loose at large ones. At the Hamming code meets it exactly, since . At it allows 6 codewords where only 2 fit, as a worked example at the end shows, because at large distances the limit is not room for balls but the difficulty of keeping many words far apart at once.
04.The Singleton Bound
The next bound needs no balls at all. Delete the same positions from every codeword. Two codewords differ in at least positions, so at least one of their differences survives the deletion, and the shortened words are still all different. Figure 2 does this for the Hamming code. Its 16 codewords, cut down to their first five bits, are 16 different words of length 5.
Proof. Deleting the same positions from every codeword leaves words of length . Two codewords that agreed on all the remaining positions would differ in at most the deleted ones, which contradicts distance . So the shortened words are distinct, and only words of that length exist. For a linear code , and comparing exponents gives .
The bound carries the name of Singleton [4]. At length 15 it allows , which runs from 14 at down to 1 at . The even-weight code and the repetition code meet it. The Hamming code does not, since , and in Figure 2 its 16 shortened words fill only half of the 32 words of length 5.
Proof. Linear Codes showed that row reduction, with the positions reordered where needed, puts a generator matrix in the systematic form , where is the identity matrix and has columns. Reordering positions changes no distance. Row of is a codeword with a single 1 in its identity part, so its part in must hold at least ones. That part has only positions, so every row of is all ones. If , the single row is the all-ones word and the code is the repetition code. If , add rows 1 and 2. Their parts in cancel, and the sum has exactly two ones, so . Then , which leaves with , where every row has weight 2 and the code is the even-weight code, or with , the whole space.
Over larger alphabets the picture changes completely, and Reed–Solomon Codes builds a whole family of MDS codes that are far from trivial.
05.The Plotkin Bound
When the distance is more than half the length, a direct count of distances beats every ball argument. Plotkin found it [5]. Take the code from above and add up the distance between every ordered pair of different codewords, counting each pair twice, once in each order. There are ordered pairs, each at distance at least 3, so the total is at least 36. Now count the same total a second way, one position at a time. A position where of the codewords hold a 1 separates each of those from each of the other , in both orders, so it adds to the total. Figure 3 shows that every position of the code holds exactly two ones, so each adds and the total is exactly 40. The product is largest at , where it equals , so with four codewords no position can ever add more than 8.
Proof. The left side counts the ordered pairs of different codewords, each at distance at least . The middle sum counts the same distances position by position, since a position with ones adds 1 to the distance of exactly ordered pairs. The right inequality uses , which holds because . Dividing by gives , so , and since , dividing by it gives the bound.
The count can be sharpened, because is a whole number, and so is whenever is even.
Proof. Write , and note that because . If is even, the Plotkin bound gives , so the whole number is at most and therefore at most . If , then . If is odd and at least 3, then is largest at , so . The count becomes , and dividing by gives , so and . A whole number at most is at most , and , so again.
Odd distances do better still through the extension identity, which raises and together, as the first worked example shows at length 5. In the same way , which the shortened Hamming code meets.
When the denominator vanishes and the bound says nothing, but one more step recovers it.
Proof. Take a binary code of length and distance with codewords. In the first position one of the two bit values is held by at least codewords. Keep those, which agree in that position, and delete it, which is the shortening of Modifying and Combining Codes applied to the majority value. Their distances are unchanged, so they form a code of length and distance , and . The sharpened bound gives , so .
At length 15 the Plotkin bound applies from on. The plain form gives 16, 6 and 4 codewords at , 9 and 10. The sharpened form with the extension identity gives 16, 4, 4, 2, 2, 2, 2 and 2 for from 8 to 15, where the value 4 at comes from . At the bound is met by the simplex code, the dual of the Hamming code, whose 15 nonzero codewords all have weight 8, by the argument that proves the constant-weight theorem of Linear Codes for length 7. So . An exercise at the end carries the bound to lengths of at least twice the distance.
Over symbols the same double count works with one change.
Proof. In one position let be the number of codewords holding the symbol , so that the numbers add up to . The ordered pairs that differ there number . Expanding gives , an instance of the Cauchy–Schwarz inequality, so each position adds at most . The double count becomes , so and , which gives the bound because .
For , and the bound reads , the binary form again.
06.The Griesmer Bound
The Singleton bound deletes positions and keeps every codeword. The Griesmer bound deletes positions, chosen with care, and loses only one dimension each time. It holds only for linear codes. Griesmer proved it for binary codes [6], and the form over symbols given here follows Huffman and Pless [7].
Pick a codeword of minimum weight in a linear code over symbols. Multiplying the symbols in one position of every codeword by a fixed nonzero constant changes no weight, so the code may be rescaled position by position until holds the symbol 1 wherever it is nonzero. A binary code needs no rescaling. Reorder the positions so that the ones of come first, and write a generator matrix with as its first row, as Figure 4 draws. The block under the zeros of is what remains after deleting the columns where is nonzero.
Proof. Rescaling a position and reordering positions change no weight, so the proof may assume, as above, that holds 1 in its first positions and 0 elsewhere. Deleting positions is linear, so the result is a linear code of length . A codeword that becomes 0 under the deletion is zero outside the support of . If , its weight of at least must sit inside those positions, so it is nonzero in every one of them. Let be its symbol in the first. Then is a codeword that is zero outside the support of and zero in that first position, so its weight is below and it must be 0. Thus , and exactly the multiples of become 0. Each word of the residual code is therefore the image of exactly codewords, so the residual code has words and dimension . For the distance, take a nonzero residual word , the image of a codeword whose part sits on the support of . Let be the all-ones word of length . For every symbol , the word is a nonzero codeword, so . Add these inequalities. In each of the positions of exactly one matches the symbol there, so the weights add up to and the sum reads . Hence , and since a weight is a whole number, .
Proof. Induct on . For the sum is , and a nonzero codeword of weight at least needs positions. For the residual code is an code with , so by induction . A whole number satisfies exactly when , because is itself a whole number, so the smallest such is the same on both sides and . The sum is therefore , and adding to both sides gives the bound.
For binary codes the sum halves the distance again and again, rounding up each time. The Hamming code needs positions and has exactly 7. The extended Hamming code needs , the simplex code , the and first-order Reed–Muller codes 16 and 32, and the code of the section Real Codes at Length 15 needs . All six meet the bound with equality. Other good codes fall short by one position. The Hamming code would fit in 14 positions by this count, and so would the code.
The Golay codes show that the Hamming bound and the Griesmer bound measure different things. The Golay code is perfect, since , yet its Griesmer sum is 7, 4 and 2 followed by nine 1s, 22 in all, and the extended Golay code sums to 23, each one short of its length. A perfect code wastes no word of the space, and a code that meets the Griesmer bound wastes no position.
At length 15 the Griesmer bound allows the largest dimensions 14, 12, 11, 8, 7, 5, 4, 2 and 2 for from 2 to 10, and 1 for every distance from 11 to 15. It is weaker than the Hamming bound only at , where it allows 12 against 11. It matches the Hamming bound at , 5 and 7 and from 13 on, and is stronger at the other seven distances, 2, 6, 8, 9, 10, 11 and 12, for example 7 against 8 at and 2 against 4 at .
07.The Gilbert–Varshamov Bound
Upper bounds say what cannot be built. The next two results say what can. The first is Gilbert's [8], and it is the covering argument of Figure 1.
Proof. Build a code by adding words one at a time, each at distance at least from all the words already chosen, until no word can be added. Every word of the space is then within distance of some codeword, or it could still be added. So the balls of radius around the codewords cover all words, and .
At length 7 and distance 3 the ball of radius 2 holds words, and , so a code built this way has at least 5 codewords, far below the 16 of the Hamming code, because the covering balls overlap heavily. The largest distance from any word to its nearest codeword is the covering radius of the code, the subject of Covering Radius.
Varshamov's version builds a linear code, and it chooses columns of a parity-check matrix instead of codewords. It appeared in 1957, and the form used here follows Huffman and Pless [7]. Linear Codes showed how the columns of a parity-check matrix set the distance. A binary linear code has minimum distance at least exactly when no nonempty set of at most of those columns adds up to zero.
Proof. Let and choose columns of bits one at a time. When column is chosen, forbid every sum of at most of the columns already chosen, the empty sum, which is the zero column, included. There are at most forbidden columns, which is at most , so some column of bits is still free. Suppose now that some nonempty set of at most chosen columns added up to zero, and let be the one chosen last. Then equals the sum of the others, at most columns chosen before it, which the choice of forbade. So no such set exists, and the code with these columns as its parity-check matrix has distance at least . Its dimension is minus the rank of that matrix, at least , and any subcode of dimension keeps the distance.
Figure 5 runs the construction at with check bits. Distance 3 forbids only the zero column and the columns already chosen, so step forbids exactly of the 8 columns of 3 bits. Seven steps succeed, and at the eighth every column is forbidden. The seven columns are all the nonzero columns of 3 bits, which is the parity-check matrix of the Hamming code, so the construction rebuilds the code that the Hamming bound says is best. The theorem itself promises as much, since , and allows every length up to 7.
At length 15 the Varshamov bound guarantees linear codes of dimension 14, 11, 8, 6, 4, 3 and 2 for from 2 to 8, and of dimension 1 for every larger distance. The Gilbert bound is much weaker there. It guarantees , , , , , and codewords for from 2 to 8, about at where Varshamov promises . Gilbert divides by a ball of radius in length , while Varshamov compares against a ball of radius in length , which is much smaller. Even Varshamov's count is cautious, since many forbidden sums coincide. At with 4 check bits the theorem guarantees only length 5, while taking the smallest free column at every step reaches length 8, as one of the exercises shows.
08.The Elias Bound
The Hamming bound is strong at small distances and the Plotkin bound at large ones. The Elias bound mixes the two ideas, and at length 15 it settles directly a case that the Hamming bound settles only after a change of length. It is the one result in the chapter stated without proof, and Linear Programming and Asymptotic Bounds proves it. The idea is short enough to sketch. The balls of radius around all words cover each codeword times, so some ball contains at least the average share of the codewords. Translating by its center turns those codewords into words of weight at most that still lie at distance at least from one another, and a Plotkin count over such light words limits how many there can be. The statement below follows Huffman and Pless [7].
Every allowed gives a bound, and the smallest of them is the one to use. At length 15 the best radius is 1 for and 3, 2 for and 5, 3 for , 4 for , and 7 from on. Rounded down, the bound on the number of codewords is 30720, 5421, 2031, 883, 284, 104, 30, 11, 7, 6, 5, 4, 4 and 3 for from 2 to 15, and the largest dimension it allows a linear code is 14, 12, 10, 9, 8, 6, 4, 3, 2, 2, 2, 2, 2 and 1.
Most of these lose to another bound. The one that matters is at . With the denominator is and the ball is , so the bound is , which rounds down to 2031. That is below , so no binary code of length 15 and distance 4 has 2048 codewords, linear or not. Applied directly at length 15, the Hamming and Griesmer bounds both allow at , and the Elias bound is the first applied there to rule it out. The section Real Codes at Length 15 reaches a sharper verdict through length 14.
09.Real Codes at Length 15
Table 1 lists one code of length 15 for every distance. Several are built from a polynomial, a construction the part on cyclic codes develops properly, and the recipe needs only this much. Write the coefficients of a polynomial of degree as a row of bits, constant term first, and shift that row one place at a time to make rows. Those rows generate the code. For the row is 110010000000000, and its 11 shifts generate a Hamming code. Multiplying by gives , whose 10 shifts generate a code in which every codeword is a multiple of . Setting in a codeword counts its ones modulo 2, and setting in a multiple of gives 0, so every codeword has even weight. The code also sits inside the Hamming code, so its distance is at least 3 and even, hence at least 4, and the script finds exactly 4.
The degree-8 polynomial and the degree-10 polynomial generate the and codes, which BCH Codes constructs and explains. Multiplying the degree-8 polynomial by keeps its even-weight codewords, as before, and gives a code. The script generates every codeword of every code in the table and confirms each distance.
Table 1. A binary code of length 15 for each distance, with how it is built. The distance column names every the code serves, since a code of distance 10 also has distance at least 9.
| Distances served | Code | Built from |
|---|---|---|
| 2 | even-weight code | every word with an even number of ones |
| 3 | Hamming code | shifts of |
| 4 | even-weight subcode | shifts of |
| 5 | shifts of | |
| 6 | shifts of | |
| 7 | shifts of | |
| 8 | simplex code | the dual of the Hamming code |
| 9 and 10 | rows with ones in bits 0 to 9 and in bits 5 to 14 | |
| 11 to 15 | repetition code | the all-zeros and all-ones words |
Source: reproduced by ch27_bounds_on_codes.py.
Two kinds of agreement close a case. The first is equality. The simplex code meets two bounds at once, with Griesmer sum and with 16 codewords, the Plotkin value at . The second kind needs no equality. At the Hamming bound allows codewords. The code has only 32, but 64 would exceed 56.9, so no linear code of length 15 and distance 7 has dimension 6, and is the best.
A bound applied to a modified code can say more than the same bound applied directly. Suppose a code existed. Puncturing it, deleting one position, gives a code, and the Hamming bound at length 14 needs , that is , which is false. So no code exists, and the code is the best linear code at distance 4. Deleting a position works for nonlinear codes too, which is the extension identity, so for every code, linear or not, well below the 2031 of the Elias bound.
Table 2 collects every bound at length 15 beside the codes of Table 1, and Figure 6 draws the same numbers. For linear codes a bound applied directly closes a case wherever the smallest upper bound equals the dimension of a code that exists, and that happens at twelve of the fourteen distances. At the best code here has dimension 7 while the Hamming and Griesmer bounds allow 8, and at the code has dimension 6 while the Griesmer bound allows 7. The residual code closes both gaps. A code would leave a residual code, a code a one, and the Hamming bound rules out both, as a worked example at the end proves. So every code of Table 1 is the best linear code for its distances.
Table 2. The largest dimension each bound allows at length 15, the Varshamov guarantee, and the dimension of the code in the previous table. A case is closed when the smallest upper bound equals the code's dimension, or, at and 6, when the Hamming bound applied to the residual code rules out one dimension more.
| Singleton | Hamming | Plotkin | Griesmer | Elias | Varshamov | Code | Status | |
|---|---|---|---|---|---|---|---|---|
| 2 | 14 | 15 | n/a | 14 | 14 | 14 | 14 | closed |
| 3 | 13 | 11 | n/a | 12 | 12 | 11 | 11 | closed |
| 4 | 12 | 11 | n/a | 11 | 10 | 8 | 10 | closed |
| 5 | 11 | 8 | n/a | 8 | 9 | 6 | 7 | closed, residual |
| 6 | 10 | 8 | n/a | 7 | 8 | 4 | 6 | closed, residual |
| 7 | 9 | 5 | n/a | 5 | 6 | 3 | 5 | closed |
| 8 | 8 | 5 | 4 | 4 | 4 | 2 | 4 | closed |
| 9 | 7 | 4 | 2 | 2 | 3 | 1 | 2 | closed |
| 10 | 6 | 4 | 2 | 2 | 2 | 1 | 2 | closed |
| 11 | 5 | 2 | 1 | 1 | 2 | 1 | 1 | closed |
| 12 | 4 | 2 | 1 | 1 | 2 | 1 | 1 | closed |
| 13 | 3 | 1 | 1 | 1 | 2 | 1 | 1 | closed |
| 14 | 2 | 1 | 1 | 1 | 2 | 1 | 1 | closed |
| 15 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | closed |
Source: reproduced by ch27_bounds_on_codes.py.
10.What the Bounds Tell a Designer
A memory word of 64 data bits is the case hardware meets most often, and the bounds turn directly into check-bit budgets. A single-error-correcting linear code with check bits has length and needs , the Hamming bound at radius 1, and the smallest such is 7. A double-error-correcting code needs the Hamming bound at radius 2, , and the smallest that passes is 12, since .
A SECDED code needs 8. Seven check bits pass the radius-1 count at length 71, since . But a code, punctured, would give a code, which needs , and that fails. So 8 is the floor, and the Hsiao codes of SECDED and Hsiao Codes meet it. The same move shows that a code correcting two errors and detecting three needs at least 13 check bits, because puncturing it leaves a double-error-correcting code with one check bit fewer.
Beyond SECDED built a double-error-correcting code with 14 check bits and a code that also detects three errors, with 15. Each sits two bits above its floor. The bounds of this chapter do not say whether either floor can be reached, only that nothing below it can.
Table 3. Check bits needed for a data width of bits. The SEC and SECDED columns are met by Hamming and Hsiao codes. The DEC column is a floor from the Hamming bound at radius 2, which no double-error-correcting code can go below.
| Data bits | SEC | SECDED | DEC floor |
|---|---|---|---|
| 4 | 3 | 4 | 6 |
| 8 | 4 | 5 | 7 |
| 16 | 5 | 6 | 9 |
| 32 | 6 | 7 | 10 |
| 64 | 7 | 8 | 12 |
| 128 | 8 | 9 | 14 |
| 256 | 9 | 10 | 16 |
Source: reproduced by ch27_bounds_on_codes.py.
Table 3 extends the budget from 4 to 256 data bits, and Figure 7 plots it. Each doubling of the data width adds one check bit for single correction, and one or two for double correction, because a ball of radius 2 holds about words and so grows fourfold when doubles.
A bound tells a designer when to stop searching. At 64 data bits the 7-bit Hamming code and the 8-bit SECDED code meet their bounds, so no cleverer check matrix will save a bit. Where a gap remains, the bound caps what any search could win, two bits for the 14-bit double-error-correcting code.
Nonlinear codes are the one escape that a bound on linear codes leaves open, and the length-8 example shows how small the prize is, bits against the 4 bits of the 16-word linear code. Without linearity there is no generator matrix, so the encoder becomes a lookup table, and there is no parity-check matrix, so the decoder in general must compare the received word against stored codewords instead of computing a syndrome with XOR trees. That is why the codes in memories and on buses throughout this part are linear, and why the linear bounds are the ones that set their budgets.
11.Looking Ahead
The next chapter, Verifying ECC Hardware, turns from the codes to the circuits that encode and decode them, and to showing that a circuit computes exactly the code it was meant to compute.
Every bound here was evaluated at one length. Linear Programming and Asymptotic Bounds lets the length grow with the ratio held fixed, so that each bound becomes a curve for the best rate . There the Gilbert–Varshamov argument guarantees rates near , where is the binary entropy function of Information and Entropy, the Elias bound becomes a curve that lies below the Hamming and Plotkin curves, and the Delsarte linear programming bound and the McEliece–Rodemich–Rumsey–Welch bound push the upper curve down further. How far apart the best curves from above and from below truly are is still an open question.
12.Worked Examples
13.Exercises
References
- [1]Best, M. R. and Brouwer, A. E. and MacWilliams, F. J. and Odlyzko, A. M. and Sloane, N. J. A. (1978). “Bounds for Binary Codes of Length Less Than 25.” IEEE Transactions on Information Theory, 24(1), pp. 81–93. doi:10.1109/TIT.1978.1055827
- [2]Brouwer, Andries E. (2026). “Small Binary Codes: Table of General Binary Codes.” Online table. Accessed 2026-11-15. https://aeb.win.tue.nl/codes/binary-1.html
- [3]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
- [4]Singleton, Richard C. (1964). “Maximum Distance q-nary Codes.” IEEE Transactions on Information Theory, 10(2), pp. 116–118. doi:10.1109/TIT.1964.1053661
- [5]Plotkin, Morris (1960). “Binary Codes with Specified Minimum Distance.” IRE Transactions on Information Theory, 6(4), pp. 445–450. doi:10.1109/TIT.1960.1057584
- [6]Griesmer, J. H. (1960). “A Bound for Error-Correcting Codes.” IBM Journal of Research and Development, 4(5), pp. 532–542. doi:10.1147/rd.45.0532
- [7]Huffman, W. Cary and Pless, Vera (2003). “Fundamentals of Error-Correcting Codes.” Cambridge University Press. doi:10.1017/CBO9780511807077
- [8]Gilbert, E. N. (1952). “A Comparison of Signalling Alphabets.” Bell System Technical Journal, 31(3), pp. 504–522. doi:10.1002/j.1538-7305.1952.tb01393.x
— Anirban
Hardware–software at the seam where compilers meet microcode.