Soft decision decoding of Reed-Muller codes: recursive lists

TL;DR

This paper introduces an improved recursive list decoding algorithm for Reed-Muller codes that approaches maximum-likelihood performance, utilizing permutation techniques and error-prone bit elimination, with extensive simulation results.

Contribution

The paper presents a novel recursive list decoding method for Reed-Muller codes that significantly improves decoding performance and provides tight bounds on ML performance.

Findings

Approaches ML performance within 0.1 dB for length 256 codes.

Effective use of permutation techniques enhances decoding accuracy.

Elimination of error-prone bits improves overall decoding performance.

Abstract

Recursive list decoding is considered for Reed-Muller (RM) codes. The algorithm repeatedly relegates itself to the shorter RM codes by recalculating the posterior probabilities of their symbols. Intermediate decodings are only performed when these recalculations reach the trivial RM codes. In turn, the updated lists of most plausible codewords are used in subsequent decodings. The algorithm is further improved by using permutation techniques on code positions and by eliminating the most error-prone information bits. Simulation results show that for all RM codes of length 256 and many subcodes of length 512, these algorithms approach maximum-likelihood (ML) performance within a margin of 0.1 dB. As a result, we present tight experimental bounds on ML performance for these codes.

Equations

$$g=1,...,m-r,h=1,...,r.$$

$$\xi \stackrel{\text{def}}{=}({\xi }_1,...,{\xi }_{m-g})$$

$$\xi \stackrel{\text{def}}{=}({\xi }_1,...,{\xi }_{m-h}).$$

$$q_i^{\prime }\stackrel{\text{def}}{=}\mathrm{Pr}\{u_i=1|x_i^{\prime }\},q_i^{\prime \prime }\stackrel{\text{def}}{=}\mathrm{Pr}\{u_i{v}_i=1|x_i^{\prime \prime }\}.\text{vskip}3.0ptplus1.0ptminus1.0pt$$

$$y_i^{\prime }\stackrel{\text{def}}{=}2q_i^{\prime }-1,y_i^{\prime \prime }=2q_i^{\prime \prime }-1.$$

$$y_i^v=y_i^{\prime }{y}_i^{\prime \prime }.$$

$$y_i^u=(y_i^{\prime }+{\hat{y}}_i)/(1+y_i^{\prime }{\hat{y}}_i),$$

$$\mathrm{Pr}(c_i|y_i)=(1+c_i{y}_i)/2$$

$$P(\mathbf{c}\mid \mathbf{y})=\prod _{i=1}^{2^g}(1+c_i{y}_i)/2$$

$$\forall \mathbf{c}\in \left\{{}_h^g\right\}:P(\hat{\mathbf{c}}|\mathbf{y})\ge P(c|y).$$

$${\mathbf{y}}^u=({\mathbf{y}}^{\prime }+\hat{\mathbf{y}})/2.$$

$$\forall \mathbf{c}:(\hat{\mathbf{c}},\mathbf{y})\ge (\mathbf{c},\mathbf{y}).$$

$$|{\Psi }_r^m|\le \left|{\Psi }_{r-1}^{m-1}\right|+\left|{\Psi }_r^{m-1}\right|+3n.$$

$$|{\Psi }_r^m|\le 6n\min (r,m-r)+n.$$

$$A=(\bar{\mathbf{a}},\rho (\bar{\mathbf{a}}),\mathbf{y}(\bar{\mathbf{a}})).$$

$$\bar{\mathbf{a}}=\varnothing ,\rho (\bar{\mathbf{a}})=1,\mathbf{y}(\bar{\mathbf{a}})=\mathbf{y},$$

$$\rho (\bar{\mathbf{a}})=\prod _{i=1}^{2^{m-r}}\frac{1+{\mathbf{c}}_i(a_1)y_i(\bar{\mathbf{a}})}{2}$$

$$\bar{\mathbf{a}}=(a_1,...,a_{s-1})$$

$$\bar{\mathbf{a}}:=\bar{\mathbf{a}},a_s$$

$$\rho (\bar{\mathbf{a}}):=\rho (\bar{\mathbf{a}})\cdot \prod _{i=1}^{2^g}\frac{1+c_i(a_s)y_i(\bar{\mathbf{a}})}{2}.$$

$${\sigma }_v^2\ge \max \{2{\sigma }^2,{\sigma }^4\}.$$

$$\Delta =0.25\text{ dB.}$$

$$(1,2,...,m)\stackrel{\pi }{\mapsto }\left(\pi (1),\dots ,\pi (m)\right)$$

