Minimum-Distance Based Construction of Multi-Kernel Polar Codes

TL;DR

This paper introduces a new construction method for multi-kernel polar codes that maximizes minimum distance, leading to improved short-length code performance over traditional density evolution-based designs.

Contribution

It presents a minimum-distance based construction and a greedy algorithm for multi-kernel polar codes, enhancing error-rate performance especially for short codes.

Findings

Improved error-rate performance over Arikan polar codes

Effective for short code lengths with less polarization impact

Introduces minimum-distance profile and greedy design algorithm

Abstract

In this paper, we propose a construction for multi-kernel polar codes based on the maximization of the minimum distance. Compared to the original construction based on density evolution, our new design shows particular advantages for short code lengths, where the polarization effect has less impact on the performance than the distances of the code. We introduce and compute the minimum-distance profile and provide a simple greedy algorithm for the code design. Compared to state-of-the-art punctured or shortened Arikan polar codes, multi-kernel polar codes with our new design show significantly improved error-rate performance.

Tables

Table 1. TABLE I: Comparison of minimum distances for N = 6 𝑁 6 N=6 .

	Rate	$1/6$	$2/6$	$3/6$
Reliability	Information Set	$u_5$	$(u_4,u_5)$	$(u_2,u_4,u_5)$
Design	Minimum Distance	4	4	2
Distance	Information Set	$u_3$	$(u_4,u_5)$	$(u_0,u_4,u_5)$
Design	Minimum Distance	6	4	3

Equations

$$T_2=\left(\begin{array}{cc}1& 0\\ 1& 1\end{array}\right).$$

$$T_3$$

$$G_N=T_{p_1}\otimes T_{p_2}\cdots \otimes T_{p_s},$$

$${\lambda }_0$$

$${\lambda }_1$$

$${\lambda }_0$$

$${\lambda }_1$$

$${\lambda }_2$$

$${\lambda }_0$$

$${\lambda }_1$$

$${\lambda }_2$$

$${\lambda }_3$$

$${\lambda }_4$$

$$S_{T_2^{\otimes n}}=\mathrm{sort}([21{]}^{\otimes n}),$$

$$G_6=T_2\otimes T_3=\left(\begin{array}{cc}{T}_3& 0\\ T_3& T_3\end{array}\right)=\left(\begin{array}{cccccc}1& 1& 1& 0& 0& 0\\ 1& 0& 1& 0& 0& 0\\ 0& 1& 1& 0& 0& 0\\ 1& 1& 1& 1& 1& 1\\ 1& 0& 1& 1& 0& 1\\ 0& 1& 1& 0& 1& 1\end{array}\right).$$

Full text

I Introduction

Polar codes, introduced by Arikan in [1], are a new class of channel codes which achieve capacity over various classes of channels under low encoding and decoding complexity. Also for finite-lengths, these codes show remarkable error rate performance under list decoding. Only seven years after their discovery, polar codes were recently adopted in the standardization for the control channel of the future 5G system, where the focus is on short-length codes.

In their original construction, polar codes are based on the polarization effect of the Kronecker powers of the $2\times 2$ kernel matrix $T_{2}=\tiny\begin{pmatrix}1&0\\ 1&1\end{pmatrix}$. The generator matrix of a polar code is then a sub-matrix of the transformation matrix $T_{2}^{\otimes n}$. Arikan conjectured in [1] that the polarization effect is not restricted to powers of the kernel $T_{2}$, which was verified in [2], where the authors provide necessary and sufficient conditions for binary kernels $T_{p}$ of size $p\times p$, $p>2$, to allow for the polarization effect. Recently, polar codes based on larger kernels were proposed in [3, 4], while in [5] authors propose to use different kernels of the same size to construct the transformation matrix of the code.

Thanks to these ideas, it is now possible to construct polar codes of any code length of the form $N=p^{n}$. However, not all code lengths can be expressed as powers of integers. To overcome this length matching problem, puncturing [6], [7] and shortening [8] techniques have been proposed to construct polar codes of arbitrary lengths, at the cost of a loss in terms of polarization speed, and hence worse error rate performance.

