An efficient algorithm for the reconstruction of punctured convolutional codes

Abstract

Puncturing is one of the methods of increasing the code rate, and the original code before puncturing is called the mother code. Any (N,K) convolutional code is obtainable by puncturing some (n,1) mother codes. The objective of a blind recognition of a channel code is to obtain its generator from the intercepted noisy bit stream. The process of the blind recognition of punctured convolutional codes consists of two parts: the reconstruction of the PGM of the (N,K) punctured convolutional code and the searching process of the mother code and its puncturing pattern. The process of finding the mother code is important for designing the optimum channel decoder. In this paper, a new searching algorithm with the computational complexity of O(K ⁴) polynomial operations is proposed, compared to the existing searching algorithm by M. Cluzeau which requires O(K ⁶) polynomial operations.

1 Introduction

In most of the digital communication systems through a noisy channel, the use of an error correction code is necessary for protecting the message from noise. In an attack context, the adversary wants to retrieve the message from the intercepted noisy bit stream without any prior knowledge of the channel codes used. For this purpose, finding out the code parameters such as code length, code dimension, and code generator is essential. This process is called the blind recognition of channel codes or the reconstruction of channel codes.

Rice [1] was the first to propose a method for the reconstruction of the convolutional codes of rate 1/n, and Filiol [2] generalized it for all rates. Barbier [3] improved Filiol’s technique using algebraic approach. Most of the reconstruction algorithms begin with the finding of n, the code length. Once the code length is recognized, the searching process for the generator matrix or the polynomial generator matrix starts. In the case of the reconstruction of punctured convolutional codes, an additional searching algorithm for finding mother code follows after the recognition of the polynomial generator matrix. In this case, revealing the mother code with its puncturing pattern is as much important as the recognition of the code itself in the sense of designing the optimum Viterbi decoder.

Recently, Cluzeau and Finiasz [4] proposed a searching algorithm for finding mother code in blind recognition of (N,K) punctured convolutional codes. In [4], the structure of the blocked PGM (polynomial generator matrix) of the mother code is used in finding the PGM of the punctured convolutional code. But, their algorithm has very high computational complexity especially for large K and cannot foretell whether the mother code with the specific puncturing pattern exists or not. The sufficient conditions for the existence of an (n,1) mother code and its puncturing pattern to generate a given convolutional code can be found in [5].

In this paper, we propose an alternative solution for this searching problem. The proposed algorithm employs the notion of dual codes and reduces the computational complexity.

The paper is organized as follows. The original idea in [4] of getting the PGM of the punctured convolutional codes from the blocked PGM of the mother code is reviewed in Section 2. In Section 3, we briefly introduce the existing algorithm in [4], propose a new reconstruction algorithm with the validity proof, and then compare the performance of each algorithm. Our conclusion is drawn in Section 4.

2 Punctured convolutional codes

A convolutional code is one of the most widely used channel codes. An (N,K) convolutional code is described by two parameters K and N, the number of input and output symbols, respectively. The rate K to N is called the code rate R=K/N. An (N,K) convolutional code is characterized by a (K×N) PGM G(D)=[g _i,j (D)], where g _i,j (D)∈F ₂[D] and D represents the delay operator. The encoding process can be described by

$$\begin{array}{@{}rcl@{}} c(D)=m(D)G(D) \end{array} $$

(1)

where m(D) is the message sequence vector and c(D) is the coded sequence vector. Since the set of coded sequence vectors forms a K-dimensional vector space, two distinct PGM G ₁(D) and G ₂(D) may yield the same set of coded sequence vectors. In this case, the two PGM are said to be equivalent. The formal definition of equivalence is given below.

Definition 1

Two (N,K)convolutional encoders G ₁(D) and G ₂(D) are equivalent if and only if there exist a K×K polynomial matrix T(D)with rank K, called transition matrix, over F ₂(D) such that

$$\begin{array}{@{}rcl@{}} G_{1}(D)=T(D)G_{2}(D). \end{array} $$

(2)

The dual code of an (N,K) convolutional code has an (N−K)×N PGM H(D) satisfying that

$$\begin{array}{@{}rcl@{}} G(D)H(D)^{T}=[0]. \end{array} $$

(3)