$$\pi (i):(i_1,\dots ,i_m)\to (i_{\pi (1)},\dots ,i_{\pi (m)}).$$

$${\pi }^{-1}\left\{1,...,r\right\}={\eta }^{-1}\{1,...,r\}.$$

Full text

Index terms – Maximum-likelihood performance, Plotkin construction, posterior probabilities, recursive lists, Reed-Muller codes.

I Introduction

The main goal of this paper is to design feasible error-correcting algorithms that approach ML decoding on the moderate lengths ranging from 100 to 1000 bits. The problem is practically important due to the void left on these lengths by the best algorithms known to date. In particular, exact ML decoding has huge decoding complexity even on the blocks of 100 bits. On the other hand, currently known  iterative (message-passing) algorithms have been efficient only on the blocks of thousands of bits.

To achieve near-ML performance with moderate complexity,  we wish to use recursive techniques that repeatedly split an original  code into the shorter ones. For this reason, we consider Reed-Muller (RM) codes, which represent the most notable example of recursive constructions known to date. These codes - denoted below $\left\{\genfrac{}{}{0.0pt}{}{m}{r}\right\}$ - have length $n=2^{m}$ and Hamming distance $d=2^{m-r}.$ They also admit a simple recursive structure based on the Plotkin construction $(\mathbf{u,u+v}),$ which splits the original RM code into the two shorter codes of length $2^{m-1}$. This structure was efficiently used in recursive decoding algorithms of [2]-[4], which derive the corrupted symbols of the shorter codes $\mathbf{u}$ and $\mathbf{v}$ from the received symbols. These recalculations are then repeated until the process reaches the repetition codes or full spaces, whereupon new information symbols can be retrieved by any powerful algorithm - say, ML decoding. As a result, recursive algorithms achieve bounded distance decoding  with a low complexity order of $n\min\{r,m-r\}$, which improves upon the complexity of majority decoding [1].

We also mention two list decoding algorithms of [5] and [6], which substantially reduce the error rates at the expense of a higher complexity. In both algorithms, RM codes are represented as the generalized concatenated codes, which are repeatedly decomposed into the shorter blocks similarly to the Plotkin construction. In all intermediate steps, the algorithm of [5] tries to estimate the Euclidean distance to the received vector and then retrieves the codewords with the smallest estimates. To do so, the algorithm chooses some number $L$ of codewords from both constituent codes $\mathbf{u}$ and $\mathbf{v.}$ Then the product list is constructed for the original code. These lists are recursively re-evaluated and updated in multiple runs. The second technique [6] is based on a novel sequential scheme that uses both the main stack and the complementary one. The idea here is to lower-bound the minimum distance between the received vector and the best code candidates that will be obtained in the future steps. This “look-ahead” approach gives low error rates and reduces the decoding complexity of [5].

Recently, new recursive algorithms were considered in [8] and [9]. In particular, for long RM codes of fixed code rate $R,$ recursive decoding of [8] corrects most error patterns of weight ($d\ln d)/2$ instead of the former threshold of $d/2.$ This is done without any increase in decoding complexity. However, the new decoding threshold is still inferior to that of a much more powerful ML decoding.

In the sequel, we advance the algorithm of [8], also applying list decoding techniques. This approach mostly follows [9] and differs from the prior results in a few important aspects. First, we use exact posterior probabilities in our recursive recalculations instead of the distance approximations employed before. This allows us to design a tree-like recursive algorithm that can better sort out all plausible candidates in intermediate steps and avoid multiple decoding runs. Second,  we shall see that the output error rate significantly varies for the different information symbols derived in the recursive process. Therefore, we also consider subcodes of RM codes obtained by removing the least protected information bits. Finally, decoding will be improved by applying a few permutations on code positions. As a result, we closely approach the performance of ML decoding on the lengths 256 and 512, which was beyond the reach of the former techniques.

The material is organized as follows.  In Section 2, we briefly summarize some recursive properties of RM codes and their decoding procedures. In Section 3, we describe our list decoding algorithm $\Psi_{\,r}^{m}(L)$. Finally, in Section 4 we discuss the improvements obtained by eliminating the least protected information bits and using permutation techniques.

II Recursive encoding and decoding for RM codes

II-A Encoding