To tackle the code length problem of polar codes, a multi-kernel construction has been proposed in [9]. By mixing binary kernels of different sizes in the transformation matrix, codes of lengths that are not only powers of integers can be constructed. The resulting multi-kernel polar code still benefits from the polarization effect while decoded through successive cancellation [10]. As a result, the new multi-kernel construction largely increases the number of code lengths that can be achieved without puncturing or shortening, with comparable or even better error-rate performance.

For codes based on the polarization effect, the reliability of the input positions is determined by density evolution or other techniques, and then the least reliable positions are frozen. This is the design principle of the original construction of polar codes of infinite length [1], and it is similarly used for the design of multi-kernel polar codes [9]. Such design by reliability is appropriate for long codes under successive cancellation decoding; for short codes under list decoding [11], however, design principles that give more weight to distance properties may give superior error-rate performance. Related to this is the work in [12], where reliability-based design of polar codes for better channels is shown to lead to better distance properties, and ultimately to Reed-Muller codes.

In this paper, we propose a construction of multi-kernel polar codes that maximizes the minimum distance. We show how to find kernels of size larger than 2 that are advantageous in our construction. Moreover, we present a simple greedy code design algorithm that maximizes the minimum distance for given kernels. Due to the special structure of the kernels of larger size and the resulting flexibility in the code design, our construction of multi-kernel polar codes leads to better distance properties and thus to superior error rate performance under successive cancellation list decoding, compared to the reliability-based construction, and also compared to shortened or punctured codes based on $T_{2}^{\otimes n}$.

This paper is organized as follows. In Section II, we review construction, encoding, and decoding of multi-kernel polar codes. In Section III we describe explicitly the new distance-based design for multi-kernel polar codes. In Section IV we illustrate numerically the performance of the codes, and Section V concludes this paper.

II Multi-Kernel Polar Codes

In this section, we briefly review the structure, encoding and decoding of multi-kernel polar codes; for details, we refer the reader to [9]. Multi-kernel polar codes are a generalization of the Arikan polar codes [1], simply referred to as polar codes throughout the paper, and therefore we will provide a comparison to the Arikan construction for clarity.

II-A Code Structure and Encoding

Polar codes are based on the Kronecker product $G_{N}=T_{2}^{\otimes n}$, $N=2^{n}$, where $T_{2}$ denotes the $2\times 2$ kernel

[TABLE]

Let us assume an information set $\mathcal{I}\subset[N]$, $[N]=\{0,1,\ldots,N-1\}$, of size $|\mathcal{I}|=K$ and a corresponding frozen set $\mathcal{F}=[N]\backslash\mathcal{I}$ of size $|\mathcal{F}|=N-K$. An $(N,K)$ polar code of length $N$ and dimension $K$ is then defined by the encoder $x=u\;G_{N}$, mapping the input vector $u\in\operatorname{\mathbb{F}_{2}}2^{N}$ to the codeword $x\in\operatorname{\mathbb{F}_{2}}2^{N}$, where $u_{i}=0$ for $i\in\mathcal{F}$, denoting the frozen bits, and $u_{i}$, $i\in\mathcal{I}$, are the information bits.

Multi-kernel polar codes generalize this construction by mixing binary kernels of different sizes in the Kronecker product forming the transformation matrix. Examples of such kernels, which are used in this paper, are

[TABLE]

The transformation matrix of a multi-kernel polar code is given by

[TABLE]

