Fast Decoding of Multi-Kernel Polar Codes

TL;DR

This paper introduces a fast decoding method for multi-kernel polar codes that significantly reduces latency, enabling more practical use of these codes with flexible lengths in communication systems.

Contribution

It develops fast simplified successive cancellation decoding patterns compatible with multi-kernel polar codes, including Arikan and ternary kernels, with efficient implementation constraints.

Findings

Achieves at least 72% latency reduction compared to standard SC decoding.

Supports multiple codeword lengths including 96, 432, 768, and 2304.

Enables practical decoding of multi-kernel polar codes with improved speed.

Abstract

Polar codes are a class of linear error correction codes which provably attain channel capacity with infinite codeword lengths. Finite length polar codes have been adopted into the 5th Generation 3GPP standard for New Radio, though their native length is limited to powers of 2. Utilizing multiple polarizing matrices increases the length flexibility of polar codes at the expense of a more complicated decoding process. Successive cancellation (SC) is the standard polar decoder and has time complexity $\mathcal{O}(N \log N)$ due to its sequential nature. However, some patterns in the frozen set mirror simple linear codes with low latency decoders, which allows for a significant reduction in SC latency by pruning the decoding schedule. Such fast decoding techniques have only previously been used for traditional Arikan polar codes, causing multi-kernel polar codes to be an impractical length-compatibility technique with no fast decoders available. We propose fast simplified successive cancellation decoding node patterns, which are compatible with polar codes constructed with both the Arikan and ternary kernels, and generalization techniques. We outline efficient implementations, made possible by imposing constraints on ternary node parameters. We show that fast decoding of multi-kernel polar codes has at least 72% reduced latency compared with an SC decoder in all cases considered where codeword lengths are (96, 432, 768, 2304).

Figures

Tables

Table 1. TABLE I : Examples of P v subscript 𝑃 𝑣 P_{v} patterns.

$N_v$	${𝒌}_{𝒗}$	$P_v$	Type
3	(3)	(0,1,1)	REP3A
6	(2,3)	(0,1,1,0,1,1)	REP3C
6	(3,2)	(0,0,1,1,1,1)	REP3B
8	(2,2,2)	(1,1,1,1,1,1,1,1)	REP2
9	(3,3)	(0,0,0,0,1,1,0,1,1)	REP3A
12	(2,2,3)	(0,1,1,0,1,1,0,1,1,0,1,1)	REP3C
12	(3,2,2)	(0,0,0,0,1,1,1,1,1,1,1,1)	REP3B
18	(2,3,3)	(0,0,0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1)	REP3C

Table 2. TABLE II : Latency reduction of MK polar codes with ternary kernels as last/first Kronecker constituents.

$N$	$R$	# SC Nodes	# Fast-SSC Nodes	# R0	# R1	# SPC	# REP2	# REP3A/B/C	% Reduction
96	0.25	158/189	37/27	7/2	1/0	4/4	0/4	1/0	76.6/85.7
	0.5	158/189	43/45	8/5	1/5	6/3	0/3	0/0	72.8/76.2
	0.75	158/189	37/42	3/3	5/6	4/4	0/3	0/1	76.6/77.8
432	0.25	654/849	101/118	15/11	4/6	16/13	0/11	4/2	84.5/86.1
	0.5	654/849	110/136	14/9	4/7	21/19	0/15	7/0	83.2/83.4
	0.75	654/849	106/109	13/9	9/9	17/14	0/8	2/0	83.8/87.2
768	0.25	1278/1533	196/186	34/17	5/8	24/19	0/19	3/0	84.6/87.9
	0.5	1278/1533	223/222	31/15	9/14	31/24	0/22	4/0	82.5/85.5
	0.75	1278/1533	172/192	19/12	10/19	25/19	0/15	4/0	86.5/87.5
2304	0.25	3582/4602	409/453	62/31	8/16	71/54	0/52	5/0	88.6/90.1
	0.5	3582/4602	487/516	63/23	17/17	86/78	0/56	8/0	86.4/88.8
	0.75	3582/4602	395/441	45/24	27/39	60/50	0/36	9/0	88.9/90.4