The following description is detailed in [10]. Let any codeword $\mathbf{c}$ of RM code $\left\{\genfrac{}{}{0.0pt}{}{m}{r}\right\}$ be represented in the form $\mathbf{u,u+v}$ where $\mathbf{u}\in\left\{\genfrac{}{}{0.0pt}{}{m-1}{r}\right\}$ and $\mathbf{v\in}\left\{\genfrac{}{}{0.0pt}{}{m-1}{r-1}\right\}$. We say that $\mathbf{c}$ is split onto two “paths” $\mathbf{u}$ and $\mathbf{v}$. By splitting both paths,  we obtain four paths that lead to RM codes of length $2^{m-2},$ and so on. In each step $i$ of our splitting, we assign the path value $\xi_{i}=0$ to a new $\mathbf{v}$-component and $\xi_{i}=1$ to a new $\mathbf{u}$-component.  All paths end at the repetition codes $\left\{\genfrac{}{}{0.0pt}{}{g}{0}\right\}$ or full spaces $\left\{\genfrac{}{}{0.0pt}{}{h}{h}\right\},$ where

[TABLE]

Thus, we can consider a specific binary path

[TABLE]

that leads from the origin $\left\{\genfrac{}{}{0.0pt}{}{m}{r}\right\}$ to some left-end code $\left\{\genfrac{}{}{0.0pt}{}{g}{0}\right\}$. For any right-end node $\left\{\genfrac{}{}{0.0pt}{}{h}{h}\right\},$ the same process gives a subpath $\xi$ of length $m-h:$

[TABLE]

A similar decomposition can be performed on the block $\mathbf{a}_{\,r}^{m}$ of  k\information bits  that encode the original vector $\mathbf{c}.$ In this way, any left-end path $\xi$ gives only one information bit associated with its end node $\left\{\genfrac{}{}{0.0pt}{}{g}{0}\right\}.$ Any right-end path gives $2^{h}$ information bits associated with the end code $\left\{\genfrac{}{}{0.0pt}{}{h}{h}\right\}.$ We can also add an arbitrary binary suffix of length $h$ to the right-end paths, and obtain a one-to-one mapping between the extended paths $\xi$ and $k$ information bits $a(\xi).$

II-B Basic decoding with posterior probabilities

Let any binary symbol $a$ be mapped onto $(-1)^{a}$. Then any codeword of RM code belongs to $\{1,-1\}^{n}$ and has the form $\mathbf{c=}(\mathbf{u,uv}).$ This codeword is transmitted over a memoryless channel $\mathcal{Z}_{g}.$ The received block $\mathbf{x}$ consists of the two halves $\mathbf{x}^{\prime}$ and $\mathbf{x}^{\prime\prime}$, which are the corrupted images of vectors $\mathbf{u}$ and $\mathbf{uv}$.  The decoder first takes the symbols $x_{i}^{\prime}$ and $x_{i}^{\prime\prime}$ for any position $i=1,...,n/2,$ and finds the posterior probabilities of transmitted symbols $u_{i}$ and $u_{i}v_{i}:$

[TABLE]

To simplify our notation, below we use the associated quantities

[TABLE]

Note that $y_{i}^{\prime}$ is the *difference *between the two posterior probabilities $q_{i}^{\prime}$ and $1-q_{i}^{\prime}$ of $1$ and $-1$ in position $i$ of the left half. Similarly, $y_{i}^{\prime\prime}$ is obtained on the right half. The following basic recursive algorithm is described in [8] and Section IV of [10] in more detail.

**Step 1. **Let $q_{i}^{v}=\Pr\{v_{i}=1\,\,|\,\,x_{i}^{\prime}\,,x_{i}^{\prime\prime}\}$ be the posterior probability of any symbol $v_{i}\mathbf{\ }$of  the codeword $\mathbf{v.}$ We find the corresponding quantity $y_{i}^{v}=2q_{i}^{v}-1,$ which is (see formula (18) in [10])

[TABLE]

Symbols $y_{i}^{v}$ form the vector $\mathbf{y}^{v}$ of length $n/2.$ Then we use some soft-decision decoder $\Psi_{v}(\mathbf{y}^{v})$ that gives a vector $\hat{\mathbf{v}}\in\left\{\genfrac{}{}{0.0pt}{}{m-1}{r-1}\right\}$ and its information block $\hat{\mathbf{a}}^{v}.$

**Step 2. Now we assume that   Step 1 gives correct vector $\hat{\mathbf{v}}=\mathbf{v.}$ Let $q_{i}^{u}=\Pr\{u_{i}=1\,\,|\,\,x_{i}^{\prime}\,,x_{i}^{\prime\prime}\}$ be the posterior probability of a symbol $u_{i}.$ Then the corresponding quantity $y_{i}^{u}=2q_{i}^{u}-1$ is (see formula (19) in [10])