where $T_{p_{i}}$, $i=1,2,\ldots,s$, denotes the kernel matrix of size $p_{i}\times p_{i}$, and kernels of same size can be used multiple times, i.e., it may be that $p_{i}=p_{j}$ for some $i,j$. The length of the code is $N=p_{1}\cdot p_{2}\cdots p_{s}$. Note that the ordering of the kernels in the Kronecker product is important for the frozen set design, as the Kronecker product is not commutative. An $(N,K)$ multi-kernel polar code is defined by the transformation matrix $G_{N}$ and the information set $\mathcal{I}$, with corresponding frozen set $\mathcal{F}=[N]\backslash\mathcal{I}$. Codewords $x\in\operatorname{\mathbb{F}_{2}}2^{N}$ are generated from the input words $u\in\operatorname{\mathbb{F}_{2}}2^{N}$ by $x=u\;G_{N}$, where $u_{i}=0$ for $i\in\mathcal{F}$ and $u_{i}$, $i\in\mathcal{I}$, stores the information bits. In [9], $\mathcal{I}$ is generated according to the reliabilities of the positions in the input vector $u=(u_{0},u_{1},\ldots,u_{N-1})$, which can be determined e.g. through density evolution [13]. In this case, the information set is composed by the $K$ most reliable positions.

Similar to polar codes, the Tanner graph of multi-kernel polar codes can be constructed. While the Tanner graph of polar codes consists solely of $2\times 2$ blocks, each corresponding to the kernel $T_{2}$, the Tanner graph of multi-kernel polar codes consists of various blocks, corresponding to the different kernels used. The Tanner graph for the transformation matrix in (2) consists of $s$ stages. On stage $i$, there are $N/p_{i}$ blocks, each of size $p_{i}\times p_{i}$, corresponding to a $T_{p_{i}}$ kernel, with $p_{i}$ edges to the left and to the right. The connections and edge permutations follow from the Kronecker product [9]. An example is given in Fig. 1, with edge-permutations indicated by dotted boxes.

II-B Decoding of Multi-Kernel Polar Codes

Decoding of multi-kernel polar codes is performed similarly to polar codes, using successive cancellation (SC) decoding on the Tanner graph of the code [9], or enhanced SC-based decoding methods like SC list (SCL) decoding [11]. Log-likelihood ratios (LLRs) are passed along the Tanner graph from the right to the left, while hard decisions on decoded bits are passed from the left to the right. The major difference to decoding of polar codes is given by the computations in the blocks corresponding to the new kernels.

The notation used for the $p\times p$ block corresponding to a $T_{p}$ kernel is depicted in Fig. 2. Denote $u=(u_{0},u_{1},\ldots,u_{p-1})$ the binary input vector to this block and $x=(x_{0},x_{1},\ldots,x_{p-1})$ its binary output vector. Then we have the relationship $u\;T_{p}=x$, defining the update rule for the hard-decisions going from left to right. Further denote $L_{i}$ the LLR of output bit $x_{i}$ and $\lambda_{i}$ the LLR of the input bit $u_{i}$. The general structure of the update rule for LLRs, going from right to left, is $\lambda_{i}=f(L_{0},L_{1},\ldots,L_{l-1},\hat{u}_{0},\hat{u}_{1},\ldots,\hat{u}_{i-1})$, i.e., all LLRs $L_{j}$ and only previous hard-decisions (estimates) $\hat{u}_{j}$ may be used for the computation, following the SC principle. The corresponding LLR calculations for $T_{2}$ from [1] are

[TABLE]

for $T_{3}$ depicted in (1), from [9], are

[TABLE]

and for $T_{5}$ in (1), presented here for the first time, are

[TABLE]

The boxplus operator for two LLRs $a$ and $b$ may be evaluated exactly as a\boxplus b=2\tanh^{-1}\bigl{(}\tanh\frac{a}{2}\cdot\tanh\frac{b}{2}\bigr{)} or approximately as $a\boxplus b\approx\operatorname{sgn}a\cdot\operatorname{sgn}b\cdot\min\{|a|,|b|\}$; the extension to multiple LLRs is as usual. For other kernels similar LLR update equations can be derived [14]. In the next section, we will show that the presented kernels $T_{3}$ and $T_{5}$ permit to construct multi-kernel polar codes with good minimum distance.

III Design for Minimum-Distance