Equations

$$\mathbf{G}=\underset{i=0}{\overset{m+n}{⨂}}{\mathbf{T}}_{{\mathbf{k}}_{\mathbf{i}}}.$$

$$f(l_0,l_1,)$$

$$g(l_0,l_1,u_0)$$

$${\lambda }_0(l_0,l_1,l_2)$$

$${\lambda }_1(l_0,l_1,l_2,u_0)$$

$${\lambda }_2(l_1,l_2,u_0,u_1)$$

$$h_l(l_i)=\{\begin{array}{ll}0& \text{if }{l}_i>0\text{ or }i\in \mathcal{F}\\ 1& \text{otherwise}\end{array}.$$

$$z_i^N=\frac{2}{{\sigma }^2}=\frac{2}{(2R\frac{E_b}{N_0}{)}^{-1}}=4R\frac{E_b}{N_0}\text{ for }i\in [0,N).$$

$$z_{2i-1}^{\frac{N}{2}}$$

$$\displaystyle z_{2i{\color[rgb]{1,1,1}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,1}\pgfsys@color@gray@stroke{1}\pgfsys@color@gray@fill{1}-0}}^{\frac{N}{2}}$$

$$z_{3i-2}^{\frac{N}{3}}$$

$$z_{3i-1}^{\frac{N}{3}}$$

$$\displaystyle z_{3i{\color[rgb]{1,1,1}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,1}\pgfsys@color@gray@stroke{1}\pgfsys@color@gray@fill{1}-0}}^{\frac{N}{3}}$$

$$\varphi (x)$$

$${\varphi }^{-1}(x)$$

$${\mathbf{\beta }}_{{\mathbf{v}}_{\mathbf{l}}}=h({\mathbf{\alpha }}_{{\mathbf{v}}_{\mathbf{l}}}),{\mathbf{\beta }}_{{\mathbf{v}}_{\mathbf{c}}}=h({\mathbf{\alpha }}_{{\mathbf{v}}_{\mathbf{c}}}),{\mathbf{\beta }}_{{\mathbf{v}}_{\mathbf{r}}}=h({\mathbf{\alpha }}_{{\mathbf{v}}_{\mathbf{r}}}).$$

$$h(a⊞b)=h(a)\oplus h(b)\text{ if }ab\ne 0.$$

$$h({\alpha }_{v_l}[i])$$

$$h({\alpha }_{v_c}[i])$$

$$=h({\alpha }_v[o]⊞{\alpha }_v[u]$$

$$+(1-2(h({\alpha }_v[e])\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u]))){\alpha }_v[e])$$

$$=h({\alpha }_v[o]⊞{\alpha }_v[u])=h({\alpha }_v[o])\oplus h({\alpha }_v[u])$$

$$h({\alpha }_{v_r}[i])$$

$$+(1-2h({\alpha }_{v_l}[i]\oplus {\alpha }_{v_c}[i])){\alpha }_v[u])$$

$$=h((1-2(h({\alpha }_v[e])\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u]))){\alpha }_v[o]$$

$$+(1-2(h({\alpha }_v[e])\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u])$$

$$\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u]))){\alpha }_v[u])$$

$$=h({\alpha }_v[e])\oplus h({\alpha }_v[u])$$

$${\beta }_v[u]$$

$$\stackrel{(b)}{=}h({\alpha }_{v_l}[i])\oplus h({\alpha }_{v_c}[i])\oplus h({\alpha }_{v_r}[i])$$

$$=h({\alpha }_v[e])\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u])$$

$$\oplus h({\alpha }_v[o])\oplus h({\alpha }_v[u])$$

$$\oplus h({\alpha }_v[e])\oplus h({\alpha }_v[u])=h({\alpha }_v[u]);\text{ thus}$$

$${\beta }_v[o]$$

$$=h({\alpha }_v[o])$$

$${\beta }_v[e]$$

$$=h({\alpha }_v[e])$$

$$\text{parity }=\underset{i=0}{\overset{N_v-1}{⨁}}h({\beta }_v[i]).$$