[TABLE]

where $\hat{y}_{i}=y_{i}^{\prime\prime}\hat{v}_{i}.$ The symbols $y_{i}^{u}$ form the vector $\mathbf{y}^{u}$ of length $n/2.$ We use some (soft decision) decoding algorithm $\Psi_{u}(\mathbf{y}^{u})$ to obtain a vector $\hat{\mathbf{u}}\mathbf{\in}\left\{\genfrac{}{}{0.0pt}{}{m-1}{r}\right\}$ and its information block $\hat{\mathbf{a}}^{u}.$ $\square$

In a more general scheme $\Psi_{r}^{m}$, vectors $\mathbf{y}^{v}$ and $\mathbf{y}^{u}$ are not decoded but used as our new inputs $\mathbf{y.}$ These inputs are recalculated multiple times according to (2) and (3). Finally, we reach the end nodes $\left\{\genfrac{}{}{0.0pt}{}{g}{0}\right\}$ and $\left\{\genfrac{}{}{0.0pt}{}{h}{h}\right\}$. Here we perform maximum-likelihood (ML) decoding as follows.

At any node $\left\{{}_{h}^{g}\right\}$, our input is a newly recalculated vector $\mathbf{y}$ of length $2^{g}$ with the given differences $y_{i}$ between posterior probabilities of two symbols $c_{i}=\pm 1$. Rewriting definition (1), we assign the posterior probability

[TABLE]

to a symbol $c_{i}=\pm 1$. In this way, we can find the posterior probability

[TABLE]

of any codeword $\mathbf{c\in}\left\{{}_{h}^{g}\right\}$, and choose the most probable codeword $\mathbf{\hat{c}}$, where

[TABLE]

The decoded codeword $\mathbf{\hat{c}\in}\left\{{}_{r}^{m}\right\}$ and the corresponding information block $\hat{\mathbf{a}}$ are now obtained as follows (here operations (2) and (3) are performed on vectors componentwise).

[TABLE]

Note that this algorithm $\Psi_{\,r}^{m}$ differs from the simplified algorithm $\Phi_{\,r}^{m}$ of [10] in three aspects. Firstly, we use exact recalculations (3) instead of the former simplification

[TABLE]

Secondly, we use ML decoding instead of the minimum distance decoding that chooses $\mathbf{\hat{c}}$ with the maximum inner product:

[TABLE]

Thirdly, we employ a different rule and stop at the repetition codes $\left\{\genfrac{}{}{0.0pt}{}{r}{0}\right\}$ instead of the biorthogonal codes used in [10]. This last change will make it easier to use the list decoding described in the following section.

Finally, note that recalculations (2) require $n/2$ operations, while recalculations (3) can be done  in $5n/2$ operations. Therefore our decoding complexity satisfies recursion

[TABLE]

Similarly to [10], this recursion gives decoding complexity

[TABLE]

Thus, complexity $|\Psi_{\,r}^{m}|$ has maximum order of $3n\log n,$ which is twice the complexity $\left|\Phi_{\,r}^{m}\right|$ of the algorithm $\Phi_{\,r}^{m}$ of [10].

III List decoding

To enhance algorithm $\Psi_{r}^{m}$, we shall use some lists of $L=2^{p}$ or fewer codewords obtained on any path $\xi$. This algorithm – called $\Psi_{r}^{m}(L)$ – increases the number of operations at most $L$ times and has the overall complexity order of $Ln\log n.$ Given any integer parameter $A$,  we say that the list have size $A^{\ast},$ if decoding outputs either all available records or $A$ records, whichever is less. This algorithm performs as follows.

At any step $s=1,...,k$ of the algorithm $\Psi_{r}^{m}(L)$, our input consists of $L^{\ast}$ records

[TABLE]

Each record is formed by some information block $\mathbf{\bar{a}},$ its cost function $\rho(\mathbf{\bar{a}}),$ and the corresponding input $\mathbf{y(\bar{a}}),$ which is updated in the decoding process These three entries are defined below.

Decoding* *starts at the root node $\left\{\genfrac{}{}{0.0pt}{}{m}{r}\right\}.$ Here we set $s=0$ and take one record

[TABLE]

