SYSTEM AND METHOD FOR DECODING REED-MULLER CODES

Abstract

Various embodiments are directed to Reed-Muller decoding systems and methods based on recursive projections and aggregations of cosets decoding, exploiting the self-similarity of RM codes, and extended with list-decoding procedures and with outer-code concatenations

Description

FIELD OF THE DISCLOSURE

The present disclosure relates generally to systems and methods for information encoding and decoding and, more particularly, to methods for decoding Reed-Muller (RM) codes and variants thereof.

BACKGROUND

This section is intended to introduce the reader to various aspects of art, which may be related to various aspects of the present invention that are described and/or claimed below. This discussion is believed to be helpful in providing the reader with background information to facilitate a better understanding of the various aspects of the present invention. Accordingly, it should be understood that these statements are to be read in this light, and not as admissions of prior art.

Reed-Muller (RM) codes are among the oldest families of error-correcting codes. As compared to polar codes, RM codes have in particular the advantage of having a simple and universal code construction, though RM codes do not possess yet the generic analytical framework of polar codes (i.e., polarization theory). It has been shown that RM codes achieve capacity on the Binary Erasure Channel (BEC) at constant rate, as well as for extremal rates for BEC and Binary Symmetric Channels (BSC), but obtaining such results for a broader class of communication channels and rates remains open.

Unfortunately, an important missing component is for RM codes is that of a guaranteed efficient decoder for RM codes that is competitive in the low rate/block-length regime.

SUMMARY OF THE INVENTION

Various deficiencies in the prior art are addressed below by the disclosed systems, methods and apparatus configured for decoding Reed-Muller codes (and variants thereof) over any binary input memoryless channels. Various embodiments include decoders based on recursive projections and aggregations of cosets decoding, exploiting the self-similarity of RM codes, and extended with list-decoding procedures and with outer-code concatenations. Various embodiments include RM decoders of particular utility within the context of specific regimes of interest, such as short code length (e.g., ≤1024 bits) and low code rate (e.g., ≤0:5) regimes contemplated for use within the emerging 5G communications and Internet of Things (IoT) applications.

A method for decoding Reed-Muller (RM) encoded data according to one embodiment comprises: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words; recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; and aggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data.

Additional objects, advantages, and novel features of the invention will be set forth in part in the description which follows, and in part will become apparent to those skilled in the art upon examination of the following or may be learned by practice of the invention. The objects and advantages of the invention may be realized and attained by means of the instrumentalities and combinations particularly pointed out in the appended claims.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the present invention and, together with a general description of the invention given above, and the detailed description of the embodiments given below, serve to explain the principles of the present invention.

FIG. 1 is a functional block diagram of a block coding system benefiting from the various embodiments.

FIG. 2 graphically depicts a Recursive Projection-Aggregation decoding algorithm for third order RM codes according to an embodiment;

FIGS. 3-4 are flow diagrams of decoding methods according to various embodiments; and

FIG. 5 depicts a high-level block diagram of a computing device suitable for use within the context of the various embodiments.

It should be understood that the appended drawings are not necessarily to scale, presenting a somewhat simplified representation of various features illustrative of the basic principles of the invention. The specific design features of the sequence of operations as disclosed herein, including, for example, specific dimensions, orientations, locations, and shapes of various illustrated components, will be determined in part by the particular intended application and use environment. Certain features of the illustrated embodiments have been enlarged or distorted relative to others to facilitate visualization and clear understanding. In particular, thin features may be thickened, for example, for clarity or illustration.

DETAILED DESCRIPTION OF THE INVENTION

The following description and drawings merely illustrate the principles of the invention. It will thus be appreciated that those skilled in the art will be able to devise various arrangements that, although not explicitly described or shown herein, embody the principles of the invention and are included within its scope. Furthermore, all examples recited herein are principally intended expressly to be only for illustrative purposes to aid the reader in understanding the principles of the invention and the concepts contributed by the inventor(s) to furthering the art and are to be construed as being without limitation to such specifically recited examples and conditions. Additionally, the term, “or,” as used herein, refers to a non-exclusive or, unless otherwise indicated (e.g., “or else” or “or in the alternative”). Also, the various embodiments described herein are not necessarily mutually exclusive, as some embodiments can be combined with one or more other embodiments to form new embodiments.

The numerous innovative teachings of the present application will be described with particular reference to the presently preferred exemplary embodiments. However, it should be understood that this class of embodiments provides only a few examples of the many advantageous uses of the innovative teachings herein. In general, statements made in the specification of the present application do not necessarily limit any of the various claimed inventions. Moreover, some statements may apply to some inventive features but not to others. Those skilled in the art and informed by the teachings herein will realize that the invention is also applicable to various other technical areas or embodiments, such as seismology and data fusion.

Various deficiencies in the prior art are addressed below by the disclosed systems, methods and apparatus configured for decoding Reed-Muller codes over any binary input memoryless channels. Various embodiments include decoders based on recursive projections and aggregations of cosets decoding, exploiting the self-similarity of RM codes, and extended with list-decoding procedures and with outer-code concatenations. Various embodiments include RM decoders of particular utility within the context of specific regimes of interest, such as short code length (e.g., ≤1024 bits) and low code rate (e.g., ≤0:5) regimes contemplated for use within the emerging 5G communications and Internet of Things (IoT) applications.

FIG. 1 depicts a high level block diagram of a block coding/decoding system benefiting from the various embodiments. Specifically, FIG. 1 depicts a block diagram of a block coding/decoding system 100 including a transmit side 102 and a receive side 104.

On the transmit side 102, the system 100 includes an (n,k;d) linear block channel encoder 106 wherein a block of “k” information bits received from an information source encoder 108 is encoded to output a codeword of “n” bits in length (wherein n>k). The channel encoder 106 preferably implements an error control code. An example of the information source encoder 108 is a vocoder or data compressor. The code words output from the channel encoder 106 are then optionally rearranged by an interleaver 110. A modulator 112 then maps the rearranged code words into waveforms suited for transmission over a communications channel 114. Modulator 112 may comprise, illustratively, a known modulator having an M-ary signal constellation (e.g., quadrature amplitude modulation (QAM), phase shift keying (PSK) and the like). The communications channel 114 may comprise a wired or wireless medium which suffering from error and/or distortion introducing problems such as fading, interference, noise and the like.

On the receive side 104, the system 100 includes an appropriate demodulator 116 that demodulates the communications channel 114 transmitted communication and outputs the rearranged code words. The estimated code words are then reordered (i.e., de-rearranged) by a de-interleaver 118 if necessary. An (n,k;d) linear block channel decoder 120 then processes the reordered estimated code words to generate estimates of the information bits for output to an information source decoder 122. The channel decoder 120 preferably comprises a maximum likelihood decoder for the selected error control code which utilizes soft decision decoding.

The block coding/decoding system 100 of FIG. 1 benefits from the use of RM channel encoding/decoding functions such as discussed herein, and especially the recursive projection-aggregation decoding of RM codes as discussed herein. The remaining discussion will assume that RM encoded data generated by, for example, the channel encoder 106 is subsequently decoded by the channel decoder 120. As such, the functions of the channel decoder 120 and similar structures will be the focus of the following discussion.

The system 100 of FIG. 1 is illustrative of only one example of a use for the various embodiments described herein. In particular, it is noted that while FIG. 1 depicts a system wherein various embodiments of decoders and/or decoding methods are used within the context of a data transmitting/receiving system, the various embodiments also find utility within the context of data storage systems.

Generally speaking, the various embodiments find utility within the context of any system, method or component thereof wherein RM or related encoding/decoding is used. Further, the various embodiments may be used in conjunction or concatenation with other codes, such as in the form of outer-codes, inner-codes, or any other components of various coding schemes.

Recursive Projection-Aggregation (RPA) Decoding Embodiments

Various embodiments are based on the observations of the inventors that drawbacks in polar codes and, in particular, CRC-aided polar codes at short to medium block lengths arise from inherent weakness of the polar code itself. The inventors note that advantages of Reed-Muller (RM) codes over polar codes include: (1) better performance at short to medium block length in agreement with better scaling law, and (2) simple and universal code construction that is independent of the channels. As such, the inventors have disclosed herein various encoding and decoding methods, apparatus and computer implementations thereof that provide greatly improved error-correcting performance of RM codes over both previous decoding methods for RM codes and polar codes with the same parameters. The disclosed methods, apparatus and computer implementations thereof also allow for natural parallel implementations, in contrast to the Successive Cancellation List (SCL) decoder of polar codes.

RM codes are a family of error correcting codes that allow for data compression and transmission, such as to facilitate the transfer of information from a transmitter to a receiver over a noisy medium (e.g., as happens in cell phones, computer hard disks, deep-space communications, etc.). The various embodiments provide new decoding methods for RM codes as well as, in some embodiments, modifications of the RM codes themselves. The disclosed methods, apparatus and computer implementations thereof provide excellent performance in low code rate (≤1/2) and short code length (≤1024) regimes.