A common way to generate a high-rate convolutional code is by puncturing a low rate (n,1) code, called the mother code. A punctured convolutional code is obtained through a periodic deletion of encoded symbols generated from the mother code. The pattern of deleting symbols is called the puncturing pattern. The PGM of the punctured convolutional code can be derived from that of the mother code [4]. Here, we briefly review the notion of K-times blocked code introduced in [4]. The (n,1) mother code can be viewed as an (n K,K) code called the K-times blocked code with K parallel inputs and nK outputs. The first step of representing the PGM of the K-times blocked code is obtaining the polynomials g _l (D)’s from the polynomial g(D). For a polynomial $g(D)=\sum _{i} a_{i}D^{i}$, let D ^l g _l (D ^K), 0≤l≤K−1, denote the part of g(D) consisting only of the terms of degree l mod K, so that $g(D)=\sum _{l=0}^{K-1}D^{l}g_{l}\left (D^{K}\right)$. Using the polynomials g _l (D)’s, we can define $\overrightarrow {v_{K}}(g(D))$ given below as the mod −K representation of the polynomial g(D).

$$\begin{array}{@{}rcl@{}} \overrightarrow{v_{K}}(g(D))=\left(g_{K-1}(D),g_{K-2}(D),\cdots, g_{0}(D)\right)^{T} \end{array} $$

(4)

Now, assume that the PGM G _M (D) of the (n,1) mother code is given as

$$\begin{array}{@{}rcl@{}} G_{M}(D)=\left[g^{(0)}(D)\,g^{(1)}(D)\,\cdots \,g^{(n-1)}(D)\right]. \end{array} $$

(5)

Then, the PGM G _B (D) of the K-times blocked code can be expressed as

$$\begin{array}{@{}rcl@{}} G_{B}(D)=\left(Z^{K-1}\times M | \cdots | Z \times M | M\right), \end{array} $$

(6)

where Z is the K×K matrix given as

$$\begin{array}{@{}rcl@{}} Z= \left[\begin{array}{cccc} 0 & & & \\ \vdots & & I_{K-1} & \\ 0 & & & \\ D & 0 & \cdots & 0 \end{array}\right] \end{array} $$

(7)

and M is the K×n matrix whose l-th column is $\overrightarrow {v_{K}}\left (g^{(l)}(D)\right)$.

Finally, the PGM G _P (D) of the (N,K) punctured convolutional code is obtained from G _B (D) by deleting the corresponding columns indicated in the puncturing pattern. Usually, the puncturing pattern is an n×K binary matrix. To a given puncturing pattern, we can associate a mapping ϕ:Z _N →Z _nK which maps the index i of a column of G _P (D) into the ϕ(i)-th column of G _B (D). From (6), we can see that the i-th column G _P (D) _i of G _P (D) is represented as

$$\begin{array}{@{}rcl@{}} G_{P}(D)_{i}=G_{B}(D)_{\phi(i)}=Z^{K-1-q}\overrightarrow{v_{K}}\left(g^{(r)}(D)\right), \end{array} $$

(8)

where ϕ(i)=q n+r, 0≤q≤K−1, 0≤r≤n−1. Now, let us take an example.

Example 1

Assume that the (4,3) punctured convolutional code is obtained from a (2,1) mother code by the puncturing pattern $P=\left [\begin {array}{ccc}1 & 0 & 1 \\ 0 & 1 & 1\end {array}\right ]$. Assume that the PGM G _M (D) of the mother code is given as

$$\begin{array}{@{}rcl@{}} &G_{M}(D) &=\left[g^{(0)}(D)\,\, g^{(1)}(D)\right]\\ &&=\left[1+D^{2}+D^{3}+D^{7}\,\, 1+D+D^{5}+D^{7}\right] \end{array} $$

Note that K = 3. To obtain G _B (D), we should have the mod −3 representation of g ⁽⁰⁾(D) and g ⁽¹⁾(D). Since $\kern0.3em {g}_0^{(0)}\kern0.3em \left({D}^3\right)=1+{D}^3$, ${Dg}_{1}^{(0)}\left (D^{3}\right)=D\left (D^{6}\right)$ and $D^{2}g_{2}^{(0)}\left (D^{3}\right)=D^{2}$, we have