where $\mathbf{y}$ is the input vector. Decoding takes the first path (denoted $\xi=1)$ to the leftmost code $\left\{\genfrac{}{}{0.0pt}{}{m-r}{0}\right\}$ and recalculates vector $\mathbf{y(\bar{a}})$ similarly to the algorithm $\Psi_{r}^{m}.$ However, now we take both values $a_{1}=0,1$ of  the first information symbol and consider both codewords $1^{d}$ and $-1^{d}$ of length $d=2^{m-r}$ in the repetition code $\mathbf{c(}a_{1})$. The posterior probabilities (4) of these two vectors will also define the cost function of the new information block $\mathbf{\bar{a}}=a_{1}:$

[TABLE]

In our list decoding, we represent the two outcomes $\mathbf{\bar{a}}$ as the initial edges mapped with their cost functions $P(\mathbf{\bar{a}})\mathbf{.}$ Then we proceed to the next code $\left\{\genfrac{}{}{0.0pt}{}{m-r-1}{0}\right\},$ which corresponds to the subsequent path denoted $\xi=2.$ Given two different decoding results $\mathbf{v}=\mathbf{c(}a_{1}),\mathbf{\ }$our recursion (2), (3) gives two different vectors $\mathbf{y(\bar{a}})$ arriving at this node.  Therefore, decoding is performed two times and gives the full tree of depth 2. More generally, at any step $s$, decoding is executed as follows.

Suppose that the first $s-1$ paths are already processed. This gives $L^{\ast}$ information blocks

[TABLE]

of length $s-1$ and the corresponding records $A.$ Each vector $\mathbf{y(\bar{a}})$ is then recalculated on the new path $\xi=s$ using formulas (2) and (3), in the same way it was done in $\Psi_{r}^{m}.$ Let this path end on some left-end code $\left\{\genfrac{}{}{0.0pt}{}{g}{0}\right\}$. Decoding of the new information symbol $a_{s}=0,1$ yields $2L^{\ast}$ extended blocks

[TABLE]

of depth $s,$ marked by their cost functions

[TABLE]

Step $s$ is completed by choosing $L^{\ast}$ blocks with the highest cost functions $\rho(\mathbf{\bar{a}}).$

The decoding on the right-end nodes is similar. The only difference is that the full spaces $\left\{{}_{h}^{h}\right\}$ include $2^{h}$ codewords defined by information blocks $a_{s}$ of length $|a_{s}|=h.$ In this case, we can choose the two most probable vectors $\mathbf{c}(a_{s})$ (in essence, making bit-by-bit decisions) and set $g=h$ in our cost calculations (8). Another - more refined version of the algorithm - chooses four different vectors of the code $\left\{{}_{h}^{h}\right\}$ whenever $h\geq 2.$ The best record is chosen at the last node $\left\{\genfrac{}{}{0.0pt}{}{r}{r}\right\}.$ More generally, the algorithm is executed as follows.

[TABLE]

Discussion.  Consider the above algorithm on the AWGN channel $\mathcal{N}(0,\sigma^{2}).$ Using the results of [10], it can be proven that on this channel, the $\mathbf{v}$-component is decoded on the channel with the new noise power

[TABLE]

The first approximation is tight for very small $\sigma^{2}$ (though the channel is no longer Gaussian), while the second one performs well on the “bad” channels with $\sigma^{2}\gg 1.$ Thus, the noise power always increases in the $\mathbf{v}$-direction; the more so the worse the original channel is. By contrast, the $\mathbf{u}$-channel can be approximated by the smaller power $\sigma^{2}/2$. These observations also show that the first information symbol

• which is obtained on the binary path $0^{r}$ - is protected the least, and then the decoding gradually improves on the subsequent paths.

Now we see that the algorithm $\Psi_{r}^{m}(L)$ with the list of size $L=2^{p}$ delays our decision on any information symbol by $p$ steps, making this decision better protected. In the particular case of a bad channel, it can be verified that the first symbol $a_{1}$ is now decoded when the noise power is reduced $2^{p}$ times. For this reason, this list decoding substantially reduces the output word error rates (WER) even for small size $L.$

For $L=2^{m-r+1},$ the algorithm $\Psi_{r}^{m}(L)$ processes all the codewords of the first biorthogonal code $\left\{\genfrac{}{}{0.0pt}{}{m-r+1}{1}\right\}$ and is similar to the algorithm $\Phi_{\,r}^{m}$ of [10].  On the other  hand, algorithm $\Psi_{r}^{m}(L)$ updates all $L$ cost functions, while $\Phi_{\,r}^{m}$ chooses one codeword on each end node. Therefore $\Psi_{r}^{m}(L)$ can be considered as a generalization of $\Phi_{\,r}^{m}$ that continuously updates decoding lists in all intermediate steps. The result is a more powerful decoding that comes along with a higher complexity.

