|
|
| Line 1: |
Line 1: |
| {{confusing|date=March 2011}}
| | The author's name is Andera and she believes it seems quite great. To climb is something she would by no means give up. Office supervising is exactly where her primary income arrives from. Her family members lives in Ohio.<br><br>My site telephone psychic ([https://cs.mju.ac.kr/?document_srl=32433672 cs.mju.ac.kr]) |
| | |
| {{infobox code
| |
| | name = Reed-Muller code RM(r,m)
| |
| | image =
| |
| | image_caption =
| |
| | namesake = [[Irving S. Reed]] and [[David E. Muller]]
| |
| | type = [[Linear block code]]
| |
| | block_length = <math>2^m</math>
| |
| | message_length = <math>k</math> depending on <math>r</math> and <math>m</math>
| |
| | rate = <math>k/2^m</math>
| |
| | distance = <math>2^{m-r}</math>
| |
| | alphabet_size = <math>2</math>
| |
| | notation = <math>[2^m,k,2^{m-r}]_2</math>
| |
| }}
| |
| | |
| '''Reed–Muller codes''' are a family of [[linear code|linear]] [[error-correcting code]]s used in communications. Reed–Muller codes belong to the classes of [[locally testable code]]s and [[locally decodable code]]s, which is why they are useful in the design of [[probabilistically checkable proof]]s in [[computational complexity theory]]. They are named after [[Irving S. Reed]] and [[David E. Muller]]. Muller discovered the codes, and Reed proposed the majority logic decoding for the first time. Special cases of Reed–Muller codes include the [[Hadamard code]], the [[Walsh code|Walsh–Hadamard code]], and the [[Reed–Solomon error correction|Reed–Solomon code]].
| |
| | |
| Reed–Muller codes are listed as RM(''d'', ''r''), where ''d'' is the order of the code, and ''r'' determines the length of code, ''n'' = 2<sup> ''r''</sup>. RM codes are related to binary functions on the field GF(2<sup> ''r''</sup>) over the elements {0, 1}.
| |
| | |
| RM(0, ''r'') codes are repetition codes of length ''n'' = 2<sup> ''r''</sup>, rate <math>{R=\tfrac{1}{n}}</math> and minimum distance ''d''<sub>min</sub> = ''n''.
| |
| | |
| RM(1, ''r'') codes are parity check codes of length ''n'' = 2<sup> ''r''</sup>, rate <math>R=\tfrac{r+1}{n}</math> and minimum distance <math>d_\min = \tfrac{n}{2}</math>.
| |
| | |
| RM(''r'' − 1, ''r'') codes are parity check codes of length ''n'' = 2<sup> ''r''</sup>.
| |
| | |
| RM(''r'' − 2, ''r'') codes are the family of extended Hamming codes of length ''n'' = 2<sup> ''r''</sup> with minimum distance ''d''<sub>min</sub> = 4.<ref>Trellis and Turbo Coding, C. Schlegel & L. Perez, Wiley Interscience, 2004, p149.</ref>
| |
| | |
| ==Construction==
| |
| A generator matrix for a Reed–Muller code of length ''n'' = 2<sup>''d''</sup> can be constructed as follows. Let us write:
| |
| | |
| :<math> X = \mathbb{F}_2^d = \{ x_1, \ldots, x_{2^d} \}. </math>
| |
| | |
| Note that each member of the set X is a '''point''' in <math>\mathbb{F}_2^d</math>. We define in n-dimensional space <math>\mathbb{F}_2^n</math> the [[indicator vector]]s
| |
| | |
| :<math>\mathbb{I}_A \in \mathbb{F}_2^n</math>
| |
| | |
| on subsets <math> A \subset X </math> by:
| |
| | |
| :<math>\left( \mathbb{I}_A \right)_i = \begin{cases} 1 & \mbox{ if } x_i \in A \\ 0 & \mbox{ otherwise} \\ \end{cases} </math>
| |
| | |
| together with, also in <math>\mathbb{F}_2^n</math>, the binary operation
| |
| | |
| :<math> w \wedge z = (w_1 \cdot z_1, \ldots , w_n \cdot z_n ), </math>
| |
| | |
| referred to as the ''wedge product'' (this wedge product is not to be confused with the [[wedge product]] defined in exterior algebra). Here, <math>w=(w_1,w_2,\ldots,w_n)</math> and <math>z=(z_1,z_2,\ldots, z_n)</math> are
| |
| points in <math>\mathbb{F}_2^n</math>, and the operation <math>\cdot</math> is the usual multiplication in the field <math>\mathbb{F}_2</math>.
| |
| | |
| <math>\mathbb{F}_2^d</math> is a ''d''-dimensional vector space over the field <math>\mathbb{F}_2</math>, so it is possible to write
| |
| | |
| <math>(\mathbb{F}_2)^d = \{ (y_d, \ldots , y_1) | y_i \in \mathbb{F}_2 \} </math>
| |
| | |
| We define in ''n''-dimensional space <math>\mathbb{F}_2^n</math> the following vectors with length ''n'': ''v''<sub>0</sub> = (1, 1, 1, 1, 1, 1, 1, 1) and
| |
| | |
| :<math> v_i = \mathbb{I}_{ H_i } </math>
| |
| | |
| where the ''H''<sub>''i''</sub> are [[Hyperplane|hyperplanes]] in <math>(\mathbb{F}_2)^d</math> (with dimension d −1):
| |
| | |
| :<math>H_i = \{ y \in ( \mathbb{F}_2 ) ^d \mid y_i = 0 \} </math>
| |
| | |
| ===Building a generator matrix===
| |
| The '''Reed–Muller RM(''d'', ''r'') code''' of order ''d'' and length ''n'' = 2<sup>''r''</sup> is the code generated by ''v''<sub>0</sub> and the wedge products of up to ''r'' of the ''v''<sub>''i''</sub> (where by convention a wedge product of fewer than one vector is the identity for the operation). In other words, we can build a generator matrix for RM(''d'',''r'') code, using vectors and their wedge product permutations up to the ''r'' at a time <math>{v_0, v_1, \ldots, v_d, \ldots, (v_i \wedge v_j), \ldots (v_i \wedge v_j \ldots \wedge v_r)}</math>, as the rows of the generator matrix.
| |
| | |
| ==Example 1==
| |
| | |
| Let ''r'' = 3. Then ''n'' = 8, and
| |
| | |
| :<math> X = \mathbb{F}_2^3 = \{ (0,0,0), (0,0,1), \ldots, (1,1,1) \}, </math>
| |
| | |
| and
| |
| | |
| :<math>
| |
| \begin{matrix}
| |
| v_0 & = & (1,1,1,1,1,1,1,1) \\[2pt]
| |
| v_1 & = & (1,0,1,0,1,0,1,0) \\[2pt]
| |
| v_2 & = & (1,1,0,0,1,1,0,0) \\[2pt]
| |
| v_3 & = & (1,1,1,1,0,0,0,0). \\
| |
| \end{matrix}
| |
| </math>
| |
| | |
| The RM(1,3) code is generated by the set
| |
| | |
| :<math> \{ v_0, v_1, v_2, v_3 \},\, </math>
| |
| | |
| or more explicitly by the rows of the matrix
| |
| | |
| :<math>
| |
| \begin{pmatrix}
| |
| 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\
| |
| 1 & 0 & 1 & 0 & 1 & 0 & 1 & 0 \\
| |
| 1 & 1 & 0 & 0 & 1 & 1 & 0 & 0 \\
| |
| 1 & 1 & 1 & 1 & 0 & 0 & 0 & 0 \\
| |
| \end{pmatrix}
| |
| </math>
| |
| | |
| ==Example 2==
| |
| | |
| The RM(2,3) code is generated by the set:
| |
| :<math> \{ v_0, v_1, v_2, v_3, v_1 \wedge v_2, v_1 \wedge v_3, v_2 \wedge v_3 \} </math>
| |
| | |
| or more explicitly by the rows of the matrix:
| |
| | |
| :<math>
| |
| \begin{pmatrix}
| |
| 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\
| |
| 1 & 0 & 1 & 0 & 1 & 0 & 1 & 0 \\
| |
| 1 & 1 & 0 & 0 & 1 & 1 & 0 & 0 \\
| |
| 1 & 1 & 1 & 1 & 0 & 0 & 0 & 0 \\
| |
| 1 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\
| |
| 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\
| |
| 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\
| |
| \end{pmatrix}
| |
| </math>
| |
| | |
| ==Properties==
| |
| The following properties hold:
| |
| | |
| '''1''' The set of all possible wedge products of up to ''d'' of the ''v''<sub>''i''</sub> form a basis for <math>\mathbb{F}_2^n</math>.
| |
| | |
| '''2''' The RM (''d'', ''r'') code has [[linear code|rank]]
| |
| ::<math> \sum_{s=0}^r {d \choose s}. </math>
| |
| | |
| '''3''' RM (''d'', ''r'') = RM (''d''− 1, ''r '') | RM (''d'' − 1, ''r'' − 1) where '|' denotes the [[bar product (coding theory)|bar product]] of two codes.
| |
| | |
| '''4''' RM (''d'', ''r'') has minimum [[Hamming weight]] 2<sup>''d'' − ''r''</sup>.
| |
| | |
| ===Proof===
| |
| '''1'''
| |
| :There are
| |
| | |
| ::<math> \sum_{s=0}^d { d \choose s } = 2^d = n </math>
| |
| | |
| :such vectors and <math>\mathbb{F}_2^n</math> has dimension ''n'' so it is sufficient to check that the ''n'' vectors span; equivalently it is sufficient to check that RM(d, d) = <math>\mathbb{F}_2^n</math>.
| |
| | |
| :Let ''x'' be an element of ''X'' and define
| |
| | |
| ::<math>y_i = \begin{cases} v_i & \mbox{ if } x_i = 0 \\ 1+v_i & \mbox{ if } x_i = 1 \\ \end{cases} </math>
| |
| | |
| :Then <math>\mathbb{I}_{ \{ x \} } = y_i \wedge \ldots \wedge y_d </math>
| |
| | |
| :Expansion via the distributivity of the wedge product gives <math> \mathbb{I}_{ \{ x \} } \in \mbox{ RM(d,d)} </math>. Then since the vectors <math>\{ \mathbb{I}_{ \{ x \} } \mid x \in X \} </math> span <math>\mathbb{F}_2^n</math> we have RM(d, d) = <math>\mathbb{F}_2^n</math>.
| |
| | |
| '''2'''
| |
| :By '''1''', all such wedge products must be linearly independent, so the rank of RM(d, r) must simply be the number of such vectors.
| |
| | |
| '''3'''
| |
| :Omitted.
| |
| | |
| '''4'''
| |
| :By induction.
| |
| | |
| :The RM(''d'', 0) code is the repetition code of length ''n'' =2<sup>''d''</sup> and weight ''n'' = 2<sup>''d''−0</sup> = 2<sup>''d''−0</sup>. By '''1''' RM(''d'', ''d'') = <math>\mathbb{F}_2^n</math> and has weight 1 = 2<sup>0</sup> = 2<sup>''d''−''d''</sup>.
| |
| | |
| :The article [[bar product (coding theory)]] gives a proof that the weight of the bar product of two codes ''C''<sub>1</sub> , ''C''<sub>2</sub> is given by
| |
| | |
| ::<math>\min \{ 2w(C_1), w(C_2) \} </math>
| |
| | |
| :If 0 < ''r'' < ''d'' and if
| |
| :: i) RM(''d'' − 1, ''r'') has weight 2<sup>''d''−1−''r''</sup>
| |
| :: ii) RM(d-1,r-1) has weight 2<sup>''d''−1−(''r''−1)</sup> = 2<sup>''d''−''r''</sup>
| |
| | |
| :then the bar product has weight
| |
| | |
| ::<math>\min \{ 2 \times 2^{d-1-r}, 2^{d-r} \} = 2^{d-r} .</math>
| |
| | |
| ==Alternative construction==
| |
| | |
| A Reed–Muller code RM(r,m) exists for any integers <math>m \ge 0</math> and <math>0 \le r \le m</math>. RM(''m'', ''m'') is defined as the universe (<math>2^m,2^m,1</math>) code. RM(−1,m) is defined as the trivial code (<math>2^m,0,\infty</math>). The remaining RM codes may be constructed from these elementary codes using the length-doubling construction
| |
| | |
| : <math>RM(r,m) = \{(\mathbf{u},\mathbf{u}+\mathbf{v})|\mathbf{u} \in RM(r,m-1),\mathbf{v} \in RM(r-1,m-1)\}.</math>
| |
| | |
| From this construction, RM(r,m) is a binary [[linear block code]] (''n'', ''k'', ''d'') with length ''n'' = 2<sup> ''m''</sup>, dimension <math>k(r,m)=k(r,m-1)+k(r-1,m-1)</math> and minimum distance <math>d = 2^{m-r}</math> for <math>r \ge 0</math>. The [[dual code]] to RM(r,m) is RM(m-r-1,m). This shows that repetition and SPC codes are duals, biorthogonal and extended Hamming codes are duals and that codes with k=n/2 are self-dual.
| |
| | |
| ==Construction based on low-degree polynomials over a finite field==
| |
| | |
| There is another, simple way to construct Reed–Muller codes based on low-degree polynomials over a finite field. This construction is particularly suited for their application as [[locally testable code]]s and [[locally decodable code]]s.<ref>Prahladh Harsha et al., [http://arxiv.org/abs/1002.3864 Limits of Approximation Algorithms: PCPs and Unique Games (DIMACS Tutorial Lecture Notes)], Section 5.2.1.</ref>
| |
| | |
| Let <math>\mathbb F</math> be a finite field and let <math>m</math> and <math>d</math> be positive integers, where <math>m</math> should be thought of as larger than <math>d</math>. We are going to encode messages consisting of <math>{m+d \choose m}</math> elements of <math>\mathbb F</math> as codewords of length <math>|\mathbb F|^m</math> as follows: We interpret the message as an <math>m</math>-variate polynomial <math>f</math> of degree at most <math>d</math> with coefficient from <math>\mathbb F</math>. Such a polynomial has <math>{m+d \choose m}</math> coefficients. The Reed–Muller encoding of <math>f</math> is the list of the evaluations of <math>f</math> on all <math>x\in\mathbb F^m</math>; the codeword at the position indexed by <math>x\in\mathbb F^m</math> has value <math>f(x)</math>.
| |
| | |
| ==Table of Reed–Muller codes==
| |
| The table below lists the RM(''r'', ''m'') codes of lengths up to 32.
| |
| | |
| {| class="wikitable" border="0"
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(m,m)<br />(<math>2^m,2^m,1</math>)
| |
| |universe codes
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(5,5)<br />(32,32,1)
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(4,4)<br />(16,16,1)
| |
| |
| |
| |RM(''m'' − 1, ''m'')<br />(<math>2^m,2^m-1,2</math>)
| |
| |[[parity bit|SPC]] codes
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |RM(3,3)<br />(8,8,1)
| |
| |
| |
| |RM(4,5)<br />(32,31,2)
| |
| |-
| |
| |
| |
| |
| |
| |RM(2,2)<br />(4,4,1)
| |
| |
| |
| |RM(3,4)<br />(16,15,2)
| |
| |
| |
| |RM(''m'' − 2, ''m'')<br />(<math>2^m,2^m-m-1,4</math>)
| |
| |ext. [[Hamming code]]s
| |
| |-
| |
| |
| |
| |RM(1,1)<br />(2,2,1)
| |
| |
| |
| |RM(2,3)<br />(8,7,2)
| |
| |
| |
| |RM(3,5)<br />(32,26,4)
| |
| |-
| |
| |RM(0,0)<br />(1,1,1)
| |
| |
| |
| |RM(1,2)<br />(4,3,2)
| |
| |
| |
| |RM(2,4)<br />(16,11,4)
| |
| |-
| |
| |
| |
| |RM(0,1)<br />(2,1,2)
| |
| |
| |
| |RM(1,3)<br />(8,4,4)
| |
| |
| |
| |RM(2,5)<br />(32,16,8)
| |
| |
| |
| |[[self-dual code]]s
| |
| |-
| |
| |RM(−1,0)<br />(1,0,<math>\infty</math>)
| |
| |
| |
| |RM(0,2)<br />(4,1,4)
| |
| |
| |
| |RM(1,4)<br />(16,5,8)
| |
| |-
| |
| |
| |
| |RM(-1,1)<br />(2,0,<math>\infty</math>)
| |
| |
| |
| |RM(0,3)<br />(8,1,8)
| |
| |
| |
| |RM(1,5)<br />(32,6,16)
| |
| |-
| |
| |
| |
| |
| |
| |RM(-1,2)<br />(4,0,<math>\infty</math>)
| |
| |
| |
| |RM(0,4)<br />(16,1,16)
| |
| |
| |
| |RM(1,m)<br />(<math>2^m,m+1,2^{m-1}</math>)
| |
| |biorthogonal codes
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |RM(−1,3)<br />(8,0,<math>\infty</math>)
| |
| |
| |
| |RM(0,5)<br />(32,1,32)
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(−1,4)<br />(16,0,<math>\infty</math>)
| |
| |
| |
| |RM(0,m)<br />(<math>2^m, 1, 2^m</math>)
| |
| |[[repetition code]]s
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(−1,5)<br />(32,0,<math>\infty</math>)
| |
| |-
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |RM(-1,m)<br />(<math>2^m,0,\infty</math>)
| |
| |trivial codes
| |
| |}
| |
| | |
| == Decoding RM codes ==
| |
| RM(''r'', ''m'') codes can be decoded using the majority logic decoding. The basic idea of majority logic decoding is
| |
| to build several checksums for each received code word element. Since each of the different checksums must all
| |
| have the same value (i.e. the value of the message word element weight), we can use a majority logic decoding to decipher
| |
| the value of the message word element. Once each order of the polynomial is decoded, the received word is modified
| |
| accordingly by removing the corresponding codewords weighted by the decoded message contributions, up to the present stage.
| |
| So for a ''r''th order RM code, we have to decode iteratively r+1, times before we arrive at the final
| |
| received code-word. Also, the values of the message bits are calculated through this scheme; finally we can calculate
| |
| the codeword by multiplying the message word (just decoded) with the generator matrix.
| |
| | |
| One clue if the decoding succeeded, is to have an all-zero modified received word, at the end of (''r'' + 1)-stage decoding
| |
| through the majority logic decoding. This technique was proposed by Irving S. Reed, and is more general when applied
| |
| to other finite geometry codes.
| |
| | |
| == Notes ==
| |
| {{reflist}}
| |
| | |
| == References ==
| |
| Research Articles:
| |
| | |
| * D. E. Muller. Application of boolean algebra to switching circuit design and to error detection. IRE Transactions on Electronic Computers, 3:6–12, 1954.
| |
| * Irving S. Reed. A class of multiple-error-correcting codes and the decoding scheme. Transactions of the IRE Professional Group on Information Theory, 4:38–49, 1954.
| |
| | |
| Textbooks:
| |
| | |
| * {{cite book | author=Shu Lin | coauthors=Daniel Costello | title=Error Control Coding | edition=2 | year=2005 | publisher=Pearson | isbn=0-13-017973-6 }} Chapter 4.
| |
| * {{cite book | author=J.H. van Lint | title=Introduction to Coding Theory | edition=2 | publisher=[[Springer-Verlag]] | series=[[Graduate Texts in Mathematics|GTM]] | volume=86 | year=1992 | isbn=3-540-54894-7 }} Chapter 4.5.
| |
| | |
| ==External links==
| |
| * [http://ocw.mit.edu MIT OpenCourseWare], 6.451 Principles of Digital Communication II, Lecture Notes section 6.4
| |
| * [http://octave.sourceforge.net/communications/function/reedmullergen.html GPL Matlab-implementation of RM-codes ]
| |
| * [http://octave.svn.sourceforge.net/viewvc/octave/trunk/octave-forge/main/comm/inst/reedmullergen.m?revision=9852&view=markup Source GPL Matlab-implementation of RM-codes]
| |
| | |
| {{CCSDS}}
| |
| | |
| {{DEFAULTSORT:Reed-Muller code}}
| |
| [[Category:Error detection and correction]]
| |
| [[Category:Coding theory]]
| |