$$\begin{array}{@{}rcl@{}} \overrightarrow{v_{3}}\left(g^{(0)}(D)\right)=\left(1\,\, D^{2}\,\, 1+D\right)^{T}. \end{array} $$

Similarly, we have

$$\begin{array}{@{}rcl@{}} \overrightarrow{v_{3}}\left(g^{(1)}(D)\right)=\left(D\,\, 1+D^{2}\,\, 1\right)^{T}. \end{array} $$

Therefore, G _B (D) of the three times blocked code is

$$\begin{array}{@{}rcl@{}} G_{B}(D)= \left[\begin{array}{cccccc} g_{0}^{(0)} & g_{0}^{(1)} & g_{1}^{(0)} & g_{1}^{(1)} & g_{2}^{(0)} & g_{2}^{(1)}\\ {Dg}_{2}^{(0)} & {Dg}_{2}^{(1)} & g_{0}^{(0)} & g_{0}^{(1)} & g_{1}^{(0)} & g_{1}^{(1)}\\ {Dg}_{1}^{(0)} & {Dg}_{1}^{(1)} & {Dg}_{2}^{(0)} & {Dg}_{2}^{(1)} & g_{0}^{(0)} & g_{0}^{(1)} \end{array}\right], \end{array} $$

and since ϕ(0)=0, ϕ(1)=3, ϕ(2)=4, and ϕ(3)=5, G _P (D) of the (4,3) punctured code is obtained from G _B (D) by deleting the second and the third columns as

$$\begin{array}{@{}rcl@{}} \begin{array}{ll} G_{P}(D)&= \left[\begin{array}{cccc} g_{0}^{(0)} & g_{1}^{(1)} & g_{2}^{(0)} & g_{2}^{(1)}\\ {Dg}_{2}^{(0)} & g_{0}^{(1)} & g_{1}^{(0)} & g_{1}^{(1)}\\ {Dg}_{1}^{(0)} & {Dg}_{2}^{(1)} & g_{0}^{(0)} & g_{0}^{(1)} \end{array}\right]\\ &= \left[\begin{array}{cccc} 1+D & 1+D^{2} & 1 & D\\ D & 1 & D^{2} & 1+D^{2}\\ D^{3} & D^{2} & 1+D & 1 \end{array}\right] \end{array} \end{array} $$

□

Note that $\overrightarrow {v_{K}}(Dg(D))$ can be expressed as

$$\begin{array}{@{}rcl@{}} \begin{array}{rl} \overrightarrow{v_{K}}(Dg(D))&=\left(g_{K-2}(D),\cdots,g_{0}(D),{Dg}_{K-1}(D)\right)^{T}\\ &=Z\overrightarrow{v_{K}}(g(D)) \end{array} \end{array} $$

where Z is K×K matrix shown in (7) satisfying Z ^K=D I _K . Extending this property, we can easily derive the following Lemma.

Lemma 1

$$ \begin{array}{c} \overrightarrow{v_{K}}(a(D)g(D))=a(Z)\overrightarrow{v_{K}}(g(D))\\ \text{for}\ \text{any}\ a(D)\in F_{2}[D]\left(mod\, Z^{K}+{DI}_{K}\right). \end{array} $$

(9)

3 Reconstruction algorithms for (n,1) mother code of (N,K) convolutional code

In this section, we first explain the settings of the reconstruction problem, describe the existing algorithm in [4] and our proposed algorithm, and then compare their complexity.

3.1 Description of the reconstruction problem

In [4], for the recognition of the puncturing pattern P and the PGM G _M (D) of the rate 1/n mother code of the punctured convolutional code of rate K/N, it is assumed that the the K×N G(D) of the punctured convolutional code are given from the existing reconstruction algorithms (for example, the one in [3]), so that the reconstruction is focused on recovering the puncturing pattern P and G _M (D) of the mother code of rate 1/n. As one can see in [5], equivalent codes to a given punctured code can be obtained from different P’s with different mother codes. So G _M (D) has to be searched for all possible P. The searching for G _M (D) is starting from the smallest n such that K/N exceeds 1/n. And then, for a selected puncturing pattern P, G _P (D) is constructed as in Example 1 and checked if it is equivalent to G(D). Once G _M (D) has been found, it is transformed into the canonical form. And finally, the puncturing pattern P and G _M (D) with the smallest degree is selected.