*Simulation results. *Below we present our simulation results for the AWGN channels. Here we also counted all the instances, when for a given output the decoded vector  was more probable than the transmitted one. Obviously, these specific events also represent the errors of ML decoding. Thus, the fraction of these events gives a lower bound on the ML decoding error probability. This lower bound is also depicted in the subsequent figures for all the codes tested.

Our simulation results show that for all RM codes of lengths 128 and 256, the algorithm $\Psi_{r}^{m}(L)$ rapidly approaches ML performance as the list size $L$ grows.  For RM codes of length 128 and distance $d>4$, we summarize  these results in Fig. 1. For each RM code, we present tight lower bounds for the error probability of ML decoding. To measure the efficiency of the algorithm $\Psi_{r}^{m}(L),$ we also exhibit the actual list size $L(\Delta)$ at which $\Psi_{r}^{m}(L)$ approaches the optimal ML decoding within a small margin of

[TABLE]

This performance loss $\Delta$ is measured at the output word error rate (WER) $P=10^{-4};$ however, we found little to no difference for all other WER tested in our simulation. In Table 1, we complement these lists sizes $L(\Delta)$ with the two other relevant parameters:

$-$ the signal-to-noise ratios (SNR per information bit) at which algorithm $\Psi_{r}^{m}(L)$ gives the WER $P=10^{-4};$

$-$ the complexity estimates $\left|\Psi_{r}^{m}(L)\right|$ counted as the number of floating point operations.

[TABLE]

Table 1. RM codes of length 128: the list size $L(\Delta),$ decoding complexity, and the corresponding SNR at which algorithm $\Psi_{r}^{m}(L)$ performs within $\Delta=0.25$ dB from ML decoding at WER $10^{-4}.$

For RM codes of length 256, we skip most decoding results as these will be improved in the next section by the permutation techniques. In our single example in Fig. 2, we present the results for the $(n=256,k=93)$ code $\left\{{}_{3}^{8}\right\}.$ This code gives the lowest rate of convergence to the ML decoding among all RM codes of length $256.$ In other words, all other codes require the smaller lists to achieve the same performance loss $\Delta.$ This example and other simulation results show that the algorithm* $\Psi_{r}^{m}(L)$* performs within 0.5 dB from ML decoding on the lengths 128 and 256 using lists of small or moderate size.

IV Further improvements

IV-A Subcodes of RM codes

More detailed results also show that many codes of length $n\geq 256$ require lists of large size $L\geq 1024$ to approach ML decoding within the small margin of 0.25 dB. Therefore for $n\geq 256$, we also employ a different approach. Namely, the decoding performance can be improved by eliminating those paths, where recursive decoding fails more often. Here we use the results of [10], which show that the leftmost paths are the least protected.

Recall that each left-end path $\xi$ corresponds to one information symbol. Therefore, decoding on these paths can be eliminated by setting the corresponding * information bits as zeros*. In this way, we employ the subcodes of the original code $\left\{\genfrac{}{}{0.0pt}{}{m}{r}\right\}$. Note that our decoding algorithm $\Psi_{r}^{m}(L)$ runs virtually unchanged on subcodes. Indeed, the single difference arises when some information block $a_{s}$ takes only one value 0 on the corresponding left node (or less than $2^{h}$ values on the right node). Therefore, on each step $s,$ we can proceed as before, by taking only the actual blocks $a_{s}$ left at this node after expurgation.

In the algorithm $\Psi_{r}^{m}(L)$,  this expurgation starts with the least protected information path $0^{r}$ that ends at the node $\left\{\genfrac{}{}{0.0pt}{}{m-r}{0}\right\}.$ It can be shown that for long RM codes of fixed order $r,$ eliminating even the single weakest path $0^{r}$  increases the admissible noise power $2^{1/2^{r}}$ times. Thus, the lowest orders $r=2,3$ yield the biggest gain (10log${}_{10}2)/2^{r}$ dB, which equals 0.75 dB and 0.375 dB, respectively.

To proceed further, we eliminate the next weakest path $0^{r-1}10.$ However, the theoretical analysis becomes more complicated on the subsequent bits and it is unclear which bits should be eliminated first. For this reason, we optimized this pruning process in our simulation by making a few ad hoc trials and eliminating subsequent bits in different order.