In this section, we describe how to design multi-kernel polar codes to increase the minimum distance of the code. In [9], the information set $\mathcal{I}$ is selected according to reliability. This approach, which is also commonly followed for polar codes, is optimal for SC decoding when the code length tends to infinity. For short codes, however, the distance properties are more crucial than the polarization effect.

In the following, we focus on multi-kernel polar codes with transformation matrix of the form $G_{N}=T_{2}^{\otimes n}\otimes T_{p}$, i.e., a polar code composed with a larger kernel at the end. This is not a very limiting assumption for the following reasons. First, the proposed design is to be used for short codes, for which the use of a single larger kernel is usually sufficient. Second, the larger kernel can be the composition of multiple smaller kernels. And third, changing the order of the kernels in the Kronecker product is equivalent to a row and column permutation of $G_{N}$, and thus leads to equivalent codes.

III-A Minimum-Distance Spectrum

In the following, we will determine the minimum distance $d$ achievable by a code generated by selecting $K$ rows of a transformation matrix $G_{N}$. More formally, we define the minimum-distance spectrum $S_{G_{N}}$ of the transformation matrix $G_{N}$ to be the mapping from dimension $K$ to the maximal minimum distance $d$ achievable by selecting an information set $\mathcal{I}$ of size $K$, i.e., $S_{G_{N}}(K)$ is the largest minimum distance achievable by an $(N,K)$ multi-kernel polar code derived from the transformation matrix $G_{N}$.

Finding the minimum-distance spectrum of a code is in general a complex task, which may be accomplished e.g. by an exhaustive search. Under certain constraints, however, the minimum-distance spectrum of a multi-kernel polar code can be easily calculated based on the minimum-distance spectra of its building kernels. In fact, for polar codes,

[TABLE]

where $\operatorname{sort}(x)$ is the vector $x$ sorted in decreasing order, since polar codes have the same transformation matrix as Reed-Muller codes. In the following, we prove that a similar property holds for multi-kernel polar codes, allowing one to calculate the minimum-distance spectrum of the transformation matrix $G_{N}$ using the Kronecker product of the spectra of the kernels composing it.

Proposition 1** (Minimum-distance spectrum).**

If $G_{N}=T_{2}^{\otimes n}\otimes T_{p}$, then $S_{G_{N}}=\operatorname{sort}(S_{T_{2}^{\otimes n}}\otimes S_{T_{p}})$.

Proof.

The proposition is proved by induction on the number $n$ of $T_{2}$ kernels employed in the transformation matrix $G_{N}$. The property obviously holds for $n=0$, and by inductive hypothesis we suppose that $S_{G_{N/2}}=\operatorname{sort}(S_{T_{2}^{\otimes n-1}}\otimes S_{T_{p}})$ given $G_{N/2}=T_{2}^{\otimes n-1}\otimes T_{p}$. Given the transformation matrix $G_{N}=T_{2}^{\otimes n}\otimes T_{p}=\tiny\begin{pmatrix}G_{N/2}&0\\ G_{N/2}&G_{N/2}\end{pmatrix}$, this matrix can be divided into two parts, an upper matrix $G^{U}=[G_{N/2}|\mathbf{0}]$ and a lower matrix $G_{L}=[G_{N/2}|G_{N/2}]$, for which $S_{G^{U}}=S_{G_{N/2}}$ and $S_{G^{L}}=2S_{G_{N/2}}$. Given $V=\operatorname{sort}(S_{T_{2}^{\otimes n}}\otimes S_{T_{p}})$, the goal of the proof is to show that $S_{G_{N}}=V$, i.e., that for every dimension $K$, there exists a subset of $K$ rows of $G_{N}$ such that the span of these rows has minimum distance $V(K)$.