As described in detail herein, various embodiments comprise systems, methods, apparatus, mechanisms, algorithms and the like for efficiently decoding RM codes over binary input (typically) memoryless channels. Various embodiments are based on projecting the code and reducing its parameters, recursively decoding the projected codes, and aggregating the reconstructions. These exploit in particular the self-similarity structure of RM codes ensuring that quotient space codes for RM codes are again RM codes. Also provided are embodiments further providing list-decoding and code concatenation extensions of the various embodiments.

It is noted that the RPA algorithms/decoders described herein, and variations thereof, with list decoding is able to achieve an optimal performance of maximum likelihood decoding in some of the regimes at low block-length and rate. Further, the RPA algorithms/decoders and variants thereof without list decoding provide improved performance when compared to polar code algorithms/decoders plus CRC, and without requiring the addition of a list decoding procedure. In this manner, the various embodiments provide near optimal performance for practical regimes of parameters, and with an improved computation and power consumption due such as when avoiding list decoding procedures.

The discussion of the various embodiments will be provided in accordance with the following notation and background on RM codes. The term ⊕ is used herein to denote sums over such as a polynomial ring [Z₁, Z₂, . . . , Z_m,] of m variables. Since Z²=Z in , the following set of 2^m monomials forms a basis of [Z₁, Z₂, . . . , Z_m]:

$\left\{\underset{i\in A}{\Pi }{Z}_i\text{:}A\subseteq \left[m\right]\right\},\mathrm{where}\underset{i\in \varnothing }{\Pi }{Z}_i\text{:}=1.$

The next step is to associate every subset A⊆[m] with a row vector v_m(A) of length 2^m, whose components are indexed by a binary vector z=(z₁, z₂, . . . , z_m)∈{0,1}^m. The vector v_m(A) is defined as follows:

v _m(A,z)=Π_i∈Az_i  (eq. 1)

where v_m(A,z) is the component of v_m(A) indexed by z. That is, v_m(A,z) is the evaluation of the monomial Π_i∈AZ_i at z. For 0≤r≤m, the set of vectors

{v_m(A): A⊆[m],|A|≤r}

forms a basis of the r-th order Reed-Muller code RM(m, r) of length n:=2^m and dimension Σ_i=0^r(_i^m).

Definition 1. The r-th order Reed-Muller code RM(m, r) code is defined as the following set of binary vectors:

$\mathrm{RM}\left(m,r\right)\text{:=}\left\{\sum _{A\subseteq \left[m\right],A\le r}u\left(A\right)v_m\left(A\right)\text{:}u\left(A\right)\in \left\{0,1\right\}\approx \mathrm{for}\mathrm{all}A\subseteq \left[m\right],A\le r\right\}.$

In other words, each vector v_m(A) consists of all the evaluations of the monomial Π_i∈AZ_i at all the points in vector space E:=, and each codeword c∈RM(m, r) corresponds to an m variate polynomial with degree at most r. The coordinates of the codeword c are also indexed by the binary vectors z∈E, such that c=(c(z),z∈E). Let B be an s-dimensional subspace of E, where s≤r. The quotient space E/B consists of all the cosets of B in E, where every coset T has form T=z+B for some z E E. For a binary vector y=(z), z E E), we define its projection on the cosets of B as:

y _/B=Proj(y,B):=(y_/B(T),T∈E/B), where y_/B(T):=⊕_z∈Ty(z)  (eq. 2)

which is the binary vector obtained by summing up all the coordinates of y in each coset T∈E/B. Here the sum is over and the dimension of y_/B is n/|B|.

By way of example, if c is a codeword of RM(m, r), then c_/B is a codeword of RM(m−s, r−s), where s is the dimension of B. Various embodiments address the case s=1; namely, one-dimensional subspaces. More precisely, let y=(y(z), z∈E) be the output vector of transmitting a codeword of RM(m, r) over some BSC channel.

FIG. 2 graphically depicts a Recursive Projection-Aggregation decoding algorithm for third order RM codes according to an embodiment. Specifically, FIG. 2 and Algorithm 1 (below) together depict an exemplary decoding algorithm.

The depicted decoding algorithm is defined in a recursive manner: For every one-dimensional subspace B, projection y_/B is obtained. Then the decoding algorithm is used for RM(m−1, r−1) to decode y_/B, where the decoding result is denoted as . Since every one-dimensional subspace of E consists of 0 and a non-zero element, there are n−1 such subspaces in total. After the projection and recursive decoding steps, n−1 decoding results are obtained as ,, . . . , . A majority voting scheme is then used to aggregate these decoding results together with y to obtain a new estimate y of the original codeword. Then y is updated as ŷ, and the entire procedure is performed again for up to N_max rounds. It is noted that if y=ŷ (see line 6), then y is a fixed (stable) point of the algorithm and will remain unchanged for the next iterations. In this case, the iteration is exited at line 1 (see lines 6-8). In various embodiments, a maximal number of iterations is set as Nmax=┌m/2┐ to prevent the program from running into an infinite loop, and typically ┌m/2┐ iterations are enough for the algorithm to converge to a stable y.

This high-level description is summarized in FIG. 2 and Algorithm 1 (below). While this description focuses on the decoding algorithm over BSC, other embodiments discussed below extend the algorithm based on log-likelihood ratios (LLRs) that allow the decoding of RM codes over any binary-input memoryless channels, including the AWGN channel.

Algorithm 1 Pseudo-Code: The RPA_RM Decoding Function For BSC
Input: The corrupted codeword y = (y(z),z ϵ ); the parameters of the Reed-Muller code m and r;
the maximal number of iterations Nmax
Output: The decoded codeword ĉ
1:	for j = 1, 2, . . . , Nmax do
2:	← Proj(y,i) for i = 1, 2, . . . , 2m − 1	Projection
3:	← RPA_RM( , m − 1, r − 1, Nmax) for i = 1, 2, . . . , 2m − 1	Recursive decoding
4:	If r = 2, then we use the Fast Hadamard Transform to decode the first-order RM code [8]
5:	ŷ ← Aggregation(y, ŷ/B1, ŷ/B2, . . . , ŷ/Bn−1)	Aggregation
6:	if y = ŷ then
7:	break	y = ŷ means that the algorithm already converges to a fixed (stable) point
8:	end if
9:	y = ŷ
10:	end for
11:	ĉ ← ŷ
12:	return ĉ

List Decoding Procedure

Various embodiments utilize a list decoding procedure to further decrease decoding error probability. For example, assume a unique decoding algorithm “decodeC” for a codeword C received via a binary-input memoryless channel W: {0,1}→W. Without loss of generality, assume that the algorithm “decodeC” is based on the LLR vector of the channel output, where the LLR of an output symbol x∈W is defined as:

$\begin{array}{cc}\mathrm{LLR}\left(x\right)\text{:=}\ln \left(\frac{w\left(x❘0\right)}{w\left(x❘1\right)}\right)& \left(\mathrm{eq}.3\right)\end{array}$

Clearly, if |LLR(x)| is small, then x is a noisy symbol, and if |LLR(x)| is large, then x is relatively noiseless.

The list decoding procedure works as follows. Suppose that y=(y₁, y₂, . . . , y_n) is the output vector when sent a codeword of C over the channel W. A first step is to sort |LLR_(yi)|, i∈[n] from small to large. Without loss of generality, assume that |LLR(y₁)|, |LLR(y₂)|, |LLR(y₃)| are the three smallest components in the LLR vector, meaning that y₁, y₂ and y₃ are the three most noisy symbols in the channel outputs (taking three arbitrarily). Next, enumerate all the possible cases of the first three bits of the codeword c=(c₁, c₂, . . . , c_n): The first three bits (c₁, c₂, c₃) can be any vector in , so there are 8 cases in total, and for each case change the value of LLR(y₁), LLR(y₂), LIS (y₃) according to the values of c₁, c₂, c₃. More precisely, set LLR(y_i)=(−1)^ciL_max for i=1,2,3, where L_max is some large real number. In practice, various embodiments may choose L_max:=max(|LLR(y_i), i∈[n]) or L_max:=2 max(|LLR(y_i), i∈[n]). For each of these 8 cases, various embodiments use “decodeC” to obtain a decoded codeword, which are denoted as , , . . . , . Finally, various embodiments calculate the posterior probability of Wⁿ(y|), 1≤i≤8, and choose the largest one as the final decoding result; namely, various embodiments perform a maximal likelihood decoding among the 8 candidates in the list.

Binary Symmetric Channels (BSC) Decoding Procedure

This section begins with the definition of the quotient code, and the illustrates how the quotient code of an RM code is also an RM code.

Definition 2. Let s≤r≤m be integers, and let B be an s-dimensional subspace of E:=. A quotient code is defined as:

Q(m,r,B):={c_/B: c∈RM(m,r)}

Lemma 1. Let s≤r≤m be integers, and let B be an s-dimensional subspace of E:=. The code Q(m, r, B) is the Reed-Muller code RM(m−s, r−s).

