- Research
- Open Access
- Published:

# An efficient algorithm for the reconstruction of punctured convolutional codes

*EURASIP Journal on Wireless Communications and Networking*
**volume 2017**, Article number: 86 (2017)

## 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*
^{4}) polynomial operations is proposed, compared to the existing searching algorithm by M. Cluzeau which requires *O*(*K*
^{6}) polynomial operations.

## 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.

## 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*
_{2}[*D*] and *D* represents the delay operator. The encoding process can be described by

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*
_{1}(*D*) and *G*
_{2}(*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*
_{1}(*D*) and *G*
_{2}(*D*) are equivalent if and only if there exist a *K*×*K* polynomial matrix *T*(*D*)with rank *K*, called transition matrix, over *F*
_{2}(*D*) such that

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

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*).

Now, assume that the PGM *G*
_{
M
}(*D*) of the (*n*,1) mother code is given as

Then, the PGM *G*
_{
B
}(*D*) of the *K*-times blocked code can be expressed as

where *Z* is the *K*×*K* matrix given as

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

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

Note that *K* = 3. To obtain *G*
_{
B
}(*D*), we should have the mod −3 representation of *g*
^{(0)}(*D*) and *g*
^{(1)}(*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

Similarly, we have

Therefore, *G*
_{
B
}(*D*) of the three times blocked code is

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

□

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

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**

## 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.

### 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

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

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*).

### 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

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

They showed that for a properly selected puncturing pattern, they can have enough number of independent equations for obtaining *K*
^{2} 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.

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

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

and solve the system, we have

Thus, we have

And finally, we have the mother code *G*
_{
M
}(*D*) as

□

### 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*
_{2}[*D*]. Then, (11) can be expressed as

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,

for 0≤*j*≤*N*−*K*−1. Note that \(S_{r}^{(j)}(Z)\) is the polynomial of *Z* of degree less than *K* over *F*
_{2}[*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

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*
^{(0)}(*D*) *g*
^{(1)}(*D*)], *G*
_{
P
}(*D*) can be written as

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

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*
^{(1)}(*D*)=1, we have *g*
^{(0)}(*D*)=*D*
^{−2}+*D*+*D*
^{2}+*D*
^{3}+*D*
^{4} from (16). By multiplying *D*
^{2} to both *g*
^{(0)}(*D*) and *g*
^{(1)}(*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*
_{2}(*D*) be the quotient field of the polynomial ring *F*
_{2}[*D*]. Let *Z* be the *K*×*K* matrix given in *(7)*. Then, *F*
_{2}(*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*
_{1}(*D*)*Z*+*c*
_{0}(*D*)*I* for some *l*<*K*, which implies that the matrices *I*,*Z*,*Z*
^{2},…,*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*
_{2}(*D*)[*Z*](*m*
*o*
*d*
*Z*
^{K}+*D*
*I*
_{
K
} is a field. □

### 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*
^{2} unknowns. Finding the bases of the solution space with Gaussian elimination for a linear system in *K*
^{2} unknowns will require *O*(*K*
^{6}) polynomial operations, since the complexity of solving the linear system in *K*
^{2} unknowns is the same as the complexity of finding inverse matrix of *K*
^{2}×*K*
^{2} 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*
^{2}+2*n* 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*
^{3}) but *O*(*K*
^{2}). Therefore the overall complexity of the proposed algorithm is *O*(*K*
^{2}
*n*
^{2})≈*O*(*K*
^{4}). 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*
^{6}), the complexity of the algorithm in [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*
^{2}+2*n* 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*
^{4}) compared to that of the existing algorithm *O*(*K*
^{6}). 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*).

## References

- 1
B Rice, in

*Proceedings of the 3rd International Conference on Finite Fields and Applications, Glasgow*. Determining the parameters of a rate 1/n convolutional encoder over gf(q) (Cambridge University PressUnited Kingdom, 1995). - 2
E Filiol, in

*Proceedings of the 6th IMA Conference on Cryptography and Coding, Vol. 1355, London*. Reconstruction of convolutional encoders over gf(q) (Springer VerlagBerlin Heidelberg, 1997), pp. 100–110. - 3
J Barbier, G Sicot, S Houcke, in

*Proceedings of the World Academy of Science, Engineering and Technology, Vol. 16, Venice*. Algebraic approach for the reconstruction of linear and convolutional error correcting codes (WASETFrance, 2006), pp. 66–71. - 4
M Cluzeau, M Finiasz, in

*Proceedings of the IEEE Information Theory Workshop, Taormina*. Reconstruction of punctured convolutional codes (IEEEUnited States, 2009), pp. 75–79. - 5
H Chung, H Jang, J Seong, in

*Proceedings of the 7th International Workshop on Signal Design and Its Applications in Communication, Bengaluru*. Sufficient conditions for an (n,1) mother code and its puncturing pattern to generate a given convolutional code (IEEE, 2015), pp. 95–98. - 6
G Karpilovsky,

*Topics in Field Theory*(Elsevier, North Hollnd, 1989).

## Acknowledgements

This work was supported by the National Research Foundation (NRF) of Korea grant funded by the Ministry of Education of Korea government (NRF-2014R1A1A2059324).

The authors also wish to thank the anonymous referee for the constructive and helpful comments on the revision of this article.

### Competing interests

The authors declare that they have no competing interests.

### Publisher’s Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

## Author information

## Rights and permissions

**Open Access** This article is distributed under the terms of the Creative Commons Attribution 4.0 International License(http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.

## About this article

### Cite this article

Chung, H., Jang, H. & Seong, J. An efficient algorithm for the reconstruction of punctured convolutional codes.
*J Wireless Com Network* **2017, **86 (2017). https://doi.org/10.1186/s13638-017-0869-4

Received:

Accepted:

Published:

### Keywords

- Punctured convolutional code
- Mother code
- Blocked convolutional code
- Polynomial generator matrix