To do that, for every $K$ we show how to construct a sub-matrix of $G_{N}$ for which all the vectors of its span have Hamming weight not smaller than $V(K)$. In fact, by construction, for every $K$ there exist two integers $K^{U}$ and $K^{L}$ such that $K^{U}+K^{L}=K$, and two sub-matrices $G_{A}^{U}$ and $G_{B}^{L}$, formed by $K^{U}$ rows of $G^{U}$ and by $K^{L}$ rows of $G^{L}$ respectively, such that $S_{G_{A}^{U}}(K^{U})\geq V(K)$ and $S_{G_{B}^{L}}(K^{L})\geq V(K)$. To end the proof, it is sufficient to use the distance property of the classical $(u|u+v)$ construction [15] to verify that the code generated by $G_{A,B}=\left[\frac{G_{A}^{U}}{G_{B}^{L}}\right]$ has minimum distance $\min(S_{G_{A}^{U}}(K),S_{G_{B}^{L}}(K))=V(K)$. ∎

The proposition shows how to exploit the spectra of the building kernels to evaluate the minimum-distance spectrum of the multi-kernel polar code. Moreover, the constructive nature of the proof suggests a greedy technique to build multi-kernel polar codes with optimal minimum distance. Before describing the algorithm in detail, in the following section we present kernel design principles leading to codes with good minimum distance spectra.

III-B Kernel Design

For polar codes, kernels are usually designed to maximize the polarization effect on the input bits of the transformation $G_{N}$, and the information positions are then selected in reliability order. For short codes, however, the polarization effect is far less important than distances of the code, and kernels should be designed taking this aspect into account. Different kernels have different spectra, while polar codes are limited by the spectrum of the kernel $T_{2}$. Multi-kernel polar codes permit to create codes of desired minimum distance by changing the kernels composing the transformation matrix. If the kernels are designed properly, the information set can then be selected such that a large minimum distance is achieved for the desired length and dimension.

As an example, consider the $T_{3}$ kernel depicted in (1), introduced in [9], and its minimum-distance spectrum. For the information set of size 1, one row has to be selected: in order to maximize the minimum distance, the first row, $(1\;1\;1)$, is selected, giving minimum distance 3; any other row selection would result in a smaller minimum distance, namely 2. For the information set of size 2, the last two rows, $(1\;0\;1)$ and $(0\;1\;1)$, are selected, generating a code of minimum distance 2; any other row selection would result in a smaller minimum distance. Finally, for a code of dimension 3, all rows have to be selected, resulting in a code of minimum distance 1. $T_{3}$ thus has the minimum-distance spectrum $S_{T_{3}}=(3,2,1)$. As opposed to that, the construction by reliability selects the last row for dimension 1, the last two rows for dimension 2, and all rows for dimension 3; this gives minimum-distance spectrum $(2,2,1)$. The proposed $T_{5}$ kernel presents a similar behavior, with minimum-distance spectrum $S_{T_{5}}=(5,3,2,1,1)$.

III-C Greedy Row-Selection Algorithm

In the previous sections, we described how to calculate the minimum-distance spectrum of the transformation matrix of a certain class of multi-kernel polar codes. The scope of this section is to describe how to determine the actual information set that achieves this minimum distance. As for the minimum-distance spectrum itself, this may be accomplished by an exhaustive search, which in general will be very complex. The proof of Proposition 1, however, gives an insight on how to select rows of $G_{N}$ to achieve the minimum-distance spectrum.

In the following we describe a greedy algorithm able to accomplish this task; the pseudo code is provided in Algorithm 1. Since the algorithm is based on Proposition 1, it finds an optimal solution if only one kernel of size larger than 2 is used in the construction, and this kernel is the last term in the Kronecker product. The algorithm may as well be applied in the case of multiple kernels of size larger than 2, also at the end of the Kronecker product, by treating the Kronecker product of these kernels as one large kernel, for which the minimum-distance spectrum has to be determined before the algorithm is applied.