It is noted that the various embodiments use of the case s=1 in Lemma 1, in addition to using all subspaces and adding an iterative process. Since the RPA_RM decoding function is presented above, the following discussion will be directed to the Aggregation function only, as depicted below with respect to Algorithm 2 below. It is noted that both y_/Bi=(y_/Bi (T), T∈E/B) and =((T), T∈E/B) are indexed by the cosets T∈E/B, and that [z+B] is used to denote the coset containing z (see line 3 of Algorithm 2).

Algorithm 2 Pseudo-Code: The Aggregation Function For BSC
Input: y,  ,  . . . ,
Output: y
1:	Initialize (changevote(z), z ∈ {0, 1}m) as an all-zero vector indexed by z ∈ {0, 1}m
2:	n ← 2m
3:	changevote(z) ← Σi=1n−1  [y/   ([z +  i]) ≠ ŷ/   ([z +  i])] for each z ∈ {0, 1}m
4:	$y\left(z\right)\leftarrow y\left(z\right)\oplus \text{?}\left[\mathrm{changevote}\left(z\right)>\text{?}\right]\mathrm{for}\mathrm{each}z\in {\left\{0,1\right\}}^m$	Here addition is over  2
5:	return y
indicates data missing or illegible when filed

From line 3, it may be seen that the maximal possible value of changevote(z) for each z∈E is n−1. Therefore the condition changevote on line 4 can be viewed as a majority vote. As discussed below, this algorithm may be viewed as one step of a power iteration method to find the eigenvector of a matrix built from the quotient code decoding.

It is noted that Algorithms 1 and 2 are depicted as pseudo codes in a mathematical fashion for the ease of understanding. These pseudo-codes may be implemented as hardware or a combination of hardware and software using almost any programming language as known by those skilled in the art.

Proposition 1. The complexity of Algorithm 1 is O (n^r log n) in sequential implementation and O(n²) in parallel implementation with O(n^r) processors.

Proposition 2. Whether Algorithm 1 outputs the correct codeword or not is independent of the transmitted codeword and only depends on the error pattern imposed by the BSC channel. Specifically, let c∈RM(m, r) be a codeword of the RM code, and let e=(e(z), z∈E) be the error vector imposed on c by the BSC channel. The output vector of the BSC channel is y=c+e. Denote the decoding result as ĉ=RPA_RM(y, m, r, N_max). Then the indicator function of decoding error 1[ĉ≠c] is independent of the choice of c and only depends on the error vector e. It is noted that this proposition is useful for simulations in that a transmission of an all-zero codeword over the BSC channel may be used to measure the decoding error probability.

Algorithm 2 may be viewed as a one-step power iteration of a spectral algorithm. More precisely, it is observed that: , , . . . , contain the estimates of c(z)⊕c(z′) for all z≠z′, where c=(c(z), z∈E) is the transmitted (true) codeword. The estimate of c(z)⊕c(z′) is denoted as .

As an example, to find a vector ŷ=(ŷ(z), z∈E)∈{0,1}ⁿ to agree with as many estimates of these sums as possible is finding a vector ŷ to maximize the following:

|{(z,z′): z≠z′,ŷ(z)ŷ(z′)=}|

It is noted that:

|{(z,z′): z≠z′,ŷ(z)⊕ŷ(z′)=}|+|{(z,z′):≠z′,ŷ(z)⊕ŷ(z′)≠}|=n(n−1)

Therefore:

$\sum _{z\ne z^{\prime }}{\left(-1\right)}^{\hat{y}\left(z\right)+\hat{y}\left(z^{\prime }\right)+}=2\left\{\left(z,z^{\prime }\right)\text{:}z\ne z^{\prime },\hat{y}\left(z\right)\oplus \hat{y}\left(z^{\prime }\right)=\right\}-n\left(n-1\right)$

Thus the task is to find:

$\begin{array}{cc}\arg {\max }_{\hat{y}\in {\left\{0,1\right\}}^n{\sum }_{z\ne z^{\prime }}{\left(-1\right)}^{\hat{y}\left(z\right)+\hat{y}\left(z^{\prime }\right)+}}& \left(\mathrm{eq}.4\right)\end{array}$

Given a vector ŷ∈{0,1}ⁿ, we define another vector û∈{−1,1}ⁿ by setting û(z):=(−1)^ŷ(z) for all z∈E. In order to find the maximizing vector ŷ in (eq. 6), it suffices to find