The corresponding simulation results are presented in Figure 3 for the $(256,93)$-code $\left\{{}_{3}^{8}\right\}$ and its $(256,78)$-subcode. We see that pruning substantially improves code performance. It is also interesting to compare Figures 2 and 3. We see that the subcode approaches the optimal ML performance much faster than the original code does. In particular, the same margin of $\Delta=0.25$ dB can be reached with only $L=16$ codewords instead of $L=1024$ codewords needed on the code. In all other examples, the subcodes also demonstrated a much faster convergence, which leads to a lesser complexity.

In Fig. 4, we present similar results for the $(512,101)$-subcode of the $(512,130)$-code $\left\{\genfrac{}{}{0.0pt}{}{9}{3}\right\}.$ Here in Table 2, we also give a few list sizes $L,$ the corresponding  SNRs needed to reach the output WER $P=10^{-4},$ and the complexity estimates $\left|\Psi_{r}^{m}(L)\right|$ counted by the number of floating point operations.  Similar results were also obtained for the subcodes of other RM codes of length 512.

[TABLE]

Table 2. ($512$, $101$)-subcode of the ($512$, $130$) RM code $\genfrac{\{}{\}}{0.0pt}{}{9}{3}.$ List sizes $L,$ the corresponding SNRs, and complexity estimates $\left|\Psi_{r}^{m}(L)\right|$ needed at WER $10^{-4}.$

These simulation results show that combining both techniques - eliminating the least protected bits and using small lists of codewords - gives a gain of 3 to 4 dB on the lengths $n\leq 512$ over the original non-list decoding algorithm $\Psi_{r}^{m}.$ For subcodes, we also approach ML decoding with the lists reduced 4 to 8 times relative to the original RM codes.

IV-B New permutation techniques

The second improvement to the algorithm $\Psi_{r}^{m}(L)$ utilizes the rich symmetry group $GA(m)$ of RM codes [7] that includes $2^{O(m^{2})}$ permutations of $n$ positions $i=(i_{1},\ldots,i_{m}).$ To employ fewer permutations, we first* *permute the $m$ indices $(1,2,...,m)$ of all $n$ positions $i=(i_{1},\ldots,i_{m}).$ Thus, we first take a permutation

[TABLE]

of $m$ indices and consider the corresponding $m!$ permutations $\pi(i)$ of positions $i:$

[TABLE]

Remark. Note that the $m$ indices represent the different axes in $E_{2}^{m}.$ Thus, any permutation of indices is the permutation of axes of $E_{2}^{m}.$ For example, the permutation $(2,1,3,4,...,m)$ of $m$ indices leaves unchanged the first and the fourth quarters of all positions $1,...,n,$ but changes the order of the second and the third quarters.

Given a permutation $\pi,$ consider the subset of $r$ original indices (axes) $\pi^{-1}\left\{1,...,r\right\}$ that were transformed into the first $r$ axes $1,...,r$ by the permutation $\pi$. We say that two permutations $\pi$ and $\eta$ are equivalent if these images form the identical (unordered) subsets

[TABLE]

Now consider any subset $T$ of permutations (9) that includes exactly one permutation from each equivalent class. Thus, $T$ includes $\left({}_{\,r}^{m}\right)$ permutations, each of which specifies a subset of the first  $r$ indices. Recall that these $r$ indices correspond to the axes that are processed first on the subpath $0^{r}$ (for example, we can start with the axis $i_{2}$ instead of $i_{1},$ in which case we first fold the adjacent quarters instead of the halves of the original block). Thus, this subset $T$ specifies all possible ways of choosing $r$ unordered axes that will be processed first by the algorithm $\Psi_{r}^{m}.$

Given some positive integer $l$ (which is smaller than the former parameter $L),$ we then incorporate these permutations $\pi(i)$ into the list decoding $\Psi_{r}^{m}(l).$ Namely,  we form all permutations $\mathbf{y}_{\pi(i)}$ of the received vector $\mathbf{y}$ and apply algorithm $\Psi_{r}^{m}(l)$ to each vector $\mathbf{y}_{\pi(i)}$. However, at each step of the algorithm, we also combine different lists and leave only $l$ best candidates in the combined list, each counted once.

Note that this technique makes only marginal changes to our conventional list decoding $\Psi_{r}^{m}(l).$ Indeed, the single vector $\mathbf{y}$  in our original setting (7) is replaced by $\left({}_{\,r}^{m}\right)$ permutations $\mathbf{y}_{\pi(i)}.$ Thus, we use parameter $\left({}_{\,r}^{m}\right)$ in our initial setting but keep parameter $l$ for all decoding steps. If $l<\left({}_{\,r}^{m}\right),$ then the number of records drops to $l$ almost immediately, after the first decoding is performed on the path $0^{r}.$