Given a transformation matrix $G_{N}=T_{2}^{\otimes n}\otimes T_{p}$, we assume the kernel $T_{p}$ to have minimum-distance spectrum $S_{T_{p}}=(d_{p}(1),\cdots,d_{p}(p))$, where $d_{p}(k)$ is the minimum distance of the code of dimension $k$. The list $I^{k}=\{i^{k}_{1},\dots,i^{k}_{k}\}$ is associated to every entry $d_{p}(k)$ of the spectrum, collecting the indices of the $k$ rows of $T_{p}$ giving the optimal minimum distance of the kernel. To begin with, the vector $r_{N}=(2,1)^{\otimes n}\otimes S_{T_{p}}$ is created. This vector is an unsorted version of the minimum-distance spectrum, collecting the minimum achievable distances of each part of $G_{N}$.

For a code of dimension $K$, at each step the algorithm adds sequentially one row index to the information set $\mathcal{I}$, which is initially empty. At each step, the position $l$, with $l=0,\dots,N-1$, of the last largest entry in $r_{N}$ is found, and $r_{N}(l)$ is set to zero. After that, the value $c=(l\>\text{mod}\>p)+1$ and $q=l-c+1$ are calculated, giving the row position within the kernel and the row index in the transformation matrix where the corresponding kernel starts, respectively. In fact, since in $S_{T_{p}}$ the distances are sorted in descending order, we know that $\{i^{c}_{1}+q,\dots,i^{c}_{c}+q\}\subset\mathcal{I}$. The algorithm deletes these $c$ indices belonging to $I^{c}$, substituting them with the $c+1$ indices given by $I^{c+1}$; by the constructive proof of Proposition 1, we know that the resulting code has the desired minimum distance. Of course, if $c=0$, no rows of that part of the matrix are already in the information set, and therefore no information indices are deleted. In practice, at each step the information set is updated as $\mathcal{I}=\mathcal{I}\setminus\{i^{c}_{1}+q,\dots,i^{c}_{c}+q\}\cup\{i^{c+1}_{1}+q,\dots,i^{c+1}_{c+1}+q\}$. The algorithm stops when $\mathcal{I}$ includes $K$ elements. The remaining $N-K$ indices compose the frozen set $\mathcal{F}$.

III-D Construction Example

To illustrate our construction, in the following we describe the minimum distance design of a multi-kernel polar code of length $N=6$ depicted in Fig. 1 with transformation matrix

[TABLE]

For the described kernel of size 3, we have that $S_{T_{3}}=(3,2,1)$ with $\mathcal{I}_{T_{3}}(1)=\{0\}$, $\mathcal{I}_{T_{3}}(2)=\{1,2\}$ and obviously $\mathcal{I}_{T_{3}}(3)=\{0,1,2\}$. The minimum-distance spectrum is given by $S_{G_{6}}=\operatorname{sort}((2,1)\otimes S_{T_{3}})=(6,4,3,2,2,1)$; consequently, $r_{6}=(3,2,1,6,4,2)$. It is worth noticing that the minimum-distance spectrum of the reliability construction is $(4,4,2,2,2,1)$. If a rate 1/2 code has to be designed, the positions of the $K=3$ information bits are needed. The information set $\mathcal{I}$ is initially empty. At the first step, $l=3$, hence $c=0$ and $q=3$; since $c=0$, no entries of $\mathcal{I}$ have to be deleted, and $\mathcal{I}=\{3\}$. At the second step, $l=4$, so $c=1$ and $q=3$; the information set is calculated as $\mathcal{I}=\mathcal{I}\setminus\{3\}\cup\{4,5\}=\{4,5\}$. Finally, at the third step $l=0$, and the resulting information set is $\mathcal{I}=\{4,5\}\cup\{0\}=\{0,4,5\}$. A comparison of the information sets calculated by the proposed algorithm following the distance criterion and the one resulting from the reliability order is presented in Table I for various dimensions $K$. We observe that the proposed design always outperforms the reliability-based designs in terms of minimum distance, or performs identically when the reliability-based construction is equivalent to the minimum-distance based construction.

IV Numerical Illustrations