The major difference between the algorithm in [4] and our proposed algorithm is the method of checking the equivalence. Since the equivalence of G _P (D) to G(D) is defined as

$$ G_{P}(D)=T(D)G(D) $$

(10)

where T(D) is a K×K transition matrix, the existing algorithm tries to find out T(D) satisfying (10). On the other hand, our proposed algorithm checks if G _P (D) satisfies

$$\begin{array}{@{}rcl@{}} G_{P}(D)H(D)^{T}=[0], \end{array} $$

(11)

where H(D) is the dual of G(D) which is already on hand since most of the reconstruction algorithm (including the one in [3]) provides H(D) instead of G(D).

3.2 The existing algorithm

The existing algorithm tries to solve for T(D) satisfying (10). From (8), for i<j such that ϕ(i)≡ϕ(j) mod n, we have

$$\begin{array}{@{}rcl@{}} Z^{(\phi (j)-\phi (i))/n}G_{P}(D)_{j}=G_{P}(D)_{i}. \end{array} $$

(12)

Thus, in [4], using (10), the following set of equations are obtained.

$$\begin{array}{@{}rcl@{}} \forall i,j \,such \,that\, \phi (i) = \phi (j)\, mod\, n,\\ Z^{(\phi (j)-\phi (i))/n}T(D)G(D)_{j}=T(D)G(D)_{i}. \end{array} $$

(13)

They showed that for a properly selected puncturing pattern, they can have enough number of independent equations for obtaining K ² unknowns, and this linear system can be easily solved.

The process of calculating T(D) is out of the scope of this paper, so only the complexity of the existing algorithm will be dealt with in the Subsection 3.4. The following simple example explains how the mother code is obtained in [4].

Example 2

Find G _M (D) of rate 1/2 equivalent to the (4,3) convolutional code whose PGM and puncturing pattern are shown below.

$$\begin{array}{@{}rcl@{}} G(D)= \left[\begin{array}{cccc} D & 1+D & 1+D+D^{2} & 1\\ 1 & 1+D & 1+D+D^{2} & 0\\ 1 & 1 & D & 0 \end{array}\right], \,P= \left[\begin{array}{ccc} 1 & 0 & 1 \\ 0 & 1 & 1 \end{array}\right] \end{array} $$

From (12), we can write down 2 vector equations.

$$\begin{array}{@{}rcl@{}} T(D) \left[\begin{array}{c} D\\ 1\\ 1\end{array}\right] =Z^{2}T(D) \left[\begin{array}{c} 1+D+D^{2}\\ 1+D+D^{2}\\ D \end{array}\right],\\ T(D) \left[\begin{array}{c} 1+D\\ 1+D\\ 1 \end{array}\right] =ZT(D) \left[\begin{array}{c} 1\\ 0\\ 0 \end{array}\right], \end{array} $$

where $T(D)=\left [\begin {array}{ccc} t_{0,0}(D) & t_{0,1}(D) & t_{0,2}(D)\\ t_{1,0}(D) & t_{1,1}(D) & t_{1,2}(D)\\ t_{2,0}(D) & t_{2,1}(D) & t_{2,2}(D)\end {array}\right ]$. Since we have 6 linearly independent equations with 9 unknowns, we can freely set the value of 3 unknowns. For example, if we set

$$\begin{array}{@{}rcl@{}} T(D)= \left[\begin{array}{ccc} 0 & 0 & D^{2}\\ t_{1,0}(D) & t_{1,1}(D) & t_{1,2}(D)\\ t_{2,0}(D) & t_{2,1}(D) & t_{2,2}(D) \end{array}\right] \end{array} $$

and solve the system, we have

$$\begin{array}{@{}rcl@{}} T(D)= \left[\begin{array}{ccc} 0 & 0 & D^{2}\\ D^{2} & 1+D^{3} & 1+D^{4}\\ D+D^{2} & D & D^{2}+D^{3} \end{array}\right]. \end{array} $$

Thus, we have