argmax_{û∈{−1,1}nΣz≠z′(−}û(z)û(z′)  (eq. 5)

Now an n×n matrix A is built from {:z,z′∈E,z≠z′} as follows: The rows and columns of A are indexed by z∈E, and the following entry is set:

$A_{z,z^{\prime }}\text{:=}\{\begin{array}{cc}{\left(-1\right)}^{i_{z.,z^{\prime }}}& \mathrm{if}z\ne z^{\prime }\\ 0& \mathrm{if}z=z^{\prime }\end{array}$

That is, for z≠z′ there is set A_z,z′′=1 if =0, and A_z,z′=−1 if =1. Under this definition, the optimization problem (eq. 5) becomes:

argmax_{û∈{−1,1}nΣz≠z′Az,z′}û(z)û(z′)=argmax_{û∈{1,−1}n}Aû  (eq. 6)

It is well known that this combinatorial optimization problem is NP-hard. In practice, a reasonable approach is to use the following spectral relaxation to obtain approximate solution:

argmax_{û∈Rn,|û|2=n}Aû

A solution to this relaxed optimization problem is the eigenvector corresponding to the largest eigenvalue of A. One way to find this eigenvector is to use the power iteration method: that is, pick some vector v (e.g., at random), then A^tv converges to this eigenvector when t is large enough. After rescaling A^tv to make |A^tv|²=n, obtain the maximizing vector ũ=A^tv in the relaxed optimization problem. In order to obtain the solution to the original optimization problem in (eq. 6), the embodiments only need to look at the sign of each coordinate of ũ: If ũ(z)>0, then set û(z)=1, and if ũ(z)<0, then set û(z)=−1. In this manner, the vector 1.1 that serves as an approximate solution to (eq. 6) is obtained. To summarize, an approximate solution to (eq. 6) isû=sign(A^tv), where v is some random vector and t is some large enough integer.

Denoting the output vector of Algorithm 2 as y, and defining another vector ū as ū(z)=(−1)^y(z) for all z∈E. For the original received vector y, also defined is a vector u as u(z)=(−1)^y(z) for all z∈E. An important observation in this section is that:

ū=sign(Au)  (eq. 7)

That is, the output of Algorithm 2 is in fact the same as a one-step power iteration of the spectral algorithm with the original received vector u playing the role of vector v above. It is also easy to see why (eq. 7) holds: According to (eq. 7), ū(z)=1 if Σ_z′≠z(−^⊕y(z′)>0 and ū(z)=−1 otherwise. This is equivalent to saying that

$\stackrel{\_}{y}\left(z\right)=0\mathrm{if}\left\{z^{\prime }\text{:}{z}^{\prime }\ne z,\oplus y\left(z^{\prime }\right)=0\right\}>\frac{n-1}{2}$

and ū(z)=1 otherwise. The vector y given by this rule is exactly the same as the output vector of Algorithm 2.

General Binary-Input Memoryless Channel Decoding Procedure

The decoding algorithm is directed to BSC, whereas this section will present an extension of Algorithm 1 that is suitable for use in decoding any binary-input memoryless channels and is based on LLRs (see (eq. 3) above). Similarly to Algorithm 1, the general algorithm is also defined recursively in that it we first assumes knowledge for decoding the (r−1)-th order Reed-Muller code, after which it may be used to decode the r-th order Reed-Muller code. It is noted that a soft-decision FHT decoder may be used to allow for the decoding of the first order RM code efficiently for general binary-input channels. The soft-decision FHT decoder may be based on LLR, and the complexity is also O(n log n), as with as the hard-decision FHT decoder.

An FHT decoder for first order RM codes may be used. Specifically, various embodiments use c=(c(z), z∈E) to denote the transmitted (true) codeword and y=(y(z), z∈E) to denote the corresponding channel output. Given the output vector y, the ML decoder for first order RM codes aims to find c∈RM(m, 1) to maximize Π_z∈E W(y(z)|c(z)). This is equivalent to maximizing the following quantity:

$\underset{z\in E}{\Pi }\frac{W\left(y\left(z\right)❘c\left(z\right)\right)}{\sqrt{Q\left(y\left(z\right)❘0\right)w\left(y\left(z\right)❘1\right)}}$

which is further equivalent to maximizing:

$\begin{array}{cc}{\sum }_{z\in E}\ln \left(\frac{w\left(y\left(z\right)|c\left(z\right)\right)}{\sqrt{w\left(y\left(z\right)|0\right)w\left(y\left(z\right)|1\right)}}\right)& \left(\mathrm{eq}.8\right)\end{array}$

It is noted that codeword c is a binary vector. Therefore:

$\ln \left(\frac{W\left(y\left(z\right)❘c\left(z\right)\right)}{\sqrt{W\left(y\left(z\right)❘0\right)W\left(y\left(z\right)❘1\right)}}\right)=\{\begin{array}{cc}\frac{1}{2}\mathrm{LLR}\left(y\left(z\right)\right)& \mathrm{if}c\left(z\right)=0\\ -\frac{1}{2}\mathrm{LLR}\left(y\left(z\right)\right)& \mathrm{if}c\left(z\right)=1\end{array}.$

where the shorthand notation may be expressed as:

L(z):=LLR(y(z)),

and the formula in (eq. 8) may be written as:

$\begin{array}{cc}\frac{1}{2}\sum _{z\in E}\left({\left(-1\right)}^{c\left(z\right)}L\left(z\right)\right),& \left(\mathrm{eq}.9\right)\end{array}$

such that the goal is to find c∈RM(m, 1) to maximize this quantity.

Every c∈RM(m, 1) corresponds to a polynomial in [Z₁, Z₂, . . . , Z_m] of degree one, so every codeword c may be expressed as a polynomial u₀+Σ_i=1^mu_iZ_i. In this manner, therefore c(z)=u₀+Σ_i=1^mu₁z_i, where z₁, z₂, . . . , z_m are the coordinates of the vector z. The task then becomes finding u₀, u₁, u₂, . . . , u_m∈F₂ to maximize the following:

$\begin{array}{cc}\sum _{z\in E}\left({\left(-1\right)}^{u_0+{\sum }_{i=1}^m{u}_i{z}_i}L\left(z\right)\right)={\left(-1\right)}^{u_0}\sum _{z\in E}\left({\left(-1\right)}^{{\sum }_{i=1}^m{u}_i{z}_i}L\left(z\right)\right)& \left(\mathrm{eq}.10\right)\end{array}$

For a binary vector u=(u₁, u₂, . . . , u_m)∈E, the following is defined:

$\hat{L}\left(u\right):=\sum _{z\in E}\left({\left(-1\right)}^{{\sum }_{i=1}^m{u}_i{z}_i}L\left(z\right)\right).$

To find the maximizer of (eq. 10), a calculation may be made of {circumflex over (L)}(u)forallu∈E. Since the vector ({circumflex over (L)}(u), u∈E) is exactly the Hadamard Transform of the vector (L(z), z∈E), this calculation may be made using the Fast Hadamard Transform with complexity O(n log n). Once the values of ({circumflex over (L)}(u), u∈E) are known, a value u*=(u₁*, u₂*, . . . , u_m*)∈E that maximizes |{circumflex over (L)}(u)| may be found. If {circumflex over (L)}(u*)>0, then the decoder outputs the codeword c corresponding to u₀*=0, u₁*, u₂*, . . . , u_m*. Otherwise, the decoder outputs the codeword c corresponding to u₀*=1, u₁*, u₂*, . . . , u_m*. Thus, various embodiments decode first order RM codes for general channels in this manner.

The next problem is how to extend (eq. 2) in a general setting. The purpose of (eq. 2) is mapping two output symbols (y(z), z∈T) whose indices are in the same coset T E E/B to one symbol. This reduces the r-th order RM code to an r−1-th order RM code. For BSC, this mapping is simply the addition in F₂. The sum y_/B(T) may be interpreted as an estimate of c_/B (T), where c is the transmitted (true) codeword. In other words:

((T)=(T))>((T)=(T)⊕1)

where Y is the channel output random vector.

For general channels, a desired estimate of c_/B (T) is based on the LLRs (L (z), z∈T). More precisely, given (y(z), z∈T), or equivalently given (L(z), z∈T), it is desired to calculate the following LLR:

$L_{/B}\left(T\right):=\ln \left(\frac{P\left(Y\left(z\right)=y\left(z\right),z\in T|c_{/B}\left(T\right)=0\right)}{P\left(Y\left(z\right)=y\left(z\right),z\in T|c_{/B}\left(T\right)=1\right)}\right)$

where Y is the channel output random vector.

Lemma 2. Suppose that r≥1. Let C be a random codeword chosen uniformly from RM(m, r), and let z and z′ be two distinct vectors in E. Then the two coordinates (C(z), C(z′)) of the random codeword C have i.i.d. Bernoulli-$1/2$ distribution.

By way of proof of Lemma 2, first define the following four sets:

A(0,0):={c∈RM(m,r): c(z)=c(z′)=0},

A(0,1):={c∈RM(m,r): c(z)=0,c(z′)=1},

A(1,0):={c∈RM(m,r): c(z)=1,c(z′)=0},

A(1,1):={c∈RM(m,r):c({z})=c({z}′)=1}.

To prove this lemma, it is only necessary to show that |A(0,0)|=|A(0,1)|=|A(1,0)|=|A(1,1)|. Since RM code is linear and the all one vector is a codeword of RM codes, the marginal distribution of the coordinate C(z) is Bernoulli-1/2 for every z∈E. Thus providing the following:

|A(0,0)|+|A(0,1)|=|A(1,0)|+|A(1,1)|,

|A(0,0)|+|A(1,0)|=|A(0,1)|+|A(1,1)|.  (eq. 11)

Taking z=(z₁, . . . , z_m) and z′=z₁, . . . , z_m′) such that z≠z′, there exists i∈[m] such that z_i≠z_i′. Since it is assumed that r≥1, RM(m, r) contains the evaluation vector of the degree-1 monomial Z_i, evaluation vector is denoted as v, and it is known that v(z)≠v(z′). Without loss of generality, it is assumes that v(z)=0 and v(z′)=1. Then (given that for a set A and a vector v there is defined a set A+v:={a+v: a∈A}), it may be stated that A(0,0)+v⊆A(0,1), such that |A(0,0)|≤|A(0,1)|. Conversely, it may also be stated that A(0,1)+v⊆A(0,0), such that |A(0,1)|≤|A(0,0)|. Therefore, |A(0,1)|=|A(0,0)|. Similarly, it can be shown that |A(1,1)|=|A(1,0)|. Taking these into (eq. 11) the following is obtained: |A(0,0)|=|A(0,1)|=|A(1,0)|=|A(1,1)|, which completes the proof of Lemma 2.

L_/B (T) may now be calculated using the following model: Assume that S₁ and S₂ are i.i.d. Bernoulli-1/2 random variables, and transmitted over two independent copies of the channel W: {0,1}→W. The corresponding channel output random variables are denoted as X₁ and X₂, respectively. Then for x₁, x₂∈W,

$\ln \left(\frac{\mathbb{P}\left(X_1=x_1,X_2=x_2❘S_1+S_2=0\right)}{\mathbb{P}\left(X_1=x_1,X_2=x_2❘S_1+S_2=1\right)}\right)=\ln \left(\frac{\mathbb{P}\left(X_1=x_1,X_2=x_2,S_1+S_2=0\right)}{\mathbb{P}\left(X_1=x_1,X_2=x_2,S_1+S_2=1\right)}\right)=\ln \left(\frac{\begin{array}{c}\mathbb{P}\left(X_1=x_1,X_2=x_2,S_1=0,S_2=0\right)+\\ \mathbb{P}\left(X_1=x_1,X_2=x_2,S_1=1,S_2=1\right)\end{array}}{\begin{array}{c}\mathbb{P}\left(X_1=x_1,X_2=x_2,S_1=0,S_2=1\right)+\\ \mathbb{P}\left(X_1=x_1,X_2=x_2,S_1=1,S_2=0\right)\end{array}}\right)=\ln \left(\frac{\frac{1}{4}W\left(x_1❘0\right)W\left(x_2❘0\right)+\frac{1}{4}W\left(x_1❘1\right)W\left(x_2❘1\right)}{\frac{1}{4}W\left(x_1❘0\right)W\left(x_2❘1\right)+\frac{1}{4}W\left(x_1❘1\right)W\left(x_2❘0\right)}\right)=\ln \left(\frac{\frac{W\left(x_1❘0\right)W\left(x_2❘0\right)}{W\left(x_1❘1\right)W\left(x_2❘1\right)}+1}{\frac{W\left(x_1❘0\right)}{W\left(x_1❘1\right)}+\frac{W\left(x_2❘0\right)}{W\left(x_2❘1\right)}}\right)=\ln \left(\exp \left(\mathrm{LLR}\left(x_1\right)+\mathrm{LLR}\left(x_2\right)\right)+1\right)-\ln \left(\exp \left(\mathrm{LLR}\left(x_1\right)\right)+\exp \left(\mathrm{LLR}\left(x_2\right)\right)\right).$

Lemma 2 above allows the replacement of x₁, x₂ with (y(z), z∈T), such that the following is obtained:

$\begin{array}{cc}{L}_{/B}\left(T\right)=\ln \left(\exp \left(\sum _{z\in T}L\left(z\right)\right)+1\right)-\ln \left(\sum _{z\in T}\exp \left(L\left(z\right)\right)\right).& \left(\mathrm{eq}.12\right)\end{array}$

The following is a decoding algorithm for general binary-input channels according to an embodiment. Specifically, in Algorithms 3 and 4 (below), the decoding result of the (r−1)-th order RM code is denoted as (e.g., see line 7 of Algorithm 3), where =((T), T∈E/B) are indexed by the cosets T∈E/B, and [z+B] is used to denote the coset containing z (e.g., see line 3 of Algorithm 4).

Algorithm 3 is similar to Algorithm 1: From line 8 to line 10 there is a comparison of {circumflex over (L)}(z) with the original L (z). If the relative difference between these two is below the threshold θ for every z∈E, then the values of L (z), z∈E change very little in the instant iteration, and the algorithm reaches a “stable” state, such that it exits the for-loop on line 2. Various embodiments use θ=0.05 and we a maximal number of iterations N_max=m/2, which is the same as in Algorithm 1. It is noted that greater or lesser values may be selected for use in different embodiments. The inventors note that the decoding error probability is non-increasing when decreasing the value of θ, and the running time of the algorithm increases when decreasing θ. Simulations provide that the decoding error probability remains the same if continued decreasing of θ beyond 0.05, therefore θ=0.05 is a reasonable choice in many embodiments since a smaller θ will only increase the running time while not appreciably decreasing decoding error. On line 13, the algorithm simply produces the decoding result according to the LLR at each coordinate.

With respect to Algorithm 4, at line 3 the algorithm sets cumuLLR(z)=Σ_z′≠zα(z, z′)L(z′), where the coefficients α(z, z′) can only be 1 or −1. More precisely, α(z, z′) is 1 if the decoding result of the corresponding (r−1)-th order RM code at the coset {z, z′} is 0, and α(z, z′) is −1 if the decoding result at the coset {z, z′} is 1. Thus, the decoding result at the coset {z, z′} is an estimate of c(z)⊕c(z′). If c(z)⊕c(z′) is more likely to be 0, then the sign of L(z) and L(z′) should be the same. Here cumuLLR(z) serves as an estimate of L(z) based on all the other L(z′), z′ # z, so we assign the coefficient α(z, z′) to be 1. Otherwise, if c(z)⊕c(z′) is more likely to be 1, then the sign of L(z) and L(z′) should be different, so assign the coefficient α(z, z′) to be −1.

It is noted that Algorithms 3 and 4 are depicted as pseudo codes in a mathematical fashion for the ease of understanding. These pseudo-codes may be implemented as hardware or a combination of hardware and software using almost any programming language as known by those skilled in the art.

Proposition 3. The complexity of Algorithm 3 is O(n^r log n) in sequential implementation and O(n²) in parallel implementation with O(n^r) processors. It is also noted that the decoding error probability of Algorithm 3 is independent of the transmitted codeword for binary-input memoryless symmetric (BMS) channels. In various embodiments, the complexity is reduced by one or more of: jumping layers, taking larger subspaces, taking only a subset of projections, or combining the projections with other decompositions such as a Plotkin decomposition.

Algorithm 3 Pseudo-Code: The RPA_RM Decoding
Function For General Binary-Input Memoryless Channels
Input: The LLR vector (L(z), z ϵ {0, 1}m); the parameters of the Reed-Muller code m and r;
the maximal number of iterations Nmax; the exiting threshold θ
Output: The decoded codeword ĉ
1:	:= {0, 1}m
2:	for j = 1, 2, . . . , Nmax do
3:	i ← (i (T), T ϵ /i) for i = 1, 2, . . . , 2m − 1	Projection
4:	i(T) is calculated from (L(z), z ϵ ) according to (12)
5:	← RPA_RM(i, m − 1, r − 1, Nmax, θ) for i = 1, 2, . . . , 2m − 1	Recursive decoding
6:	If r = 2, then we use the Fast Hadamard Transform to decode the first-order RM code
7:	L ← Aggregation(L, , , . . . n−1)	Aggregation
8:	if |{circumflex over (L)}(z) − L(z)| ≤ θ|L(z)| for all z ϵ  then	The algorithm reaches a stable point
9:	break
10:	end if
11:	L ← {circumflex over (L)}
12:	end for
13:	ĉ(z) ← [L(z) < 0] for each z ϵ
14:	return ĉ

Algorithm 4 Pseudo-Code: The Aggregation Function For General Binary-Input
Memoryless Channels
Input: L, y/  , y/   . . . ,
Output: {circumflex over (L)}
1: Initialize (cumuLLR(z), z ∈ {0, 1}m) as an all-zero vector indexed by z ∈ {0, 1}m
2: n ← 2m
3: cumuLLR(z) ← Σi=1n−1 ((1 − 2ŷ/   ([z +   i]))L(z ⊕ zi)) for each z ∈ {0, 1}m
4: zi is the nonzero element in   i
5: ŷ/   is the decoded codeword, so ŷ/   ([z +   i]) is either 0 or 1
6: ⁢                                                  (                          z                          )                                                                    ←                                                                                                    cumuLLR                            ⁡                                                          (                              z                              )                                                                                                            n                            -                            1                                                                          ⁢                                                                                                  ⁢                        for                        ⁢                                                                                                  ⁢                        each                        ⁢                                                                                                  ⁢                        z                                                              ∈                                                                  {                                                  0                          ,                          1                                                }                                            m
7: return
indicates data missing or illegible when filed

Proposition 4. The decoding error probability of Algorithm 3 is independent of the transmitted codeword for binary-input memoryless symmetric (BMS) channels.

Definition 3. A memoryless channel W: {0,1}→W is a BMS channel if there is a permutation π of the output alphabet W such that π{circumflex over ( )}{−1}=π$ and $W (x|1)=W(π(x)|0) for all x∈W.

Proposition 4. Let W: {0,1}→W be a BMS channel. Let c₁ and c₂ be two codewords of RM(m,r). Let Y₁ and Y₂ be the (random) channel outputs of transmitting c₁ and c₂ over n=2^m independent copies of W, respectively. Let L⁽¹⁾ and L⁽²⁾ be the LLR vectors corresponding to Y₁ and Y₂, respectively (it is noted that Y₁ and Y₂ are random vectors, that the randomness comes from the channel noise and, as a result, L⁽¹⁾ and L⁽²⁾ are also random vectors). Then for any c₁, c₂∈RM (m, r), it can be stated that:

−P(RPA_RM(L⁽¹⁾,m,r,N_max,θ)≠c₁)=P(RPA_RM(L⁽²⁾,m,r,N_max,θ)≠c₂)

It is noted that this proposition is useful for simulations in that a transmission of an all-zero codeword over the BMS channel W may be used to measure the decoding error probability.

The above description presents a list decoding version of the RPA_RM function. Since the main concept has been described above with respect to the other Propositions, what is provided herein below will be directed toward the pseudo code of the list decoding version. It is noted that the purpose of line 8 of Algorithm 5 is to make sure that is a codeword of RM code, which is not always true for the decoding result of the RPA_RM function.

Finally, we present the following proposition on the memory requirement for sequential implementation of RPA decoder. A remarkable thing here is that the memory requirement for the list decoding version of RPA algorithm is 5n, which is independent of the list size, in contrast to, for example, an SCL decoder of polar codes.

Proposition 5. The memory needed for sequential implementation of the RPA decoder without list decoding is no more than 4n, and the memory needed for sequential implementation of the RPA decoder with list decoding is no more than 5n, where n is the code length. Note that the memory requirement for list decoding version does not depend on the list size.

As noted above, Algorithm 3 is written in compact fashion for the ease of understanding, but it is not space-efficient in practical implementation. A more robust algorithm is provided below as Algorithm 9, upon which various analysis of space complexity provided herein is generally based.

The most important difference between Algorithm 3 and Algorithm 9 is that in Algorithm 3 contemplates finishing of all the recursive decoding first, and then performing the aggregation step. By contrast, in Algorithm 9 the recursive decoding step and the aggregation step are interleaved together such that a significant amount of memory is conserved as compared to Algorithm 3.

A proof may start with an RPA decoder without list decoding, and may then prove by induction on r, the order of the RM code. For the base case of r=1, the claim clearly holds. Now assume that the claim holds for all RM codes with order <r and prove it for order r. In Algorithm 9, there is needed n floating number positions to store the LLR vector and another n floating number positions to store the cumuLLR vector. Then the codewords are projected onto the cosets of each one-dimensional subspace sequentially. For each projected codeword, there is a need to decode a RM code with length n/2 and order r−1. By induction hypothesis, this takes 4*n/2=2n floating number positions. Therefore in total there is needed n+n+2n=4n floating number positions. This establishes the inductive step and completes the proof for the non-list-decoding version.

The memory requirement for list decoding version follows directly from that of initial embodiments described above: Since list decoding is performed sequentially (i.e., only decode one list at a time), the only extra memory needed in the list decoding version is the n floating number positions that are used to store a currently best known decoding result. Therefore, the space complexity for the list decoding version is 5n.

Simplified RPA Algorithm for High Rate RM Codes

This section provide some simplified versions of the RPA decoder, which significantly accelerate the decoding process while maintaining the same (nearly optimal) decoding error probability for certain RM codes with rate >0.5.

As previously discussed, the decoding algorithm may be accelerated by using fewer subspaces in the projection step. Moreover, instead of using one-dimensional subspaces, various embodiments use a selected subsets of two-dimensional subspaces in the projection step. In particular, various embodiments only project onto the

$\left(\begin{array}{c}m\\ 2\end{array}\right)\hspace{1em}$

two-dimensional subspaces spanned by two standard basis vectors of E. The standard basis vector of E are e⁽¹⁾, . . . , e^(m), where e⁽ⁱ⁾ is defined as the vector with 1 in the i-th position and 0 everywhere else. Then the

$\left(\begin{array}{c}m\\ 2\end{array}\right)\hspace{1em}$

two-dimensional subspaces may be written as {B_i,j: 1≤i<j≤m}, where:

B _i,j:=span(e⁽ⁱ⁾,e^(j))

Algorithm 5 Pseudo-Code: The RPA_LIST Decoding
Function For General Binary-Input Memoryless Channels
Input: The LLR vector (L(z), z ϵ {0, 1}m); the parameters of the Reed-Muller code m and r;
the maximal number of iterations Nmax; the exiting threshold θ: the list size 2t
Output: The decoded codeword ĉ
1:	{circumflex over (L)} ← L
2:	(z1, z2, . . . , zi) ← indices of the t smallest entries in (|L(z)|,z ϵ {0,1}m)
3:	zi ϵ {0, 1}m for all i = 1, 2, . . . , t
4:	Lmax ← 2 max(|L(z)|, z ϵ {0, 1}m)
5:	for each u ϵ {Lmax, − Lmax}i do
6:	(L(z1), L(z2), . . . , L(zi)) ← u
7:	ĉ(u) ← RPA_RM(L, m, r, Nmax, θ)
8:	ĉ(u) ← Reedsdecoder (ĉ(u))	Reedsdecoder is the classical decoding algorithm in [1]
9:	end for
10:	u* ← argmaxu Σzϵ{0,1}m ((−1)abey(z){circumflex over (L)}(z))
11:	This follows from (9), Maximization is over u ϵ {Lmax, − Lmax}t
12:	ĉ ← ĉ(u*)
13:	return ĉ

It is noted that projection onto cosets of two-dimensional subspaces is different from onto that of one-dimensional subspaces: In the one-dimensional case, each coset only contains two coordinates, and the embodiment only needs to combine the LLR of two coordinates to obtain the LLR of the coset, as per (eq. 12). In the two-dimensional case, each coset contains four coordinates, and the embodiment needs to combine the LLR of four coordinates to obtain the LLR of the coset. Fortunately, the embodiment can use exactly the same idea as in the proof of Lemma 2 (above) to show that any four coordinates in a coset of a two-dimensional subspace are also independent. Therefore, the following counterpart of (eq. 12) may be obtained for a coset T of two-dimensional subspace assuming that

$\begin{array}{cc}T=\left\{z^{\left(1\right)},z^{\left(2\right)},z^{\left(3\right)},z^{\left(4\right)}\right\}\text{:}& \left(\mathrm{eq}.13\right)\\ L_{/𝔹}\left(T\right)=\ln \left(\exp \left(\sum _{i=1}^{4}L\left(z^{\left(i\right)}\right)\right)+\sum _{i\le i<j\le 4}\exp \left(L\left(z^{\left(i\right)}\right)+L\left(z^{\left(j\right)}\right)\right)+1\right)-\ln \left(\sum _{i=1}^4\exp \left(L\left(z^{\left(i\right)}\right)\right)+\sum _{i=1}^4\exp \left(\sum _{j\in \left[4\right]\backslash \left\{i\right\}}L\left(z^{\left(j\right)}\right)\right)\right).& \end{array}$

After projecting RM(m, r) onto the cosets of these two-dimensional subspaces, there is obtained RM codes with parameters m−2 and r−2, as proved in Lemma 1. After decoding these

$\left(\begin{array}{c}m\\ 2\end{array}\right)\hspace{1em}$

projected codes RM(m−2, r−2), there is obtained {: 1≤i<j≤m}, where =((T),T∈E/B_i,j). The procedure then moves to the aggregation step using both the recursive decoding result {: 1≤i<j≤m} and the original LLR vector L. In particular, when decoding c(z), the relevant coordinate in is ([z+B_i,j]), where [z+B_i,j] is the coset of B_i,j that contains z. Now suppose that the other three vectors in [z+B_i,j] apart from z itself are z⁽¹⁾, z⁽²⁾,z⁽³⁾. Then from ([z+B_i,j]) and L(z⁽¹⁾), L(z⁽²⁾), L(z⁽³⁾), is obtained the following estimate of the LLR of c(z):

$\begin{array}{cc}{L}_{/𝔹}\left(T\right)=\ln \left(\exp \left(\sum _{i=1}^{4}L\left(z^{\left(i\right)}\right)\right)+\sum _{1\le i<j\le 4}\exp \left(L\left(z^{\left(i\right)}\right)+L\left(z^{\left(j\right)}\right)\right)+1\right)-\ln \left(\sum _{i=1}^4\exp \left(L\left(z^{\left(i\right)}\right)\right)+\sum _{i=1}^4\exp \left(\sum _{j\in \left[4\right]\backslash \left\{i\right\}}L\left(z^{\left(j\right)}\right)\right)\right).& \left(\mathrm{eq}.14\right)\end{array}$

Algorithm 6 Pseudo-Code: A Simplified RPA Decoding Function
Input: The LLR vector (L(z), z ϵ {0, 1}m); the parameters of the Reed-Muller code m and r;
the maximal number of iterations Nmax; the exiting threshold θ
Output: The decoded codeword ĉ
1:	:= {0, 1}m
2:	for j = 1, 2, . . . , Nmax do
3:	i,j ← (i,j(T), (T) ϵ / i,j) for 1 ≤ i < j ≤ m	Projection
4:		i,j (T) is calculated according to (13)
5:	ŷ/i,j ← Simplified_RPA(i,j, m − 2, r − 2, Nmax, θ) for 1 ≤ i < j ≤ m
6:		Recursive decoding
7:	If r = 3, then we use the Fast Hadamard Transform to decode the first-order RM code
8:	If r = 4, then we use the normal RPA algorithm to decode the second-order RM code
9:	{circumflex over (L)} ← Simp_Aggregation(L1, {i,j : 1 ≤ i < j ≤ m})	Aggregation
10:	if |{circumflex over (L)}(z) − L(z)| ≤ θ|L(z)| for all z ϵ  then	The algorithm reaches a stable point
11:	break
12:	end if
13:	L ← {circumflex over (L)}
14:	end for
15:	ĉ(z) ← [L(z) < 0] for each z ϵ
16:	return ĉ

Algorithm 7 Pseudo-Code: A Simplified_Aggregation
Function In The Simplified_RPA Algorithm
Input: L, {i,j    1 ≤ i < j ≤ m}
Output: {circumflex over (L)}
1: Calculate Esti,j(z) from L and {i,j    1 ≤ i < j ≤ m}
   according to (14)
2: L                          ^                                                ⁡                                                  (                          z                          )                                                                    ←                                                                        ?                                                ⁢                                                                              ∑                                                          1                              ≤                              i                              ≤                              j                              ≤                              m                                                                                ⁢                                                                                                                    Est                                                                  i                                  ,                                  j                                                                                            ⁡                                                              (                                z                                )                                                                                      ⁢                                                                                                                  ⁢                            for                            ⁢                                                                                                                  ⁢                            each                            ⁢                                                                                                                  ⁢                            z                                                                                                                ∈                                                                  {                                                  0                          ,                          1                                                }                                            m
3: return {circumflex over (L)}
indicates data missing or illegible when filed

The embodiments may calculate such an estimate for all pairs of (i, j) such that 1≤i<j≤m. Then finally we update the LLR of c(z) as the average of these

$\left(\begin{array}{c}m\\ 2\end{array}\right)\hspace{1em}$

estimates, as follows:

$\hat{L}\left(z\right)=\frac{1}{\left(\begin{array}{c}m\\ 2\end{array}\right)}\sum _{1\le i<i\le m}Es{t}_{i,j}\left(z\right).$

Finally, as in all the previous sections, the embodiments may iterate this decoding procedure a few times for the LLR vector to converge to a stable value. Various embodiments may utilize quantization techniques to approximate these values and/or the LLRs to further improve decoder efficiency.

The decoding algorithm proposed in this section are denoted as the Simplified_RPA algorithm, rather than the normal RPA algorithm proposed in the previous section. It is noted that in the recursive decoding procedure (i.e., when decoding RM(m−2, r−2)) the embodiments may still use this simplified version of RPA algorithm instead of performing a full projection step. Since each time r is reduced by 2, if the original r is even then the procedure will not reach the first-order RM codes. In this case, the procedure uses the normal RPA decoder when it reaches the second-order RM codes.

In Algorithms 6 and 7 there is provided pseudo-codes for the Simplified_RPA algorithm. It is noted that in lines 7-8 of Algorithm 6, there is distinction made between the cases of r being even and r being odd: For even r, eventually the procedure will need to decode a second-order RM code using the normal RPA decoder, while for odd r, the procedure only needs to decode first-order RM code in the final recursive step.

As is shown herein, by applying the list decoding version of the Simplified_RPA algorithm, the various embodiments may decode RM(7,4) and RM(8,5) with list size no larger than 8 such that the decoding error probability is the same as that of ML decoder. Moreover, this version runs even faster than decoding lower rate codes such as RM(8,3).

Algorithm 8 Pseudo-Code: The RPA_RM Decoding Function For BSC
Input: The corrupted codeword y = (y(z), z ∈ {0, 1}m): the parameters of the Reed-Muller code m
and r: the maximal number of iterations Nmax
Output: The decoded codeword ĉ
1:  for i = 1, 2, . . . , Nmax do
2:  Initialize (changevote(z), z ∈ {0, 1}m) as an all-zero vector indexed by z ∈ {0, 1}m
3:  for each non-zero z0 ∈ {0, 1}m do
4:  Set    = {0, z0}
5:  ← RPA_RM(  , m − 1, r − 1, Nmax)
6:  if r = 2, then we use the Fast Hadamard Transform to decode the first-order RM code[8]
7:  for each z ∈ {0, 1}m do
8:  if y/  ([z +  ]) ≠  ([z +  ]) then
9:  changevote(z) ← changevote(z) +1      Here addition is between real numbers
10: end if
11: end for
12: end for
13: numofchange ← 0
14: n ← 2m
15: for each z ∈ {0, 1}m do
16: if⁢⁢changevote⁡(z)>n-12⁢⁢then
17: y(z) ← y(z) ⊕ 1                     Here addition is over  2
18: numofchange ← numofchange + 1        Here addition is between real numbers
19: end if
20: end for
21: if numofchange = 0 then
22: break                     Exit the first for loop of this function
23: end if
24: end for
25: ← y
26: return
indicates data missing or illegible when filed

Algorithm 9 Pseudo-Code: The RPA_RM Decoding Function For General Binary-Input
Memoryless Channels
Input: The LLR vector (L(z), z ∈ {0, 1}m): the parameters of the Reed-Muller code m
and r: the maximal number of iterations Nmax: the exiting threshold θ
Output: the decoded codeword    = (  (z), z ∈ {0, 1}m)
1:  := {0, 1}m
2:  for i = 1, 2, . . . , Nmax do
3:  Initialize (cumuLLR(z), z ∈   ) as an all-zero vector indexed by z ∈
4:  for each non-zero zθ ∈    do
5:  Set    = {0, zθ}
6:  ← (   (T), T ∈   /  )       (T) is calculated from (L(z), z ∈   ) according to (12)
7:  ← RPA_RM(  , m − 1, r − 1, Nmax, θ)
8:  if r = 2, then we use the Fast Hadamard Transform to decode the first-order RM code
9:  for each z ∈    do
10: if   ([z +  ]) = 0 then
11: cumuLLR(z) ← cumuLLR(z) + L(z ⊕ zθ)
12: else             is the decoded codeword, so   ([z +  ]) is either 0 or 1
13: cumuLLR(z) ← cumuLLR(z) − L(z ⊕ zθ)
14: end if
15: end for
16: end for
17: numofchange ← 0
18: n ← 2m
19: for each z ∈    do
20: cumuLLR⁡(z)←?
21: if |cumuLLR(z) − L(z)| >θ|L(z)| then
22: numofchange ← numofchange + 1         Here addition is between real numbers
23: end if
24: L(z) ← cumuLLR(z)
25: end for
26: if numofchange = 0 then
27: break                      Exit the first for loop of this function
28: end if
29: end for
30: for each z ∈    do
31: if L(z) > 0 then
32: (z) ← 0
33: else
34: (z) ← 1
35: end if
36: end for
37: return
indicates data missing or illegible when filed

Parallelization and acceleration. Advantageously, the various embodiments contemplate a decoding algorithm for RM codes that naturally allows parallel implementation, whereas the SCL decoder for polar codes is not parallelizable. An important step in various embodiments for decoding a codeword of RM(r,m) is to decode the quotient space codes which are in RM(r−1,m−1) codes, which can be decoded in parallel. Such a parallel structure is enables the achieving of high throughput with low latency.

Another way to accelerate the algorithm is to use only certain “voting sets”—that is, in the projection step, a subset of one-dimensional subspaces is selected instead of all the one-dimensional subspaces. Recursive decoding is still used, followed by the aggregation step. In this manner, the various embodiments may decode fewer RM(r−1,m−1) codes while, if the voting sets are chosen properly, obtaining a similar decoding error probability with shorter running time. An example of a concrete choice of voting is discussed above with respect to Algorithm 6, which indeed accelerates the decoding of high-rate RM codes with nearly-ML decoding error probability.

Various embodiments are especially well suited to RM(8,2) decoding since this is nearly optimal in terms of code length in the sense that the lower bound of code length is 251, which differs from the actual code length of RM codes by only 5. RM(9,2) is also close to optimal, where the lower bound on code length is 500. However, for RM codes with larger order (dimension) and larger code length, the lower bound differs from the actual code length by at least 50 such as, for example, RM(9,3) where the lower bound becomes 464.

Various embodiments make use of one-dimensional subspace reduction as discussed above. In further embodiments, changes may be made to the , . . . in the RPA decoding algorithms to any of the s-dimensional subspaces, with different combinations possible. In above sections according to these embodiments the usual choice was s=2, though s=3, s=4 and the like may also be used.

Various embodiments of the RPA decoding algorithms may also be used to decode other codes that are supported on a vector space, or any code that has a well-defined notion of “code projection” that can be iteratively applied to produce eventually a “trivial” code (i.e., one that can be decoded efficiently). In the case of RM codes, the quotient space projection has the specificity of producing again RM codes, and the trivial code is the Hadamard code that can be decoded using the FHT.

Various embodiments contemplate spectral decompositions and/or other relaxations in the Aggregation step instead of majority voting. Depending on the regime used, one may take multiple iteration of the power-iteration method.

As noted herein, “Algorithm 1” and related text provides a preferred description for an exemplary BSC, while “Algorithm 3” and related text provides a preferred description for general channels. It is noted that an RM-RPA decoder is discussed at “Algorithm 3” and related text, while an RM-RPA list decoder is discussed at “Algorithm 5” and related text. Further, an RM-RPA list decoder with 1 parity is discussed at “Algorithm 8” and related text, including where the number of parities in the outer code is 1.

FIG. 3 is a flow diagram of a decoding method according to an embodiment. Specifically, as described in detail above and further illustrated in FIG. 3, one embodiment is a method of decoding data encoded with a Reed-Muller (RM) code in which a received word of RM encoded data is decoded in a recursive manner (step 310); the received word is projected on the cosets of different subspaces to form the projected words (step 320), each projected word is decoded recursively, and the decoding of all projected words are aggregated to obtain a decoding of the original received word.

For the projection phase of step 320, the number and the choice of the subspaces may be a tuning parameter, and a preferred embodiment may be to use subspaces of dimension 1. Dimensions of 2, 3 and so on may also be used (box 325).

For the aggregation phase of step 330, the aggregation function may be a tuning parameter, and a preferred embodiment may be to use majority voting. Multi-step power iteration methods, spectral methods, semi-definite programming methods and the like may also be used.

Generally speaking, the method 300 of FIG. 3 and the above-described algorithms contemplates that for every one-dimensional subspace, the method first obtains the corresponding projection of the original received word onto the cosets of this subspace. Then the decoding algorithm of a lower-order RM code is used to decode the projected vector for each subspace. Finally, a majority voting scheme (or other scheme) is used to aggregate the original received word as well as the decoded words from all the one-dimensional subspaces. This procedure is iterated several times until it converges to a stable point. Then this stable point is taken as the output; that is, the decoded form of the RM encoded word.

Thus, one embodiment comprises a method for decoding Reed-Muller (RM) encoded data, comprising: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words; for each received word of RM encoded data, recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; for each received word of RM encoded data, aggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data. In some embodiments, the projecting may be performed in accordance with subspaces of dimension 1. In some embodiments, the projecting may be performed in accordance with subspaces of dimension 2 or 3. In some embodiments, the aggregation is performed in accordance with majority voting. In some embodiments, the aggregation is performed in accordance with one of a majority voting method, a multi-step power iteration method, a spectral method, and a semi-definite programming method.

FIG. 4 is a flow diagram of a list decoding method according to an embodiment. Specifically, as described in detail above and further illustrated in FIG. 3, one embodiment is a method of decoding data encoded with a Reed-Muller (RM) code or Polar Code in which received words of encoded data are processed by identifying a plurality (t) of most noisy bits in the received word for a choice oft and identifying each of a plurality of possible cases of the t most noisy bits (step 420); wherein for each identified case, obtaining a decoding result from a unique decoding algorithm to provide thereby a list of 2t codewords (step 430); and performing a maximal likelihood decoding among each of the list of 2t codewords to provide thereby the final decoding result (step 440). In various embodiments, an outer code is used for the information bits, and said list decoding utilizes only those information bits forming a codeword of the outer code.

The recursive projection-aggregation (RPA) methodology discussed above may be further improved by using list-decoding procedures and/or code-concatenation procedures to provide combined encoder methods; namely, RPA with list-decoding, RPA with code-concatenation, and RPA with list-decoding and code-concatenation. It is noted that the combined methods provide a performance level that improves upon that of optimal polar code decoders and approaches the optimal decoding performance for RM codes. The code-concatenation method modifies RM codes themselves.

Advantageously, the RPA decoding method can be applied to a broader class of error-correcting codes supported on vector spaces or any code that supports the type of operations used in the RPA algorithm, such as BCH, Reed-Solomon or expander codes.

The list-decoding procedure and the code-concatenation method can be composed with any decoding algorithm for any error correcting codes to reduce the decoding error probability.

Parallel Processing

In various embodiments, parallel processing implementations are provided wherein multiple processors or processing threads are used to process respective RM encoded words, or respective dimensions of an RM encoded word or perform other parallel processing operations configured to speed up the decoding process.

Specifically, an advantage of the disclosed RPA decoding methodology for RM codes over the SCL decoder for polar codes is that the disclosed RPA decoding methodology naturally allows parallel implementation while the SCL decoder is simply not parallelizable. An important key step in the disclosed RPA decoding methodology for decoding a codeword of RM(r,m) is to decode the quotient space codes which are in RM(r−1,m−1) codes, and each of these quotient space codes can be decoded independently and in parallel. Such a parallel structure is crucial to achieving high throughput and low latency.

Extensions

Various embodiments contemplated by the inventors herein provide universal decoder functionality suitable for use in a wide variety of channel decoding and other applications.

It is noted that the methods, algorithms, techniques and the like for encoding, decoding and otherwise processing Reed-Muller codes, Polar codes and variations thereof discussed in the first appended document, second appended document, or discussed herein with respect to the various figures may be operably combined in part or in whole to provide various other and further embodiments and that such embodiments are contemplated by the inventors.

Various embodiments comprise systems and methods of encoding, decoding and otherwise processing Reed-Muller codes, Polar codes and variations thereof discussed in the first appended document, second appended document, or discussed herein with respect to the various figures that operate by combining in part or in whole the different components and code reductions to provide various other and further embodiments.

Various embodiments comprise systems and methods of applying recursive aggregation-projection algorithms to any code that supports the algorithm's operations (e.g., BCH, Reed-Solomon or expander codes). In particular, taking any code on a finite field, summing pairs of components based on a matching of the components, iterating this projection procedure a number of time until the obtained word is decoded by a specific algorithm, and reverting the projection parts with aggregation functions.

FIG. 5 depicts a high-level block diagram of a computing device, such as a channel decoder or other computing device, suitable for use in performing functions described herein such as those associated with the various elements described herein with respect to the figures.

As depicted in FIG. 5, computing device 500 includes a processor element 503 (e.g., a central processing unit (CPU) and/or other suitable processor(s)), a memory 504 (e.g., random access memory (RAM), read only memory (ROM), and the like), a cooperating module/process 505, and various input/output devices 506 (e.g., a user input device (such as a keyboard, a keypad, a mouse, and the like), a user output device (such as a display, a speaker, and the like), an input port, an output port, a receiver, a transmitter, and storage devices (e.g., a persistent solid state drive, a hard disk drive, a compact disk drive, and the like)).

It will be appreciated that the functions depicted and described herein may be implemented in hardware and/or in a combination of software and hardware, e.g., using a general purpose computer, one or more application specific integrated circuits (ASIC), and/or any other hardware equivalents. In one embodiment, the cooperating process 505 can be loaded into memory 504 and executed by processor 503 to implement the functions as discussed herein. Thus, cooperating process 505 (including associated data structures) can be stored on a computer readable storage medium, e.g., RAM memory, magnetic or optical drive or diskette, and the like.

It will be appreciated that computing device 500 depicted in FIG. 5 provides a general architecture and functionality suitable for implementing functional elements described herein or portions of the functional elements described herein.

It is contemplated that some of the steps discussed herein may be implemented within hardware, for example, as circuitry that cooperates with the processor to perform various method steps. Portions of the functions/elements described herein may be implemented as a computer program product wherein computer instructions, when processed by a computing device, adapt the operation of the computing device such that the methods and/or techniques described herein are invoked or otherwise provided. Instructions for invoking the inventive methods may be stored in tangible and non-transitory computer readable medium such as fixed or removable media or memory, and/or stored within a memory within a computing device operating according to the instructions.

Thus, various embodiments for decoding Reed-Muller (RM) encoded data may be implemented via code stored on a non-transient medium in or suitable for use with a receiver (e.g., a special purpose receiver or decoding portion therein, computing device implementing a receiver function or decoding function, and so on), by a receiver or decoding portion thereof configured to perform the method such as by executing such code, by a special purpose device configured for performing the method and so on.

Various modifications may be made to the systems, methods, apparatus, mechanisms, techniques and portions thereof described herein with respect to the various figures, such modifications being contemplated as being within the scope of the invention. For example, while a specific order of steps or arrangement of functional elements is presented in the various embodiments described herein, various other orders/arrangements of steps or functional elements may be utilized within the context of the various embodiments. Further, while modifications to embodiments may be discussed individually, various embodiments may use multiple modifications contemporaneously or in sequence, compound modifications and the like.

Although various embodiments which incorporate the teachings of the present invention have been shown and described in detail herein, those skilled in the art can readily devise many other varied embodiments that still incorporate these teachings. Thus, while the foregoing is directed to various embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof. As such, the appropriate scope of the invention is to be determined according to the claims.

Claims

1. A method for decoding Reed-Muller (RM) encoded data, the method being implemented via code stored on a non-transient medium in a receiver and comprising: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words;recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; andaggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data.

2. The method of claim 1, wherein said projecting is performed in accordance with subspaces of dimension 1.

3. The method of claim 1, wherein said projecting is performed in accordance with subspaces greater than dimension 1 and fixed over a number of recursive decoding iterations.

4. The method of claim 1, wherein said projecting is performed in accordance with subspaces greater than dimension 1 and variable over a number of recursive decoding iterations.

5. The method of claim 1, wherein said aggregation is performed in accordance with a majority voting method.

6. The method of claim 1, wherein said aggregation is performed in accordance with one of a majority voting method, a multi-step power iteration method, a spectral method, and a semi-definite programming method.

7. The method of claim 1, wherein said aggregation selects only a subset of projected words according to a rule of selection based on the decoding of the projected words.

8. The method of claim 1, further comprising: decomposing of RM codes that reduce at least one of r and m parameters of the code individually using Plotkin transformation; andcomposing the decomposed RM codes with decoded projected word components.

9. The method of claim 1, wherein for each of the respective plurality of projected words, said steps of decoding and aggregating are performed in parallel.

10. An apparatus for decoding Reed-Muller (RM) encoded data, the apparatus comprising a processor configured to: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words;recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; andaggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data.

11. A tangible and non-transient computer readable storage medium storing instructions which, when executed by a computer, adapt the operation of the computer to provide a method of decoding Reed-Muller (RM) encoded data, the method comprising: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words;recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; andaggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data.

12. A computer program product wherein computer instructions, when executed by a processor in a computing device, adapt the operation of the computing device to provide a method of decoding Reed-Muller (RM) encoded data, the method comprising: for each received word of RM encoded data, projecting the received word onto each of a plurality of cosets of different subspaces to form thereby a respective plurality of projected words;recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words; andaggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of RM encoded data.

13. A computer program product wherein computer instructions, when executed by a processor in a computing device, adapt the operation of the computing device to provide a method of list decoding encoded data by any error-correcting codes, comprising: identifying a plurality (t) of most noisy bits in the received word for a choice of t;identifying each of a plurality of possible cases of the t most noisy bits;for each identified case, obtaining a decoding result from a unique decoding algorithm to provide thereby a list of 2t codewords; andperforming a maximal likelihood decoding among each of the list of 2t codewords to provide thereby the final decoding result.

14. The method of claim 13, wherein an outer code is used for the information bits, and said list decoding utilizes only those information bits forming a codeword of the outer code.

15. The method of claim 13, wherein said list decoding uses a twin code selected from rows in a squared RM matrix having largest conditional mutual information, and further comprises successive cancelation decoding of the twin code.

16. The method of claim 15, further comprising list decoding a plurality of outer codes.

17. A method for decoding a code, comprising: for each received word of encoded data, mapping the received word onto a plurality of projected words via a code-specific projection technique;recursively decoding each of the respective plurality of projected words to form a respective plurality of decoded projected words;aggregating each of the respective decoded projected words to obtain thereby a decoding of the corresponding received word of the original code.

18. The method of claim 17, further comprising utilizing list-decoding and code concatenation.