In the following, we show the performance of the proposed minimum distance construction of multi-kernel polar codes. In particular, in Figures 3, 4, 5 and 6, we show the BLER performance of the codes designed according to the proposed minimum distance construction under list decoding [11] with list size $L=8$ for BPSK transmission over an additive white Gaussian noise (AWGN) channel. Our proposal, coined MK-dist in the figures, will be compared to the reliability-based design of multi-kernel polar codes proposed in [9], coined MK-rel in the figures. We emphasize that MK-dist is designed according to the row selection algorithm described in the previous sections. Moreover, we add as references state-of-the-art punctured [6] and shortened [8] polar code constructions, coined polar-punct and polar-short respectively.

First, in Figure 3, we show the performance of a code with length $N=192$ and dimension $K=96$. In this case, the transformation matrix is given by $T_{192}=T_{2}^{\otimes 6}\otimes T_{3}$, i.e., there is only one $T_{3}$ kernel at the rightmost of the Kronecker product. In this case, the proposed row selection algorithm can be run using the minimum-distance spectrum of the $T_{3}$ kernel presented before, and we observe that the minimum-distance based design outperforms all other designs.

In Figure 4 we show the performance of a code of length $N=144$ and dimension $K=72$. The transformation matrix is given by $T_{144}=T_{2}^{\otimes 4}\otimes T_{3}^{\otimes 2}$, i.e., there are two $T_{3}$ kernels at the rightmost of the Kronecker product. In this case, the minimum-distance spectrum for the Kronecker product kernel $T_{3}\otimes T_{3}$ has to be calculated, along with the auxiliary lists $\mathcal{I}_{T_{3}\otimes T_{3}}$. Potentially, two different kernels of size 3 may be used, like proposed in [5], augmenting the flexibility of the minimum-distance spectrum, but this kind of optimization is out of the scope of this paper. The resulting spectrum is $S_{T_{3}\otimes T_{3}}=(9,6,4,4,3,2,2,2,1)$, and the multi-kernel polar codes resulting from our design still outperform all other depicted designs.

In Figure 5 we show the performance of a code of length $N=40$ and dimension $K=20$. The transformation matrix is given by $T_{40}=T_{2}^{\otimes 3}\otimes T_{5}$, i.e., there is only one $T_{5}$ kernel at the rightmost of the Kronecker product. In this case, the BLER performance of the proposed construction is again better than the one of the other constructions, though the gain is smaller than in the previous two cases where $T_{3}$ is used.

Finally, in Figure 6 we show the performance of a code of length $N=90$ and dimension $K=45$. In this case, the transformation mixes three different kernels, and we define $T_{90}=T_{2}\otimes T_{3}^{\otimes 2}\otimes T_{5}$. The BLER performance of the proposed construction, while is only able to match the performance of the shortened polar code. This shows that the proposed algorithm should be further optimized in the presence of multiple high size kernels.

In conclusion, the proposed distance-based construction significantly outperforms state-of-the-art punctured and shortened polar codes for small block lengths, as well as the previously proposed reliability-based construction in [9]. We expect this property to hold true for short code lengths, when the polarization effect has lower importance than the distance profile in the design of the codes. Moreover, we argue that the encoder and the decoder of the proposed multi-kernel polar codes have a lower complexity compared to the encoder and the decoder of the state-of-the-art punctured polar codes, due to the larger length of the mother polar code and the reliability calculations required for these constructions [9].

V Conclusions

In this paper, we proposed a construction for multi-kernel polar codes, introduced in [9], based on the maximization of the minimum distance. While the original construction based on bit reliabilities is suitable for long codes, our new minimum-distance based construction provides significant performance gains for short codes, i.e., where the polarization effect is less important than distance properties. This gives fundamental insights for the design of multi-kernel polar codes of any length. We further introduced the minimum-distance spectrum of a transformation matrix, and we developed a greedy algorithm that finds the information set achieving this minimum distance. Simulations illustrate the competitive performance of our design for short-length codes.