$$\begin{array}{@{}rcl@{}} \begin{array}{rl} G_{P}(D)&=T(D)G(D)\\ &= \left[\begin{array}{cccc} D^{2} & D^{2} & D^{3} & 0\\ D^{4} & D+D^{2} & 1 & D^{2}\\ D & 0 & D^{2} & D+D^{2} \end{array}\right] \end{array} \end{array} $$

And finally, we have the mother code G _M (D) as

$$\begin{array}{@{}rcl@{}} G_{M}(D)= \left[1+D^{3}+D^{4}+D^{5}+D^{6}\ \ D^{2}\right] \end{array} $$

□

3.3 The proposed algorithm

Our proposed algorithm uses (11) instead of (10) to obtain G _P (D). Let H(D)=[h _(i,j)(D)] be (N−K)×N dual PGM, where h _(i,j)(D)∈F ₂[D]. Then, (11) can be expressed as

$$\begin{array}{@{}rcl@{}} \sum_{i=0}^{N-1}h_{j,i}(D)G_{P}(D)_{i}=0 \end{array} $$

(14)

for 0≤j≤N−K−1.

As shown in (8), we know that the column vectors G _P (D) _i ’s are of the form $Z^{u}\overrightarrow {v_{K}}\left (g^{(r)}(D)\right)$ for some u, 0≤u≤K−1, and r, 0≤r≤n−1. Thus, by substituting (8) into (14) and regrouping those columns G _P (D) _i such that ϕ(i)≡r (m o d n), (14) can be transformed into the following set of equations,

$$\begin{array}{@{}rcl@{}} \sum_{r=0}^{n-1}S_{r}^{(j)}(Z)\overrightarrow{v_{K}}\left(g^{(r)}(D)\right)=0, \end{array} $$

(15)

for 0≤j≤N−K−1. Note that $S_{r}^{(j)}(Z)$ is the polynomial of Z of degree less than K over F ₂[D]. In (15), if all the nonzero coefficient matrices $S_{r}^{(j)}(Z)$ are invertible and the number of independent equations among the (N−K) equations in (15) is less than n, then we can find all $\overrightarrow {v_{K}}\left (g^{(r)}(D)\right)$’s so in turn, the (n,1) mother code. Now, in the following example, let us show how the proposed algorithm applies to the same code in Example 2.

Example 3

Consider the same (4,3) convolutional code in Example 2. The dual matrix can be easily derived as

$$\begin{array}{@{}rcl@{}} H(D)=\left[1\ \ \ 1+D^{2} \ \ \ D \ \ \ 1+D\right] \end{array} $$

For the puncturing pattern $P= \left [\begin {array}{ccc} 1&0&1\\ 0&1&1 \end {array}\right ]$ and the rate 1/2 mother code g _M (D)=[g ⁽⁰⁾(D) g ⁽¹⁾(D)], G _P (D) can be written as

$$\begin{array}{@{}rcl@{}} G_{P}(D)= \left[ Z^{2}\underline{g}^{(0)}(D) \ \ \ Z\underline{g}^{(1)}(D) \ \ \ \underline{g}^{(0)}(D) \ \ \ \underline{g}^{(1)}(D) \right], \end{array} $$

where $\underline {g}^{(r)}(D)$ implies $\overrightarrow {v_{3}}\left (g^{(r)}(D)\right)$. The condition in (14) gives us

$$\begin{array}{@{}rcl@{}} S_{0}^{(0)}(Z)\underline{g}^{(0)}(D)=S_{1}^{(0)}(Z)\underline{g}^{(1)}(D), \end{array} $$

(16)

where $S_{0}^{(0)}(Z)=Z^{2}+DI$ and $S_{1}^{(0)}(Z)=\left (1+D^{2}\right)Z+(1+D)I$.

By setting g ⁽¹⁾(D)=1, we have g ⁽⁰⁾(D)=D ⁻²+D+D ²+D ³+D ⁴ from (16). By multiplying D ² to both g ⁽⁰⁾(D) and g ⁽¹⁾(D), we get the same G _M (D) as in Example 2. And finally, we have to check whether G _P (D) has rank 3 to ensure G _M (D) to be the true mother code. □

The remaining part is the proof of the invertibility of $S_{r}^{(j)}(Z)$’s. We will show that any nonzero $S_{r}^{(j)}(Z)$ is nonsingular by proving the set of all possible $S_{r}^{(j)}(Z)$’s form a field. The following lemma is well known from [6].