$${\beta }_v[j]:={\beta }_v[j]\oplus \text{parity},$$

$$\beta_{v}[i]=h\bigg{(}\sum_{j}\alpha_{v}[j]\bigg{)}\text{ for }i,j\in v$$

$${\hat{\mathbf{u}}}_{\mathbf{v}}[i]=\{\begin{array}{ll}0& i<N-1\\ h({\sum }_j{\alpha }_v[j])& i=N-1\end{array}\text{ for }i,j\in v.$$

$$P_v=\underset{i=0}{\overset{S-1}{⨂}}{P}_{k_i}.$$

$$\beta_{v}[i]=h\bigg{(}\sum_{j}\alpha_{v}[j]\cdot P_{v}[j]\bigg{)}\text{ for }i,j\in v$$

Full text

I Introduction

Polar codes are class of error correction codes that have been proven to achieve channel capacity at infinite lengths [1]. As such, they have been selected for control channel use in the 5th generation (5G) 3GPP standard for enhanced mobile broadband [2]. Since polar codes have now entered the scope of commercial use, researching methods to maximize their practicality is crucial.

However, polar codes have limitations that preclude their immediate practicality. The primary decoding technique is known as successive cancellation and is a serial algorithm by nature. This shortcoming implies that polar decoders are latency limited and have undesirable throughput. Further, polar codes of short to medium codeword length have inferior error correction performance when compared with other state-of-the-art error correction codes. List decoding allows for a considerable improvement in error correction potential, especially when the polar code is concatenated with a CRC [3]. Additionally, fast decoding techniques, such as fast simplified successive cancellation, have been proposed, which allow for substantial latency reduction [4]. This algorithm identifies simple linear codes that are embedded in the intermediate stages of a successive cancellation decoder. Rather than decoding these stages in the typical manner, the simplified decoders are applied, significantly reducing the number of decoding operations.

Another drawback associated with polar codes is that their codeword length is limited to powers of two. This property is a result of the recursive Kronecker product expansion of the $2\times 2$ polarizing matrix proposed by Arıkan. In practice, it is desirable to utilize error correction codes that can attain any length. Length-matching techniques, such as puncturing [5] and shortening [6], have been proposed, but these methods are not ideal due to additional optimization requirements and decoding complexity that is not directly related to their codeword length. Nonetheless, puncturing and shortening methods have been incorporated into the polar code scheme of the 5G standard.

Multi-kernel (MK) polar codes were proposed in order to overcome the lack of length flexibility in conventional polar coding [7]. This method allows incorporating additional polarizing matrices of size larger than two in conjunction with Arıkan’s matrix to build a polar code with more flexibility in codeword length. Specifically, a ternary $3\times 3$ matrix was proposed, and so MK polar codes can have lengths that are powers of two, powers of three, or a product of both. Although additional polarizing matrices of larger sizes have been proposed [8], among them the $3\times 3$ matrix offers a desirable combination of a sufficiently high polarization exponent and only a small increase in decoding complexity.

Fast simplified successive cancellation (Fast-SSC) decoders only exist for conventional polar codes, and so we propose an extension to existing fast decoding techniques that makes them compatible with MK codes. We offer proofs for fast decoding methods that are not trivially applied to MK codes, and we generalize the techniques to be usable with any construction of MK polar codes that use both the Arıkan and ternary polarization matrices. Though generalized implementations are possible, we demonstrate that efficient applications of these techniques are permitted under certain code construction constraints. We find that MK compatible Fast-SSC reduces computation complexity by a minimum of 72 % in all cases considered in this study.

The remainder of this paper is organized as follows: Section II reviews polar code preliminaries, including encoding and decoding, and outlines code optimization methods used for MK polar codes. Section III reviews the existing fast decoding scheme and proposes extensions for ternary compatibility along with the necessary proofs. Section IV outlines the latency reduction of the fast MK decoder and draws comparisons with equivalent length matching techniques.

II Polar Codes

Polar codes, denoted $\mathcal{PC}(N,K)$, are linear block codes that have a codeword length of $N$, message length $K$, and rate $R=\frac{K}{N}$. Channel polarization is a phenomenon in which $N$ copies of channel $W$ are transformed into $N$ synthetic channels with either increased or decreased reliability relative to $W$ [1]. The $K$ most reliable channels are designated as the information set $\mathcal{I}$, and selected to transmit information. The $N-K$ remaining channels comprise frozen set $\mathcal{F}$.

A message $\bm{a}$ of length $K$ is expanded into the sourceword $\bm{u}=(u_{0},u_{1},\ldots,u_{N-1})$ by placing the elements of $\bm{a}$ into indices from $\mathcal{I}$, while all indices in $\mathcal{F}$ are set to 0 and considered frozen. The codeword $\bm{x}=(x_{0},x_{1},\ldots,x_{N-1})$ can be encoded by computing $\bm{x}=\bm{u\cdot G}$, where the generator matrix $\bm{G}=\bm{T_{2}}^{\otimes n}$. In other words, $\bm{G}$ is equal to the Kronecker product of the matrix \bm{T_{2}}=\bigl{[}\begin{smallmatrix}1&0\\ 1&1\end{smallmatrix}\bigr{]} that has been carried out $n\in\mathbb{N}^{+}$ times. $\bm{T_{2}}$ is the polarizing matrix proposed by Arıkan in [1] and will be referred to in this paper as the Arıkan kernel.

II-A Multi-Kernel Polar Codes

Utilization of alternate polarizing matrices, known as kernels, in the formulation for $\bm{G}$ was proposed in [9] and outlined the possibility of obtaining polar codes that are not constrained to lengths that are powers of $2$. The ternary kernel \bm{T_{3}}=\Bigl{[}\begin{smallmatrix}1&1&1\\ 1&0&1\\ 0&1&1\end{smallmatrix}\Bigr{]} was proposed as the $3\times 3$ polarizing matrix. $\bm{T_{3}}$ was shown to be optimal for polarization in [7], though it has a polarization exponent that is less than that of $\bm{T_{2}}$. $\bm{T_{3}}$ can be used as a Kronecker product constituent in conjunction with the Arıkan kernel to produce any polar code of length $N=2^{n}3^{m}$ where $n,m\in\mathbb{N}$. The native length flexibility of polar codes is thus improved. However it should be noted that the order of the kernels in the Kronecker product affects $\bm{G}$. For example, a polar code of length $N=6$ could be encoded with either $T_{2}\otimes T_{3}$ or $T_{3}\otimes T_{2}$, which are two unique generator matrices. For clarity, we can refer to a kernel vector $k$ that stores the sizes of the kernels in order as they pertain to the generator matrix. The generator matrix can then be defined as

[TABLE]

Observe that the kernel order in a MK Tanner graph is reversed from that of the the Kronecker product, as can be seen in Fig. 1. Further, additional kernels of size higher than 3 have been proposed, although the Arıkan and ternary kernel are the most common and least complex to use. As such, we will only investigate MK polar codes derived from these two kernels. Polar codes that use only the Arıkan kernel will be further referred to as Arıkan polar codes.

II-B Successive Cancellation Decoding

Decoding of MK polar codes can be accomplished using successive cancellation (SC) [1]. The encoding Tanner graph is restructured into a tree with $M=n+m$ stages, which visualizes the SC algorithm. SC involves a tree search with left-to-right branch priority, where the leaf nodes in the tree represent the estimated sourceword $\bm{\hat{u}}$. The top of the tree serves as the decoder input, which is the received soft data vector $\bm{y}$ in the form of real log likelihood ratios (LLR).

Beginning from the top of the tree, the branches are traversed by applying LLR transformations and storing the results in the proceeding stage. Each stage $S\in\left[0,M\right]$ pertains to either the Arıkan or ternary kernel and contains $P=\frac{N}{p}$ nodes, where $p=\prod_{i=1}^{S-1}k_{i}$. At the bottom stage of the tree, ie $S=0$, $p=1$. Each node in stage $S$ stores both $p$ LLRs and bit partial sums and invokes $\frac{p}{2}$ or $\frac{p}{3}$ transformations upon entering, depending on the kernel of stage $S-1$. If the stage $S$ pertains to the Arıkan kernel, the functions $f$ or $g$, found in eq. 2, are applied to the left and right branches, respectively.

[TABLE]

In the case that stage $S$ corresponds to the ternary kernel, the functions $\lambda_{0}$, $\lambda_{1}$, and $\lambda_{2}$ are applied to the left, center, and right branches, respectively.

[TABLE]

where $a\boxplus b\approx\operatorname{sign}{(a)}\operatorname{sign}{(b)}\min{(|a|,|b|)}$, $l_{0},l_{1},l_{2}$ symbolize LLR values, and $u_{0},u_{1}$ denote a partial sum located in a left or center node, respectively. When a leaf node is entered, a hard bit decision is made using the LLR stored as

[TABLE]

A modified version of this hard decision function that neglects whether $i\in\mathcal{F}$ will be referenced throughout this paper as $h()$. After computing a bit decision or returning from a right branch, $p$ partial sum updates are executed at the previous node before moving down another branch. The partial sum updates are also referred to as combine operations. For Arıkan stages, the combine operation is $c_{2}(s_{0},s_{1})=(s_{0}\oplus s_{1},s_{1})$, while for a ternary stage it is $c_{3}(s_{0},s_{1},s_{2})=(s_{0}\oplus s_{1},s_{0}\oplus s_{2},s_{0}\oplus s_{1}\oplus s_{2})$. Ostensibly, an SC decoder can be expressed as schedule of $f$, $g$, $\lambda_{0}$, $\lambda_{1}$, and $\lambda_{2}$ operations, where the total number of operations described by $(n+m)N$. Fig. 1(b) depicts a schedule representation of an SC decoder that contrasts from the tree representation in Fig. 3.

II-C Frozen Set Design

In order to select $K$ indices to constitute $\mathcal{I}$, all $N$ indices must be sorted by reliability. Several accurate reliability ordering algorithms exist for conventional polar codes. Among them is Arıkan’s Bhattacharyya parameter expansion [1], which has only been proven to be exact for binary erasure channels, although it can be used as an approximation when transmitting over a Gaussian channel. A more accurate reliability representation can be generated using Trifonov’s Gaussian Approximation (GA) [10]. The process assumes all LLRs at each stage of the decoder are Gaussian distributed, and so the absolute value of the mean of each index is tracked through each LLR transformation from one stage to the next. To begin, all $N$ indices have the same distribution as the channel $W$. Assuming an AWGN channel with mean [math] and variance $\sigma^{2}$, each index is initialized as

[TABLE]

To compute the means of the next stage, apply the following equations if the stage corresponds to an Arıkan kernel:

[TABLE]

If the stage corresponds to a ternary kernel, instead apply the following:

[TABLE]

where $\phi(x)$ and $\phi(x)^{-1}$ are approximated as

[TABLE]

where $\alpha=-0.4527,\beta=0.0218,\gamma=0.86,a=\frac{1}{\alpha},b=\frac{-\beta}{\alpha}$, and $c=\frac{1}{\gamma}$. These approximations are available from the open source error correction code simulation tool aff3ct [11]. The exact formulas devised by Trifinov can be found in [10]. Proceeding to transform the LLR means for all stages will result in $N$ unique values, which can serve as a basis for which to rank the indices in ascending order. From here, $\mathcal{I}$ can be populated with the $K$ highest values and $\mathcal{F}$ will be composed of the remaining $N-K$ indices.

II-D Kernel Order Optimization

In [7], it was suggested that the order of kernels for a MK polar code can be optimized by searching all permutations for the order that produces the highest sum of bit reliabilities among the $K$ best indices. While this method is effective, it is not desirable to have this additional optimization step when comparing the practicality of MK polar codes with Arıkan polar codes.

Fig. 2 demonstrates that for long MK polar codes, the kernel optimization step is largely inconsequential. The figure depicts MK polar codes with $N=768$ and $N=2304$ sweeping rates $R=(\frac{1}{4},\frac{1}{2},\frac{3}{4})$ under SC decoding. The codes are constructed using GA for each point in the plot to ensure that the frozen sets are optimal throughout the simulation. Three different kernel ordering strategies are investigated. The First and Last labels indicate that kernels are ordered such that the ternary kernels serve as either the first or last components of the Kronecker product, respectively. Highest Reliability ensures that the kernel order is optimized for the highest overall reliability using the method outlined in the previous paragraph. It can be concluded that placing the ternary kernel in the Kronecker product at either the first or last positions produces comparable error correction results against an optimized kernel order for long polar codes. Further, observe that low rate codes have better performance using Last, while the opposite configuration performs best for medium to high rate codes.

III Fast-SSC Decoding

The essence of fast SC decoding is to prune the decoding tree to reduce the schedule and thus decrease latency [4]. This decoding technique is known as fast simplified SC (Fast-SSC) and works by identifying specific frozen set patterns that mirror embedded subcodes that can be decoded efficiently. These fast nodes are decoded with maximum likelihood, which indicates that FSSC retains the same error correction performance of SC. This section will outline the four basic fast nodes that are currently known and extend them to be compatible with the $\bm{T_{3}}$ kernel.

III-A Reduced Latency Nodes

In this section, we will investigate the compatibility of the four basic reduced latency nodes with the ternary kernel. We will present generalizations of each node type for any kernel ordering, though we also propose practical implementations that are valid under certain constraints.

III-A1 Rate-0 Node

A Rate-0 nodes one that leads to a set of leaf nodes with indices $i\in\mathcal{F}$ does not need to be traversed further since it is known that all $p$ leaf nodes and partial sums are 0 [12]. Further, any node that leads to a set of intermediate nodes that are all Rate-0 is also Rate-0. This relationship does not change when considering the ternary kernel since encoding $(0,0,0)$ with $\bm{T_{3}}$ results in $(0,0,0)$.

III-A2 Rate-1 Node

Any node that is parent to leaf nodes whose indices $i\in\mathcal{I}$ is considered a Rate-1 node, as are any nodes that are parent to only Rate-1 nodes. Rate-1 nodes can be decoded by setting the $p$ partial sums at that stage with a hard decision on each soft LLR in that node and then updating the values of the leaf nodes by hard decoding the partial sums [12]. Specifically, the partial sums vector $\bm{\beta_{v}}$ in node $v$ are obtained from the LLR vector $\bm{\alpha_{v}}$ by $\bm{\beta_{v}}=h(\bm{\alpha_{v}})$. The estimated sourceword values in $\bm{\hat{u}_{v}}\subset\bm{\hat{u}}$ with indices in $\mathcal{I}_{v}\subset\mathcal{I}$ are hard decoded using $\bm{\hat{u}_{v}}=\bm{\beta_{v}}\bm{G}_{p}^{-1}$ where $\bm{G}_{p}$ is the generator matrix obtained by performing the Kronecker product of kernels pertaining to all stages below that of node $v$. Alternatively, $\bm{\hat{u}_{v}}$ may be estimated by propagating the partial sums $\bm{\beta_{v}}$ to the leaf nodes with inverse partial sum equations for each stage where $c_{2}^{-1}=c_{2}$ and $c_{3}^{-1}(s_{0},s_{1},s_{2})=(s_{0}\oplus s_{1}\oplus s_{2},s_{1}\oplus s_{2},s_{0}\oplus s_{2})$.

The following is a proof that outlines the validity of this decoding method for stages corresponding to $\bm{T_{3}}$. Each Rate-1 node $v$ has the property that

[TABLE]

where $\bm{\alpha_{v_{l}}}$, $\bm{\alpha_{v_{c}}}$, and $\bm{\alpha_{v_{r}}}$ are the LLRs in the three branches below node $v$, as depicted in Fig. 3(a). For shorthand, let $e=3i$, $o=3i+1$, and $u=3i+2$ for all fixed $i$. Recall that the $\boxplus$ operator has the property

[TABLE]

And so assuming that $\alpha_{v}[e]\neq 0$, $\alpha_{v}[o]\neq 0$, and $\alpha_{v}[u]\neq 0$ indicates that

[TABLE]

where (a) uses eq. 5. Further,

[TABLE]

where (b) also makes use of eq. 5. Hence, the proof is completed and asserts confirmation that decoding of a Rate-1 node can be computed using the same method for $\bm{T_{3}}$ as for $\bm{T_{2}}$. The original proof in [12] describes through induction that this method of decoding holds for a Rate-1 node of any depth.

III-A3 Single-Parity Check Node

For an Arıkan polar code of rate $R=\frac{N-1}{N}$, the lowest order bit $u_{0}$ will be frozen. Such a polar code can be interpreted as a single-parity check (SPC) code. For instance, if $N=4$, then $\bm{u}=(0,a_{0},a_{1},a_{2})$ and $\bm{x}=(a_{0}\oplus a_{1}\oplus a_{2},a_{0}\oplus a_{2},a_{1}\oplus a_{2},a_{2})$. An SC node $v$ with $\mathcal{F}_{v}$ that reflects this pattern can be optimally decoded with low complexity. First, the partial sums $\bm{\beta_{v}}$ are estimated with a hard decision in the usual fashion, ie $\bm{\beta_{v}}=h(\bm{\alpha_{v}})$. The parity of $\bm{\beta_{v}}$ is then computed using

[TABLE]

If the parity constraint is not fulfilled, then the least reliable bit at index $j$ is flipped as in

[TABLE]

where $j=\operatorname*{argmin}_{i}|\alpha_{v}[i]|$. Finally, $\bm{\hat{u}_{v}}$ is computed using the same hard decoding procedure as a Rate-1 node.

In MK polar codes with rate $R=\frac{N-1}{N}$, $u_{0}$ will always be frozen regardless of the order of kernels, and so MK polar codes also have an embedded SPC property. Observe that if $N=3$, then $\bm{u}=(0,u_{0},u_{1})$ and $\bm{x}=(u_{0},u_{1},u_{0}\oplus u_{1})$. As such, SPC nodes can be identified and decoded in exactly the same way as with polar codes using only the Arıkan kernel.

III-A4 Repetition Node

In an Arıkan polar code with rate $R=\frac{1}{N}$, only the highest order bit $u_{N-1}$ will contain information. This frozen set pattern renders the polar code into a repetition (REP) code. Any node $v$ identified as a REP node is decoded simply by summing all soft LLRs and taking a hard decision on the result. The resulting bit is stored in all indices of $\bm{\beta_{v}}$:

[TABLE]

The partial sum $\bm{\beta_{v}}$ can then be hard decoded to compute $\bm{\hat{u}_{v}}$. Alternatively, $\bm{\hat{u}_{v}}$ can be evaluated more efficiently with

[TABLE]

The ternary kernel also mirrors repetition codes when presented with the same frozen set pattern, although the decoding procedures are more involved. Unlike the Arıkan kernel, when the highest order bit of a ternary kernel is the only information bit, the data is not repeated in all codeword bits. Specifically, if $N=3$ and $\bm{u}=(0,0,a_{0})$, then $\bm{x}=(0,a_{0},a_{0})$. In this example, repetition decoding can still be carried out, supposing the first index is excluded in the sum in eq. 9. Generally, a REP node $v$ at stage $S$ has REP pattern $P_{v}$, which is determined for any combination of Arıkan or ternary kernels by performing a recursive Kronecker product of repetition patterns $P_{2}=(1,1)$ or $P_{3}=(0,1,1)$:

[TABLE]

Eq. 9 can then be modified to accommodate this new constraint:

[TABLE]

Table I outlines several examples of REP patterns with varying kernel orders. Repetition nodes can be appropriately labeled for decoder scheduling purposes depending on the order of kernels. A repetition node that is made up of only Arıkan kernels, previously the only type of REP node, can now be labeled as a REP2 node. REP nodes comprised of only ternary kernels can be labeled as REP3A nodes. Mixed kernel repetition nodes can be labeled REP3B or REP3C depending on the order of $\bm{T_{2}}$ or $\bm{T_{3}}$.

Although a MK polar code can be built using any arbitrary order of kernels, it often is the case that the non-Arıkan kernels are either the first or last constituents in the Kronecker expression used to compute $\bm{G}$. Further, Section II-D demonstrates that assuming the order of kernels without optimization presents comparable error correction results. Moreover, using LDPC WiMAX code lengths as a guideline [13] suggests that MK polar codes are able to achieve most desired code lengths with only a few stages of non-Arıkan kernels. Considering this behaviour of kernel orders in MK codes, it is unnecessary to implement generalized ternary repetition nodes as the majority of cases can be efficiently decoded under a few constraints. As such, the scheduling and implementation of MK REP nodes can be simplified by eliminating $P_{v}$ computation. We limit REP3A nodes to have a maximum size of 27 so that there are only 3 possible $P_{v}$ that can simply be stored instead of computed. Additionally, we limit REP3B and REP3C nodes to contain only a single ternary stage so that computation of $\bm{\beta_{v}}$ can be carried out efficiently:

[TABLE]

The summation in eq. 9 can be modified for REP3B nodes by skipping the first third of indices, while for REP3C node it is modified by skipping every third index. Of course, eq. 10 still applies to ternary repetition nodes. Under the requirement of only a single ternary stage, these nodes do not need to be limited in size. We will utilize these simplifications in our numerical analysis.

IV Complexity Reduction Evaluation

This section outlines the effectiveness of MK compatible Fast-SSC with numerical examples. With a sufficiently large processor, it can be assumed that each node in a decoding tree constitutes a single operation. As such, all measurements of decoding complexity refer to the number of decoding nodes. All polar codes analyzed were constructed using GA with a target $Eb/N0$ of 3dB adopting a BPSK modulation scheme, ie $\mathcal{M}=1$. Fig. 4 compares the number of computations in Fast-SSC decoders for various length-compatible polar codes over a range of codeword lengths and rates. Punct QUP [5] and Short WL [6] indicate puncturing and shortening patterns that allow for large numbers of frozen sets to be grouped together. Generally, Punct QUP and Short WL methods have comparable complexity to both kernel orderings of MK polar codes. However, MK codes with a high proportion of ternary stages, such as lengths $N=(216,324,648)$, have the fewest decoding operations overall when built with the Last kernel ordering. This is a result of the fast decoders for ternary nodes, which decode a larger number of bits simultaneously than would Arıkan nodes. This is depicted in Fig. 3(a) where a node in stage $S=2$ decodes 9 bits at once, where as node in the same stage of Fig. 3(b) decodes only 6 bits at once. Therefore, it may be desirable to construct MK polar codes using the Last kernel ordering from a decoding complexity standpoint for particular code lengths.

Regarding latency reduction of MK decoding, Table II outlines various comparisons between SC and Fast-SSC along with the node makeup of Fast-SSC decoding schedules. Just as with Arıkan polar codes, there is a greater latency reduction for extreme rates. This gain is due to the higher proportion of Rate-1 and SPC nodes for high rates and Rate-0 and REP nodes for low rates. Observe that longer MK polar codes have greater latency reduction than short polar codes. It should also be noted that MK polar codes with a higher number of ternary stages have increased latency with the First kernel permutation compared with Last. Further, the number of ternary repetition nodes is proportionately low, so it is sufficient to consider only the most common cases for a simplified implementation rather than a generalized algorithm as outlined in Section III-A4.

V Conclusion

In this work, we extended the Fast-SSC polar code decoder to be compatible with MK polar codes. The four basic fast nodes were generalized to be able to decode MK codes with arbitrary kernel orders. We propose simplified implementations of ternary repetition nodes that are valid under imposed constraints that reflect typical MK behavior. We have observed that in all tested cases, a minimum 72% latency reduction of SC is achievable for MK polar codes. This study can act as a guideline for future work on a hardware implementation of a fast MK decoder.