|
|
| Line 1: |
Line 1: |
| In [[coding theory]], a '''polynomial code''' is a type of [[linear code]] whose set of valid [[code words]] consists of those [[polynomials]] (usually of some fixed length) that are [[polynomial long division|divisible]] by a given fixed polynomial (of shorter length, called the ''generator polynomial'').
| | I'm Jewell and I live in Beerze. <br>I'm interested in Design and Technology, Speed skating and Norwegian art. I like travelling and watching The Simpsons.<br><br>Feel free to surf to my web blog; [http://www.sampower.co.kr/102849 wordpress dropbox backup] |
| | |
| == Definition ==
| |
| | |
| Fix a [[finite field]] <math>GF(q)</math>, whose elements we call ''symbols''. For the purposes of constructing polynomial codes, we identify a string of <math>n</math> symbols <math>a_{n-1}\ldots a_0</math> with the polynomial
| |
| | |
| :<math>a_{n-1}x^{n-1} + \cdots + a_1x + a_0.\,</math>
| |
| | |
| Fix integers <math>m \leq n</math> and let <math>g(x)</math> be some fixed polynomial of degree <math>m</math>, called the ''generator polynomial''. The ''polynomial code generated by <math>g(x)</math>'' is the code whose code words are precisely the polynomials of degree less than <math>n</math> that are [[polynomial long division|divisible]] (without remainder) by <math>g(x)</math>.
| |
| | |
| == Example ==
| |
| | |
| Consider the polynomial code over <math>GF(2)=\{0,1\}</math> with <math>n=5</math>, <math>m=2</math>, and generator polynomial <math>g(x)=x^2+x+1</math>. This code consists of the following code words:
| |
| | |
| :<math>0\cdot g(x),\quad 1\cdot g(x),\quad x\cdot g(x), \quad (x+1) \cdot g(x),</math>
| |
| | |
| :<math>x^2 \cdot g(x),\quad (x^2+1)\cdot g(x),\quad (x^2+x)\cdot g(x), \quad (x^2+x+1) \cdot g(x).</math>
| |
| | |
| Or written explicitly:
| |
| | |
| :<math>0,\quad x^2+x+1,\quad x^3+x^2+x,\quad x^3+1,</math>
| |
| | |
| :<math>x^4+x^3+x^2,\quad x^4+x^3+x+1,\quad x^4+x,\quad x^4+x^2+1.</math>
| |
| | |
| Equivalently, expressed as strings of binary digits, the codewords are:
| |
| | |
| :<math>00000,\quad 00111,\quad 01110,\quad 01001,</math>
| |
| | |
| :<math>11100,\quad 11011,\quad 10010,\quad 10101.</math>
| |
| | |
| Note that this, as every polynomial code, is indeed a [[linear code]], i.e., linear combinations of code words are again code words. In a case like this where the field is GF(2), linear combinations are found by taking the XOR of the codewords expressed in binary form (e.g. 00111 XOR 10010 = 10101).
| |
| | |
| == Encoding ==
| |
| | |
| In a polynomial code over <math>GF(q)</math> with code length <math>n</math> and generator polynomial <math>g(x)</math> of degree <math>m</math>,
| |
| there will be exactly <math>q^{n-m}</math> code words. Indeed, by definition, <math>p(x)</math> is a code word if and only if it is of the form <math>p(x) = g(x)\cdot q(x)</math>, where <math>q(x)</math> (the ''quotient'') is of degree less than <math>n-m</math>. Since there are <math>q^{n-m}</math> such quotients available, there is the same number of possible code words.
| |
| Plain (unencoded) data words should therefore be of length <math>n-m</math>
| |
| | |
| Some authors, such as (Lidl & Pilz, 1999), only discuss the mapping <math>q(x) \mapsto g(x)\cdot q(x)</math> as the assignment from data words to code words. However, this has the disadvantage that the data word does not appear as part of the code word.
| |
| | |
| Instead, the following method is often used to create a [[systematic code]]: given a data word <math>d(x)</math> of length <math>n-m</math>, first multiply <math>d(x)</math> by <math>x^m</math>, which has the effect of shifting <math>d(x)</math> by <math>m</math> places to the left. In general, <math>x^md(x)</math> will not be divisible by <math>g(x)</math>, i.e., it will not be a valid code word. However, there is a unique code word that can be obtained by adjusting the rightmost <math>m</math> symbols of <math>x^md(x)</math>.
| |
| To calculate it, compute the remainder of dividing <math>x^md(x)</math> by <math>g(x)</math>:
| |
| | |
| :<math>x^md(x) = g(x)\cdot q(x) + r(x),\,</math>
| |
| | |
| where <math>r(x)</math> is of degree less than <math>m</math>. The code word corresponding to the data word <math>d(x)</math> is then defined to be
| |
| | |
| :<math>p(x) := x^md(x) - r(x),\,</math>
| |
| | |
| Note the following properties:
| |
| # <math>p(x) = g(x)\cdot q(x)</math>, which is divisible by <math>g(x)</math>. In particular, <math>p(x)</math> is a valid code word.
| |
| # Since <math>r(x)</math> is of degree less than <math>m</math>, the leftmost <math>n-m</math> symbols of <math>p(x)</math> agree with the corresponding symbols of <math>x^md(x)</math>. In other words, the first <math>n-m</math> symbols of the code word are the same as the original data word. The remaining <math>m</math> symbols are called ''checksum digits'' or ''check bits''.
| |
| | |
| === Example ===
| |
| | |
| For the above code with <math>n=5</math>, <math>m=2</math>, and generator polynomial <math>g(x)=x^2+x+1</math>, we obtain the following assignment from data words to codewords:
| |
| | |
| * 000 {{mapsto}} '''000'''00
| |
| * 001 {{mapsto}} '''001'''11
| |
| * 010 {{mapsto}} '''010'''01
| |
| * 011 {{mapsto}} '''011'''10
| |
| * 100 {{mapsto}} '''100'''10
| |
| * 101 {{mapsto}} '''101'''01
| |
| * 110 {{mapsto}} '''110'''11
| |
| * 111 {{mapsto}} '''111'''00
| |
| | |
| == Decoding ==
| |
| | |
| An erroneous message can be detected in a straightforward way through polynomial division by the generator polynomial resulting in a non-zero remainder.
| |
| | |
| Assuming that the code word is free of errors, a systematic code can be decoded simply by stripping away the <math>m</math> checksum digits.
| |
| | |
| If there are errors, then error correction should be performed before decoding. Efficient decoding algorithms exist for specific polynomial codes, such as [[BCH code]]s.
| |
| | |
| == Properties of polynomial codes ==
| |
| | |
| As for all digital codes, the [[error detection and correction]] abilities of polynomial codes are determined by the minimum [[Hamming distance]] of the code. Since polynomial codes are linear codes, the minimum Hamming distance is equal to the minimum weight of any non-zero codeword. In the example above, the minimum Hamming distance is 2, since 01001 is a codeword, and there is no nonzero codeword with only one bit set.
| |
| | |
| More specific properties of a polynomial code often depend on particular algebraic properties of its generator polynomial. Here are some examples of such properties:
| |
| | |
| * A polynomial code is [[cyclic code|cyclic]] if and only if the generator polynomial divides <math>x^n-1</math>.
| |
| * If the generator polynomial is [[Primitive polynomial (field theory)|primitive]], then the resulting code has Hamming distance at least 3, provided that <math>n\leq 2^m-1</math>.
| |
| * In [[BCH code]]s, the generator polynomial is chosen to have specific roots in an extension field, in a way that achieves high Hamming distance.
| |
| | |
| The algebraic nature of polynomial codes, with cleverly chosen generator polynomials, can also often be exploited to find efficient error correction algorithms. This is the case for [[BCH code]]s.
| |
| | |
| == Specific families of polynomial codes ==
| |
| | |
| * [[Cyclic code]]s – every cyclic code is also a polynomial code; a popular example is the [[cyclic redundancy check|CRC]] code.
| |
| * [[BCH code]]s – a family of cyclic codes with high Hamming distance and efficient algebraic error correction algorithms.
| |
| * [[Reed–Solomon code]]s – an important subset of BCH codes with particularly efficient structure.
| |
| | |
| == References ==
| |
| * W.J. Gilbert and W.K. Nicholson: ''Modern Algebra with Applications'', 2nd edition, Wiley, 2004.
| |
| * R. Lidl and G. Pilz. Applied Abstract Algebra, 2nd edition. Wiley, 1999.
| |
| {{Reflist}}
| |
| [[Category:Coding theory]]
| |
I'm Jewell and I live in Beerze.
I'm interested in Design and Technology, Speed skating and Norwegian art. I like travelling and watching The Simpsons.
Feel free to surf to my web blog; wordpress dropbox backup