Lemma 2

Let F be any field. Then, F[x](m o d m(x)) is a field if m(x) is an irreducible polynomial.

Theorem 1

Let F ₂(D) be the quotient field of the polynomial ring F ₂[D]. Let Z be the K×K matrix given in (7). Then, F ₂(D)[Z](m o d Z ^K+D I _K ) is a field.

Proof

Due to Lemma 2, it is enough to show that Z ^K+D I _K is irreducible. Assume the contrary, then Z ^K+D I _K must have a factor Z ^l+c _l−1(D)Z ^l−1+⋯+c ₁(D)Z+c ₀(D)I for some l<K, which implies that the matrices I,Z,Z ²,…,Z ^l must be linearly dependent. But the first rows of the matrices I,Z,…,Z ^K−1 are [1 0 0 ⋯ 0], [0 1 0 ⋯ 0], [0 0 1 ⋯ 0], ⋯, [0 0 0 ⋯ 1] which means that they are all linearly independent. Therefore, F ₂(D)[Z](m o d Z ^K+D I _K is a field. □

3.4 Complexity comparison

In this section, we will compare the computational complexity of the previous algorithm and the proposed algorithm. For the comparison, we will set the unit operation to be a polynomial multiplication. In the previous algorithm, for a given puncturing pattern, we have to solve l, K(N−n)≤l≤K(N−1) independent equations, each having K ² unknowns. Finding the bases of the solution space with Gaussian elimination for a linear system in K ² unknowns will require O(K ⁶) polynomial operations, since the complexity of solving the linear system in K ² unknowns is the same as the complexity of finding inverse matrix of K ²×K ² matrix in big-O notation. In the proposed algorithm, the linear systems we have to solve is given in (15). We can solve (15) by simple Gauss elimination. It is not difficult to see that solving (15) requires at most n matrix inversions and n ²+2n matrix multiplications of $S_{r}^{(j)}(Z)$’s. Note that $S_{r}^{(j)}(Z)$’s are polynomials of Z given in (7). Due to the structural property of Z ^l, the inversions and multiplications of $S_{r}^{(j)}(Z)$ requires only the computations of their first rows. Thus, the computational complexity of these K×K matrices $S_{r}^{(j)}(Z)$’s is not O(K ³) but O(K ²). Therefore the overall complexity of the proposed algorithm is O(K ² n ²)≈O(K ⁴). The remaining issue of analysis is that is the validity of setting a polynomial operation as unit operation, since the complexity of the polynomial operation(meaning the multiplication of two polynomials) is dependent on the degrees of the polynomials. In [4], the polynomials of interest are the entries of G(D), whereas the polynomials of interest in the proposed algorithm are the entries of the first row of $S_{r}^{(j)}(Z)$, which are the polynomials in H(D). It is very difficult to estimate the degrees of the polynomials in H(D) from these in G(D). The maximal degree of the polynomials in H(D) can be either greater or less than that of the polynomials in G(D). Our complexity comparison is based on the assumption that both degrees are almost the same. In our example 2, both degrees are the same as 2. It can be easily shown that the maximal degree of the polynomials in H(D) is at most K times that of the polynomials in G(D). Even in this worst case, the computational complexity of our proposed algorithm is no more than O(K ⁶), the complexity of the algorithm in [4].

4 Conclusions

In this paper, we propose a new searching algorithm for reconstructing (n,1) mother code and its puncturing pattern. While the existing algorithm is based on the equivalence of G(D) and G _P (D), the proposed algorithm uses the dual relation between H(D) and G _P (D). We showed that the linear system derived from the dual relation G _P (D)^T H(D)=[0] can be easily solved by doing at most n matrix inversions and at most n ²+2n matrix multiplications of the K×K coefficient matrices $S_{r}^{(j)}(Z)$’s having a nice structural property, so that the computational complexity of the proposed algorithm is only O(K ⁴) compared to that of the existing algorithm O(K ⁶). An additional advantage of the proposed algorithm is that the mother code can be recognized without computing G(D) of the punctured convolutional code since most of the convolutional code recognition algorithm provides H(D) before deriving G(D).