Also, information bits are now decoded in different orders depending on a specific permutation $\pi(i).$ Note that we may (and often do) get the same entries repeated many times. Therefore, in steps 2 and 3 we must eliminate identical entries. This is done in all steps by applying inverse permutations and comparing the corresponding blocks $\mathbf{a}$. This permutation-based algorithm is called $\Upsilon_{r}^{m}(l)$ below and has complexity similar to $\left|\Psi_{r}^{m}(l)\right|$ for all the codes tested.

The motivation for this algorithm is as follows. The specific order of our axes also defines the order  in which the decoding algorithm folds the original block into the subblocks of lengths $n/2,$ then $n/4,$ and so on. Now note that this folding procedure will likely accumulate the errors whenever erroneous positions substantially disagree on the two halves (correspondingly, quarters, and so on). This can also happen if the errors are unevenly spread over the two halves of the original block. By using many permutations, we make it more likely that the error positions are spread more evenly even if they get accumulated in the original setting $\pi(i)=i$ or any other specific setting. In this way,  permutation techniques serve the same functions as interleaving does on the bursty channels.

Simulation results for the moderate lengths 256 and 512 show that the algorithm $\Upsilon_{r}^{m}(l)$ approaches the optimal ML performance even when the combined list of $l$ most probable candidates is reduced two to eight times relative to the original algorithm $\Psi_{r}^{m}(L)$. For RM codes of length 256, we summarize these results in Fig. 5. For each RM code, we first present the lower bounds for the ML decoding error probability. Similarly to Fig. 1, we then find the minimum size $l(\Delta)$ that makes the algorithm $\Upsilon_{r}^{m}(l)$ perform only within $\Delta=0.25$ dB away from ML decoding. These sizes and complexity estimates $\left|\Upsilon_{r}^{m}(l)\right|$ are also given in Table 3. Note that both algorithms give smaller lists once this performance loss $\Delta$ is slightly increased. In particular, the results in Table 4 show that the lists are reduced two times for $\Delta=0.5$ dB.

In summary, the permutation algorithm* $\Upsilon_{r}^{m}(l)$* * performs within 0.5 dB from ML decoding on the length 256,* by processing  $l\leq 64$ vectors for all RM codes.* To date, *both techniques - permutation decoding $\Upsilon_{r}^{m}(l)$ of complete RM codes and list decoding $\Psi_{r}^{m}(L)$ of their subcodes - yield the best trade-offs between near-ML performance and its complexity known on the lengths $n\leq 256.$

[TABLE]

Table 3. RM codes of length 256:  the list sizes, complexities, and the corresponding SNRs, at which the permutation algorithm $\Upsilon_{r}^{m}(l)$ performs within $\Delta=0.25$ dB from ML decoding at WER $10^{-4}.$

[TABLE]

Table 4. RM codes of length 256: the list sizes, complexities, and the corresponding SNRs, at which the permutation algorithm $\Upsilon_{r}^{m}(l)$ performs within $\Delta=0.5$ dB from ML decoding at WER $10^{-4}.$

Note, however, that the algorithm $\Upsilon_{r}^{m}(l)$ gives almost no advantage for the subcodes considered in the previous subsection. Indeed, these subcodes are obtained by eliminating the leftmost (least protected) information bits. However, any new permutation $\pi(i)$ assigns the new information bits to these leftmost nodes. Thus, the new bits also become the least protected. Another unsatisfactory observation is that increasing the size of the permutation set $T$ - say, to include all $m!$ permutations of all $m$ indices - helps little in improving decoding performance. More generally, there are a number of important open problems related to these permutation techniques. We name a few:

$-$ find the best permutation set $T$ for the algorithm $\Upsilon_{r}^{m}(l)$;

$-$ analyze the algorithm $\Upsilon_{r}^{m}(l)$ analytically;

$-$ modify the algorithm $\Upsilon_{r}^{m}(l)$ for subcodes.

V Concluding remarks

In this paper, we considered recursive decoding algorithms for RM codes that can provide near-maximum likelihood decoding with feasible complexity for RM codes or their subcodes on the moderate lengths $n\leq 512$.

Our study yet leaves many open problems. Firstly, we need to tightly estimate the error probabilities $p(\xi)$ on the different paths $\xi.$ To optimize our pruning procedures for specific subcodes, it is important to find the order in which information bits should be removed from the original RM code. Finally, it is yet an open problem to analytically estimate the performance of the algorithms $\Psi_{\,r}^{m}(L)$ and $\Upsilon_{r}^{m}(l).$