Skew Convolutional Codes

Abstract

A new class of convolutional codes, called skew convolutional codes, that extends the class of classical fixed convolutional codes, is proposed. Skew convolutional codes can be represented as periodic time-varying convolutional codes but have a description as compact as fixed convolutional codes. Designs of generator and parity check matrices, encoders, and code trellises for skew convolutional codes and their duals are shown. For memoryless channels, one can apply Viterbi or BCJR decoding algorithms, or a dualized BCJR algorithm, to decode skew convolutional codes.

1. Introduction

Convolutional codes were introduced by Elias in 1955 [1]. With the discovery that convolutional codes can be decoded with Fano sequential decoding [2], Massey threshold decoding [3], and, above all, Viterbi decoding [4], they became quite widespread in practice. Convolutional codes are still widely used in telecommunications, e.g., in Turbo codes [5] and in the WiFi IEEE 802.11 standard [6], in cryptography [7], etc.

The most common are binary convolutional codes; however, communication with higher orders of modulation [8] or streaming of data [9] require non-binary convolutional codes. It is known that periodic time-varying convolutional codes improve the free distance and weight distribution over fixed convolutional codes; see, e.g., Mooser [10] and Lee [11]. This is the motivation to introduce a new class of periodic time-varying non-binary convolutional codes, i.e., skew convolutional codes. These codes are based on the non-commutative ring of skew polynomials over finite fields and on the skew field of their fractions.

Block codes based on skew polynomials were studied by various authors; see, e.g., publications of Gabidulin [12], Boucher and Ulmer [13,14], Martínez-Peñas [15], Gluesing-Luerssen [16], Abualrub, Ghrayeb, Aydin, and Siap [17].

Convolutional codes are nonblock linear codes over a finite field, but it can be advantageous to treat them as block codes over certain infinite fields. We will use both approaches. Classical convolutional codes are described by usual polynomials. The product of the polynomials corresponds to convolution of vectors of their coefficients and this gives fixed-in-time classical convolutional codes. We replace usual polynomials by skew polynomials to define the new codes. The product of skew polynomials corresponds to skew convolution of their coefficients, which can be obtained by varying elements in the usual convolution. In this way, we obtain time varying convolutional codes.

Our goal is to define and to give a first encounter with skew convolutional codes. In Section 2, we define skew convolutional codes. In Section 3, we obtain generator matrices and encoders for skew codes and show that skew codes are equivalent to time-varying convolutional codes. Some useful properties of skew codes are considered in Section 4. Section 5 introduces dual skew convolutional codes. Trellis decoding of skew codes is considered in Section 6. Section 7 concludes the paper.

2. Skew Convolutional Codes

2.1. Skew Polynomials and Fractions

Consider a field $\mathbb{F}$ and an automorphism $\theta$ of the field. Later on, we will use the finite field $\mathbb{F}={\mathbb{F}}_{q^m}$, where q is a prime power, with the Frobenius automorphism

$$\theta \left(a\right)=a^q,\forall a\in \mathbb{F}.$$

(1)

The composition of automorphisms is denoted as $\theta \left(\theta \left(a\right)\right)={\theta }^2\left(a\right)$, and, for any integer i, we have ${\theta }^i\left(a\right)=\theta \left({\theta }^{i-1}\left(a\right)\right)$. The identity automorphism $\theta \left(a\right)=a$ is denoted as $\theta =\mathrm{id}$. For the automorphism (1) for all $a\in \mathbb{F}$, we have ${\theta }^i\left(a\right)=a^{q^i}$ and ${\theta }^m=\mathrm{id}$ since $a^{q^m}=a$.

Denote by $\mathcal{R}=\mathbb{F}[D;\theta ]$ the non- commutative ring [18] of skew polynomials in the variable D over $\mathbb{F}$ (with zero derivation) such that

$$\mathcal{R}=\mathbb{F}[D;\theta ]=\{a\left(D\right)=a_0+a_{1}D+\cdots +a_n{D}^n|a_i\in \mathbb{F}\mathrm{and}n\in \mathbb{N}\}.$$

The skew polynomials look like usual polynomials $\mathbb{F}\left[D\right]$ where the coefficients $a_i$ are placed to the right of the variable D. The addition in $\mathcal{R}$ is as for usual polynomials from $\mathbb{F}\left[D\right]$. The multiplication is defined by the basic rule

$$Da=\theta \left(a\right)D$$

(2)

and is extended to all elements of $\mathcal{R}$ by associativity and distributivity; see Example 1 below. The ring $\mathcal{R}$ has a unique left skew field of fractions $\mathcal{Q}$, from which it inherits its linear algebra properties, see, e.g., [19] for more details.

Example 1.

To demonstrate our results, we use the field ${\mathbb{F}}_Q={\mathbb{F}}_{q^m}={\mathbb{F}}_{2^2}$, $q=2$, $m=2$, with automorphism $\theta \left(a\right)=a^q=a^2$ for all $a\in {\mathbb{F}}_{2^2}$. The field ${\mathbb{F}}_{2^2}$ consists of the elements $\{0,1,\alpha ,{\alpha }^2\}$, where a primitive element α satisfies ${\alpha }^2+\alpha +1=0$ and the following relations hold:

$$\begin{gathered} {\alpha }^2=\alpha +1 \\ {\alpha }^3=1, \\ {\alpha }^4=\alpha \end{gathered}$$,

$and \forall i\in \mathbb{Z}{\theta }^i=\left\{\begin{array}{cc}\theta & ifiis odd,\\ id& ifiis even.\end{array}\right.$,

Let $a\left(D\right)=1+\alpha D$ and $b\left(D\right)={\alpha }^2+D$, $a\left(D\right),b\left(D\right)\in \mathcal{R}$. Using (2), we compute the product $ab$ as

$$a\left(D\right)b\left(D\right)=(1+\alpha D)({\alpha }^2+D)=({\alpha }^2+D)+\alpha \theta \left({\alpha }^2\right)D+\alpha D^2={\alpha }^2+\alpha D+\alpha D^2$$

while the product $ba$ is

$$b\left(D\right)a\left(D\right)=({\alpha }^2+D)(1+\alpha D)=({\alpha }^2+D)+{\alpha }^{3}D+\theta \left(\alpha \right)D^2={\alpha }^2+{\alpha }^2{D}^2.$$

In this example, we see that $a\left(D\right)b\left(D\right)\ne b\left(D\right)a\left(D\right)$.

The left skew field $\mathcal{Q}$ consists of fractions $\frac{b\left(D\right)}{a\left(D\right)}=a^{-1}\left(D\right)b\left(D\right)\in \mathcal{Q}$ for all $a\left(D\right),b\left(D\right)\in \mathcal{R}$, $a\left(D\right)\ne 0$. Every fraction can be expanded as the left skew Laurent series in increasing powers of D. In our example, the inverse element $\frac{1}{a\left(D\right)}=a{\left(D\right)}^{-1}$ is expanded using long devision as follows:

$$a^{-1}\left(D\right)=1+\alpha D+D^2+\alpha D^3+D^4+\dots$$

with $a^{-1}\left(D\right)a\left(D\right)=a\left(D\right)a^{-1}\left(D\right)=1$. We can expand the left fraction $\frac{b\left(D\right)}{a\left(D\right)}=a^{-1}\left(D\right)b\left(D\right)$ by long left division or equivalently by left multiplication $b\left(D\right)$ by $a^{-1}\left(D\right)$ and get

$$\frac{b\left(D\right)}{a\left(D\right)}=a^{-1}\left(D\right)b\left(D\right)={\alpha }^2+\alpha D+D^2+\alpha D^3+D^4+\dots .$$

Notice that the right fraction $b\left(D\right)a^{-1}\left(D\right)={\alpha }^2$, since $b\left(D\right)={\alpha }^2+D={\alpha }^2(1+\alpha D)={\alpha }^{2}a\left(D\right)$.

2.2. Definition of Skew Convolutional Codes

Much of linear algebra can be generalized from vector spaces over a field to (either left or right) modules over the skew field $\mathcal{Q}$. Indeed, it is shown in [19] that any left $\mathcal{Q}$-module $\mathcal{C}$ is free, i.e., it has a basis, and any two bases of $\mathcal{C}$ have the same cardinality, the dimension of $\mathcal{C}$.

Definition 1

(Skew convolutional code). Given an automorphism θ of the field $\mathbb{F}$, a skew convolutional $[n,k]$ code $\mathcal{C}$ over the field $\mathbb{F}$ is a left sub-module of dimension k of the free module ${\mathcal{Q}}^n$.

The elements of the code $\mathcal{C}$ are called its codewords. A codeword $v\left(D\right)=\left(v^{\left(1\right)}\left(D\right),\dots ,v^{\left(n\right)}\left(D\right)\right)$ is an n-tuple over $\mathcal{Q}$, where every component $v^{\left(i\right)}\left(D\right)$ is a fraction of skew polynomials from $\mathcal{R}$. The code $\mathcal{C}$ is $\mathbb{F}={\mathbb{F}}_{q^m}$-linear. Let the weight of every codeword be defined by some selected metric. The free distance $d_f$ of a skew convolutional code is defined to be the minimum nonzero weight of any codeword.

For the Hamming metric, which is the most interesting for applications, the weight of a fraction $v^{\left(i\right)}\left(D\right)$ is the number of nonzero coefficients in its expansion as a left skew Laurent series from $\mathbb{F}\left(\right(D\left)\right)$ in increasing powers of D. The weight of a codeword is the sum of weights of its components. Another interesting metric is sum-rank metric, which will be defined later.

2.3. Relations to Fixed Convolutional Codes

Lemma 1.

The class of skew convolutional codes includes the class of fixed (time-invariant) convolutional codes.

Proof. 

A time-invariant convolutional $[n,k]$ code $\tilde{\mathcal{C}}$ over the field $\mathbb{F}$ is defined as a k-dimensional subspace of $\mathbb{F}{\left(D\right)}^n$. Take the identity automorphism $\theta =\mathrm{id}$. Then, the ring $\mathcal{R}=\mathbb{F}[D;\theta ]$ becomes a ring $\mathbb{F}\left[D\right]$ of usual commutative polynomials. The skew field of fractions $\mathcal{Q}$ becomes the field of rational functions $\mathbb{F}\left(D\right)$. In this case, by Definition 1, the skew convolutional code $\mathcal{C}$ coincides with the classical fixed code $\tilde{\mathcal{C}}$. □

3. Encoding Skew Convolutional Codes

3.1. Polynomial Form of Encoding

A generator matrix of a skew convolutional $[n,k]$ code $\mathcal{C}$ is a $k\times n$ matrix $G\left(D\right)$ over the skew field $\mathcal{Q}$ whose rows form a basis for the code $\mathcal{C}$. If the matrix $G\left(D\right)$ is over the ring $\mathcal{R}$ of skew polynomials, then $G\left(D\right)$ is called a polynomial generator matrix for $\mathcal{C}$. Every skew code $\mathcal{C}$ has a polynomial generator matrix. Indeed, given a generator matrix $G\left(D\right)$ over the skew field of fractions $\mathcal{Q}$, a polynomial generator matrix can be obtained by left multiplying each row of $G\left(D\right)$ by the least common left multiple of the denominators in that row. In the paper, we focus on polynomial generator matrices and corresponding encoders.

By Definition 1, every codeword $v\left(D\right)$ of a skew code $\mathcal{C}$, which is an n-tuple over the skew field of fractions $\mathcal{Q}$

$$v\left(D\right)=\left(v^{\left(1\right)}\left(D\right),v^{\left(2\right)}\left(D\right),\dots ,v^{\left(n\right)}\left(D\right)\right),v^{\left(j\right)}\left(D\right)\in \mathcal{Q},1\le j\le n$$

(3)

can be written as

$$v\left(D\right)=u\left(D\right)G\left(D\right)$$

(4)

where $u\left(D\right)$ is a k-tuple (k-word) over $\mathcal{Q}$:

$$u\left(D\right)=\left(u^{\left(1\right)}\left(D\right),u^{\left(2\right)}\left(D\right)\dots ,u^{\left(k\right)}\left(D\right)\right),u^{\left(i\right)}\left(D\right)\in \mathcal{Q},1\le i\le k$$

(5)

and is called an information word, $G\left(D\right)$ is a generator matrix of $\mathcal{C}$, $G\left(D\right)\in {\mathcal{Q}}^{k\times n}$ or $G\left(D\right)\in {\mathcal{R}}^{k\times n}$. Relation (4) already provides an encoder. This encoder (4) is just an encoder of a block code over $\mathcal{Q}$ and the skew code $\mathcal{C}$ can be considered as the set of n-tuples $v\left(D\right)$ over $\mathcal{Q}$ that satisfy (4), i.e., $\mathcal{C}=\left\{v\right(D\left)\right\}$.

However, to use the code in practice we need to write components of $u\left(D\right)$ and $v\left(D\right)$ as skew Laurent series, i.e., we have

$$u^{\left(i\right)}\left(D\right)=u_0^{\left(i\right)}+u_1^{\left(i\right)}D+u_2^{\left(i\right)}{D}^2+\dots ,i=1,\dots ,k$$

(6)

and

$$v^{\left(j\right)}\left(D\right)=v_0^{\left(j\right)}+v_1^{\left(j\right)}D+u_2^{\left(j\right)}{D}^2+\dots ,j=1,\dots ,n.$$

(7)

Actually, in a Laurent series, the lower (time) index of coefficients can be a negative integer, but, in practice, the information sequence $u^{\left(i\right)}\left(D\right)$ should be causal for every component i, that is, the coefficients $u_t^{\left(i\right)}$ are zeros for time $t<0$. Causal information sequences should be encoded into causal code sequences; otherwise, an encoder can not be implemented, since it should output code symbols before it receives an information symbol.

Denote the block of information symbols that enters an encoder at time $t=0,1,\dots$ by

$$u_t=\left(u_t^{\left(1\right)},u_t^{\left(2\right)},\dots u_t^{\left(k\right)}\right)\in {\mathbb{F}}^k.$$

(8)

The block of code symbols that leaves the encoder at time $t=0,1,\dots$ is denoted by

$$v_t=\left(v_t^{\left(1\right)},v_t^{\left(2\right)},\dots v_t^{\left(n\right)}\right)\in {\mathbb{F}}^n.$$

(9)

Combining (5), (6), and (8), we obtain the following information series with vector coefficients:

$$u\left(D\right)=u_0+u_{1}D+\dots +u_t{D}^t+\dots ,u\left(D\right)\in \mathbb{F}{\left(\left(D\right)\right)}^k.$$

(10)

Using (3), (7), and (9), we write a codeword as a series

$$v\left(D\right)=v_0+v_{1}D+\dots +v_t{D}^t+\dots ,v\left(D\right)\in \mathbb{F}{\left(\left(D\right)\right)}^n.$$

(11)

One can write a skew polynomial generator matrix $G\left(D\right)=\left(g_{ij}\left(D\right)\right)\in {\mathcal{R}}^{k\times n}$ as a skew polynomial with matrix coefficients:

$$G\left(D\right)=G_0+G_{1}D+G_2{D}^2+\dots +G_{\mu }{D}^{\mu }$$

(12)

where $\mu$ is the maximum degree of polynomials $g_{ij}\left(D\right)$. The matrices $G_i$ are $k\times n$ matrices over the field $\mathbb{F}$ and $\mu$ is called the generator matrix memory.

From (4), (10), and (11), we obtain that $v_t$ is a coefficient in the product of skew series $u\left(D\right)$ and skew polynomial $G\left(D\right)$, which is the following skew convolution (see Figure 1)

$$v_t=u_t{\theta }^t\left(G_0\right)+u_{t-1}{\theta }^{t-1}\left(G_1\right)+\cdots +u_{t-\mu }{\theta }^{t-\mu }\left(G_{\mu }\right)$$

(13)

where $u_t=0$ for $t<0$. This encoding rule explains the title skew convolutional code, which can be also seen as the set $\mathcal{C}=\left\{v\right(D\left)\right\}$ of series $v\left(D\right)$ defined in (11).

At time t, the decoder observes an information block $u_t$ of k symbols from $\mathbb{F}$ and outputs the code block $v_t$ of n code symbols from $\mathbb{F}$ using (13); hence, the code rate is $R=k/n$. The encoder (13) uses $u_t$ and also $\mu$ previous information blocks $u_{t-1},u_{t-2},\dots ,u_{t-\mu }$, which should be stored in the encoder’s memory; this is why $\mu$ is also the encoder memory.

The coefficients ${\theta }^{t-i}\left(G_i\right)$, $i=0,1,\dots ,\mu$ in the encoder (13) depend on the time t. Hence, the skew convolutional code is a time-varying classical convolutional code. Denote

$$\tau =min\left\{i>0:{\theta }^i\left(G_j\right)=G_j\forall j=0,1,\dots ,\mu \right\}.$$

(14)

For the field $\mathbb{F}={\mathbb{F}}_{q^m}$, we have ${\theta }^m={\theta }^0$; hence, the coefficients in (13) are periodic with period $\tau \le m$, and the skew convolutional code is periodic with period $\tau \le m$. The period $\tau$ can be less than m if all the matrices $G_0,\dots G_{\mu }$ are over a subfield of ${\mathbb{F}}_{q^m}$.

3.2. Scalar Form of Encoding

The input of the encoder can also be written as an information sequence of k-blocks over $\mathbb{F}$

$$u=u_0,u_1,u_2,\dots ,u_t,\dots$$

(15)

and the output as a code sequence of n-blocks over $\mathbb{F}$

$$v=v_0,v_1,v_2,\dots ,v_t,\dots .$$

(16)

Then, the encoding rule (13) can be written in a scalar form

$$v=uG$$

(17)

with semi-infinite scalar generator block matrix

$$G=\left(\begin{array}{ccccccc}{G}_0& G_1& G_2& \cdots & G_{\mu }& & \\ & \theta \left(G_0\right)& \theta \left(G_1\right)& \dots & \theta \left(G_{\mu -1}\right)& \theta \left(G_{\mu }\right)& \\ & & {\theta }^2\left(G_0\right)& \dots & {\theta }^2\left(G_{\mu -2}\right)& {\theta }^2\left(G_{\mu -1}\right)& {\theta }^2\left(G_{\mu }\right)\\ & & & \dots \end{array}\right).$$

(18)

Thus, a skew convolutional code can be equivalently represented in a scalar form as the set $\mathcal{C}=\left\{v\right\}$ of sequences v defined in (16) that satisfy (17).

3.3. Relations between Skew and Classical Convolutional Codes

In case of identity automorphism, $\theta \left(a\right)=a$, the scalar generator matrix of the skew code becomes

$$G^{\prime }=\left(\begin{array}{ccccccc}{G}_0& G_1& G_2& \dots & G_{\mu }& & \\ & G_0& G_1& \dots & G_{\mu -1}& G_{\mu }& \\ & & G_0& \dots & G_{\mu -2}& G_{\mu -1}& G_{\mu }\\ & & & \dots \end{array}\right),$$

(19)

which is a generator matrix of a fixed convolutional code [20]. For fixed convolutional codes, polynomial generator matrices with $G_0$ of full rank k are of particular interest [20] (Chapter 3). The skew convolutional codes use the following nice property: if $G_0$ has full rank, then ${\theta }^i\left(G_0\right)$ has full rank as well for all i.

Time-varying classical convolutional codes are defined by the following generator matrices in [20],

$$G_{var}=\left(\begin{array}{cccccc}{G}_{0,0}\hfill & G_{1,1}\hfill & \hfill & G_{\mu ,\mu }\hfill & \hfill & \\ \hfill & G_{1,0}\hfill & ⋮\hfill & G_{\mu ,\mu -1}\hfill & G_{\mu +1,\mu }\hfill \\ \hfill & & \hfill & ⋮\hfill & G_{\mu +1,\mu -1}\hfill & ⋮\hfill \\ \hfill & \hfill & & G_{\mu ,0}\hfill & ⋮\hfill \\ \hfill & \hfill & & \hfill & G_{\mu +1,0}\hfill \end{array}\right)$$

(20)

where the first index t in $G_{t,i}$ is time index. The code defined by the generator matrix $G_{var}$ in (20) is called τ-periodic if the columns ${(G_{t,\mu }^T,\dots ,G_{t,0}^T)}^T$, $t\ge \mu$, repeat with period $\tau$.

Lemma 2.

A scalar generator matrix (18) of a skew code can be written in the following equivalent form:

$$G=\left(\begin{array}{cccccc}{\tilde{G}}_0\hfill & \theta \left({\tilde{G}}_1\right)\hfill & \hfill & {\theta }^{\mu }\left({\tilde{G}}_{\mu }\right)\hfill & \hfill & \\ \hfill & \theta \left({\tilde{G}}_0\right)\hfill & ⋮\hfill & {\theta }^{\mu }\left({\tilde{G}}_{\mu -1}\right)\hfill & {\theta }^{\mu +1}\left({\tilde{G}}_{\mu }\right)\hfill & \\ \hfill & & \hfill & ⋮\hfill & {\theta }^{\mu +1}\left({\tilde{G}}_{\mu -1}\right)\hfill & ⋮\hfill \\ \hfill & \hfill & & {\theta }^{\mu }\left({\tilde{G}}_0\right)\hfill & ⋮\hfill \\ \hfill & \hfill & & \hfill & {\theta }^{\mu +1}\left({\tilde{G}}_0\right)\hfill \end{array}\right).$$

(21)

Proof. 

The statement follows from the change of variables $G_i={\theta }^i\left({\tilde{G}}_i\right)$ for $i=1,2,\dots ,\mu$. □

From (14), (20) and (21), we see again that a skew code defined by a generator matrix (21) is a $\tau$-periodic classical convolutional code. Thus, above we proved the following theorem.

Theorem 1.

Given a field $\mathbb{F}={\mathbb{F}}_{q^m}$ with automorphism θ in (1), any skew convolutional $[n,k]$ code $\mathcal{C}$ over $\mathbb{F}$ is equivalent to a periodic time-varying (classical) convolutional $[n,k]$ code over $\mathbb{F}$, with period $\tau \le m$ (14). If $G\left(D\right)$ is a skew polynomial generator matrix (12) of the code $\mathcal{C}$, then the scalar generator matrix G of the time-varying code is given by (18) or (21).

Not every periodic classical convolutional code can be represented as a skew code. Indeed, e.g., the submatrix $G_{1,0}$ in (20) can be selected independently of $G_{0,0}$ while corresponding submatrix $\theta \left({\tilde{G}}_0\right)$ in (21) is completely determined by ${\tilde{G}}_0$. Hence, a class of skew convolutional codes is a subclass of periodic classical convolutional codes.

Given the field ${\mathbb{F}}_{q^m}$, the automorphism $\theta$ in (1), and the code memory $\mu$, an $[n,k]$ skew convolutional code is defined by a generator matrix G in (21). To specify the matrix, we should fix elements of $\mu +1$ matrices ${\tilde{G}}_0,\dots ,{\tilde{G}}_{\mu }$ of size $k\times n$. Hence, we should define $(\mu +1)kn$ field elements. Since a classical convolutional code corresponds to the identity automorphism $\theta =\mathrm{id}$, the description of skew and classical codes require the same number of field elements.

The number of skew $[n,k]$ convolutional codes over ${\mathbb{F}}_Q={\mathbb{F}}_{q^m}$ of memory $\mu$ with fixed automorphism $\theta \left(a\right)=a^q$ has order $q^{(\mu +1)mkn}$. The number of $\tau$-periodic classical convolutional codes has order $q^{(\mu +1)mkn\tau }$, which is much larger. As a result, the search of good periodic time-varying convolutional codes is much simpler in the class of skew codes in comparison with periodic classical codes. The search among skew convolutional codes has the same complexity as the search among fixed classical codes.

How many more skew codes can we obtain by considering all possible automorphisms? Denote $q=p^s$, where p is the field characteristic then ${\mathbb{F}}_{q^m}={\mathbb{F}}_{p^{sm}}={\mathbb{F}}_{p^M}$, i.e., our field ${\mathbb{F}}_Q$ is an M-extension of the prime field ${\mathbb{F}}_p$. The parameter $q=p^s$, we should select such that ${\mathbb{F}}_q$ is a subfield of ${\mathbb{F}}_{p^M}$, hence s should divide M. Denote by $\delta \left(M\right)$ the number-of-divisors function that is the number of divisors i of M, $1\le i\le M$. Given the field ${\mathbb{F}}_Q={\mathbb{F}}_{p^M}$, we can select $q=p^i$ and the automorphism $\theta \left(a\right)=a^q$ in $\delta \left(M\right)$ ways.

Lemma 3.

For a fixed field ${\mathbb{F}}_Q={\mathbb{F}}_{p^M}$, there are $\delta \left(M\right)$ sub-classes of skew convolutional codes, each defined by a fixed automorphism θ.

In Example 2, we have ${\mathbb{F}}_Q={\mathbb{F}}_{2^2}$, i.e., $p=q=2,s=1,m=2$. $M=sm=2$ with divisors 1 and 2. For $i=1$, we have $q=p^i=2$ and $\theta \left(a\right)=a^2$ considered in Example 2. For $i=2$, we have $q=p^2=4$ that corresponds to $\theta =\mathrm{id}$ and gives a constant classical convolutional code. For the field ${\mathbb{F}}_2^6$, we have $\delta \left(6\right)=4$, and there are four sub-classes of skew codes with $q=2^1,2^2,2^3$, and $q=2^6$ (for fixed code).

4. Properties of Skew Convolutional Codes

4.1. Extension of Fixed Convolutional Codes

To show properties of skew convolutional codes, we will use the following example.

Example 2.

Consider a [2,1] skew convolutional code $\widehat{\mathcal{C}}$ over the field ${\mathbb{F}}_Q={\mathbb{F}}_{q^m}={\mathbb{F}}_{2^2}$ with automorphism $\theta \left(a\right)=a^q=a^2$ (see Example 1). Let the generator matrix of the code $\widehat{\mathcal{C}}$ in polynomial form be

$$G\left(D\right)=(1+\alpha D,\alpha +{\alpha }^{2}D)=G_0+G_{1}D,$$

(22)

where

$$G_0=(1,\alpha ),G_1=(\alpha ,{\alpha }^2).$$

(23)

The generator matrix in scalar form (18) is

$$G=\left(\begin{array}{cc}1\alpha & \alpha {\alpha }^2\\ & 1{\alpha }^2& {\alpha }^2\alpha \\ & & 1\alpha & \alpha {\alpha }^2\\ & & & 1{\alpha }^2& {\alpha }^2\alpha \\ & & \dots \end{array}\right).$$

(24)

Here, $\mu =1$; hence, it is a unit memory code. The encoding rule is $v=uG$, or, from (13), it is

$$v_t=u_t{\theta }^t\left(G_0\right)+u_{t-1}{\theta }^{t-1}\left(G_1\right),t=0,1,\dots .$$

(25)

In some applications, it is preferable to have a generator matrix in systematic form. For our example, a systematic fractional matrix can be obtained using the left division of its components by the first component

$$G_{syst}\left(D\right)=\left(1,\frac{\alpha +{\alpha }^{2}D}{1+\alpha D}\right)=\left(1,{(1+\alpha D)}^{-1}(\alpha +{\alpha }^{2}D)\right).$$

(26)

Let us show that the matrices $G_{syst}\left(D\right)$ and $G\left(D\right)$ in (22) encode the same code $\widehat{\mathcal{C}}$. Denote $g_1\left(D\right)=1+\alpha D$. Then, for any information sequence $u\left(D\right)\in \mathcal{Q}$, we have the code word

$$u\left(D\right)G\left(D\right)=u\left(D\right)g_1\left(D\right)g_1^{-1}\left(D\right)G\left(D\right)=u\left(D\right)g_1\left(D\right)G_{syst}\left(D\right)=u^{\prime }\left(D\right)G_{syst}\left(D\right)$$

and the statement follows since there is a one to one mapping between $u\left(D\right)$ and $u^{\prime }\left(D\right)=u\left(D\right)g_1\left(D\right)$; hence, both information sequences $u\left(D\right)$ and $u^{\prime }\left(D\right)$ run over all possible causal sequences.

Theorem 2.

The class of skew convolutional codes extends the class of fixed convolutional codes.

Proof. 

By Lemma 1, the class of fixed codes is included in the class of skew convolutional codes. Hence, it is sufficient to show that there exists a codeword in a skew convolutional $[n,k]$ code that can not belong to any fixed $[n,k]$ code with the same memory. Indeed, consider the unit memory, $\mu =1$, skew $[2,1]$ code $\widehat{\mathcal{C}}$ defined by the generator matrix (24). By encoding the information sequence $u=1,0,0,1$, we obtain the codeword $v=v_0,v_1,v_2,v_3,v_4=(1,\alpha ),(\alpha ,{\alpha }^2),(0,0),(1,{\alpha }^2),({\alpha }^2,\alpha )\in \widehat{\mathcal{C}}$.

Suppose for the sake of contradiction that the codeword v belongs to a fixed unit memory $[2,1]$ convolutional code ${\mathcal{C}}^{\prime }$. A general form of generator matrix of a unit memory fixed $[2,1]$ code ${\mathcal{C}}^{\prime }$ is (19):

$$G^{\prime }=\left(\begin{array}{cc}ab& cd\\ & ab& cd\\ & & ab& cd\\ & & & ab& cd\\ & & \dots \end{array}\right)$$

where $a,b,c,d,\in {\mathbb{F}}_{2^2}$. Assume that the word $v=(e,f,g,h,\dots )G^{\prime }\in {\mathcal{C}}^{\prime }$ where $e,f,g,h\in {\mathbb{F}}_{2^2}$. From $v_2=f(c,d)+g(a,b)=(0,0)$, it follows that either i) $f=g=0$, or ii) vectors $(c,d)$ and $(a,b)$ are ${\mathbb{F}}_{2^2}$-linearly dependent. In case i), $v_0=e(a,b)=(1,\alpha )$ and $v_3=h(a,b)=(1,{\alpha }^2)$, $e^{-1}(1,\alpha )=h^{-1}(1,{\alpha }^2)$, which is impossible since the vectors $(1,\alpha )$ and $(1,{\alpha }^2)$ are linearly independent. In case ii), linear combinations of linearly dependent vectors $(c,d)$ and $(a,b)$ should give two linearly independent vectors $v_0=(1,\alpha )$ and $v_3=(1,{\alpha }^2)$, which is impossible as well. □

4.2. Canonical Encoders and Generator Matrices

The encoder in a controller canonical form [20] for the code $\widehat{\mathcal{C}}$ in Example 2 with generator matrix (22) is shown in Figure 2a for even t and in Figure 2b for odd t. The encoder has one shift register, since $k=1$. There is one Q-ary memory element in the shift register shown as a rectangle, where $Q=q^m=4$ is the order of the field. We need only one memory element since a maximum degree of items in $G\left(D\right)$, which consists of a single row in our example, is 1. A large circle means multiplication by the coefficient shown inside.

In the general case of a $k\times n$ matrix $G\left(D\right)$, we define the degree ${\nu }_i$ of its ith row as the maximum degree of its components, and external degree $\nu$ of $G\left(D\right)$ is the sum of its row degrees [21]. The controller-canonical-form encoder of $G\left(D\right)$ over ${\mathbb{F}}_Q$ has k shift registers, the ith register has ${\nu }_i$ memory elements, and the total number of Q-ary memory elements in the encoder is $\nu$. Different generator matrices for a code $\mathcal{C}$ may have different external degrees.

Definition 2.

Among all skew polynomial generator matrices (PGM) for a given skew convolutional code $\mathcal{C}$, those for which the external degree is as small as possible are called canonical PGMs. This minimal external degree is called the degree or overall constraint length of the code $\mathcal{C}$, and denoted as $\nu =deg\mathcal{C}$.

4.3. Code Trellises

For the code $\widehat{\mathcal{C}}$ in Example 2, the code trellis is shown in Figure 3. The trellis consists of sections periodically repeated with period $\tau =m=2$. Every section has $Q^{\nu }=4^1=4$ states labeled by elements of the field ${\mathbb{F}}_Q$. For the t-th section for time $t,t=0,1,\dots$, an edge connects the states $u_{t-1}$ and $u_t$ and is labeled by the code block $v_t$. Every codeword is represented by a path in the trellis that starts from the zero state 0 and goes to the right. The edge label $v_t$ is computed according to the encoding rule (25) as follows:

$$v_t=\left\{\begin{array}{cc}{u}_{t-1}(\alpha ,{\alpha }^2)+u_t(1,{\alpha }^2)\hfill & \mathrm{for} \mathrm{odd} t,\hfill \\ u_{t-1}({\alpha }^2,\alpha )+u_t(1,\alpha )\hfill & \mathrm{for} \mathrm{even} t\hfill \end{array}\right.$$

(27)

where we assume that $u_{-1}=0$, i.e., the initial state of the shift register is 0.

4.4. Code Distances

There are two important characteristics of a convolutional code: the free distance $d_f$ and the slope $\sigma$ of the increase of the active burst distance, defined as follows [20]. The weight of a branch labeled by a vector $v_t$ is defined to be the weight $w\left(v_t\right)$ of $v_t$. The weight of a path is the sum of its branch weights. A path in the trellis that diverges from zero state, which does not use edges of weight 0 from zero state to zero state, and that returns to zero state after ℓ edges is called a loop of length ℓ or ℓ-loop.

The ℓth order active burst distance $d_{\ell }^{\mathrm{burst}}$ is defined [20] to be the minimum weight of ℓ-loops in the code trellis. The slope is defined as $\sigma ={lim}_{\ell \to \infty }{d}_{\ell }^{\mathrm{burst}}/\ell$. The free distance is $d_f={min}_{\ell }{d}_{\ell }^{\mathrm{burst}}$.

Theorem 3

(Singleton bound). The free Hamming distance of $[n,k]$ skew convolutional code $\mathcal{C}$ of degree $\nu =deg\mathcal{C}$ is upper bounded as follows:

$$d_f\le (n-k)⌊\frac{\nu }{k}+1⌋+\nu +1.$$

(28)

Proof. 

We adopted the proof given in [22] for time-invariant finite state codes. The trellis of the code $\mathcal{C}$ is time-varying with $Q^{\nu }$ states at every level. Consider $Q^{\ell k}$ information sequences $u_0,\dots ,u_{\ell -1}$ of length ℓ blocks. For each of them, the code path in the trellis starts at the state 0 and terminates in one of $Q^{\nu }$ states. From the pigeon-hole principle, it follows that there must be at least $Q^{\ell k-\nu }=Q^K$ of these paths that have the same final state. The code sequences corresponding to these paths can be thought of as a block code with length $N=\ell n$ with at least $Q^K$ codewords. We should select ℓ such that $K=\ell k-\nu >0$. The Hamming distance d of the block code is upper bounded by the Singleton bound $d\le N-K+1=\ell (n-k)+\nu +1$. On the other hand, d is an upper bound on the free Hamming distance $d_f$ of the code $\mathcal{C}$. Since this is true for all $\ell >\nu /k$, we have

$$d_f\le \underset{\ell :\ell >\nu /k}{min}\ell (n-k)+\nu +1$$

that gives the upper bound (28). □

To obtain (28), we use the Singleton bound for block codes; therefore, the bound (28) is Singleton-type bound for skew convolutional codes. In fact, this bound and the proof are valid for arbitrary (also for nonlinear) time-varying trellis codes. In [23], codes that reach the Singleton-type bound are called maximum distance separable (MDS) codes. Any other upper bound for the Hamming distance of block codes can be used to obtain another upper bound for $d_f$ of skew convolutional codes (also for time-varying trellis codes). Using the Plotkin bound for block codes, we obtain the following bound.

Corollary 1

(Heller bound). The free Hamming distance of $[n,k]$ skew convolutional code $\mathcal{C}$ over ${\mathbb{F}}_Q$ of degree $\nu =deg\mathcal{C}$ and memory μ is upper bounded as follows:

$$d_f\le \underset{i\in \widehat{\mathbb{N}}}{min}⌊\frac{n(\mu +i)Q^{k(\mu +i)-\nu -1}(Q-1)}{Q^{k(\mu +i)-\nu }-1}⌋,$$

(29)

where $\widehat{\mathbb{N}}=\{1,2,\dots \}$ if $k\mu =\nu$ and $\widehat{\mathbb{N}}=\{0,1,\dots \}$, otherwise.

The bound is named Heller since it was obtained for fixed binary convolutional codes in 1968, see [20,24]. The bound (29) is valid for for time-varying (nonlinear or linear) trellis codes.

In the Hamming metric, the upper bound

$$\sigma \le n-k$$

(30)

for the slope $\sigma$ was obtained in [25] for fixed binary convolutional codes. We conjecture that this bound is true also for non-binary time-varying convolutional codes, and, hence, for skew convolutional codes.

Another interesting metric for convolutional codes is the sum-rank metric, which can be applied for multi-shot network coding [26]. The metric is defined as follows. The rank weight $w_R\left(v_t\right)$ of a vector $v_t$ over the extension field ${\mathbb{F}}_{q^m}$ is the rank of the vector over the base field ${\mathbb{F}}_q$, i.e., $w_R\left(v_t\right)$ is the maximum number of ${\mathbb{F}}_q$-linearly independent components of $v_t$. The sum-rank weight of a sequence v in (16) is the sum of weights of its items $v_t$. The sum-rank distance between two sequences is the weight of their difference.

The rank of a vector $v_t\in {\mathbb{F}}_{q^m}^n$ is upper bounded by the Hamming weight $w_H\left(v_t\right)$ of the vector, i.e.,

$$w_R\left(v_t\right)\le w_H\left(v_t\right).$$

(31)

Hence, any upper bound for the Hamming metric is an upper bound for the sum-rank metric, and, from Theorem 3, we have the following corollary.

Corollary 2.

The free sum-rank distance $d_f$ of $[n,k]$ skew convolutional code $\mathcal{C}$ of degree $\nu =deg\mathcal{C}$ is upper bounded by (28) or by (29).

On the other hand, from (31), we obtain the following lemma.

Lemma 4.

Let the distance of a code $\mathcal{C}$ in the sum-rank metric be d; then, in the Hamming metric, the code distance is at least d.

We next compute the free distance, active burst distances, and the slope for the code $\widehat{\mathcal{C}}$ from Example 2 for the Hamming and for the sum-rank metrics.

Lemma 5.

In the sum-rank metric, the skew convolutional code $\widehat{\mathcal{C}}$ defined by $G\left(D\right)$ in (22) has the ℓ-th active burst distance $d_{\ell }^{burst}=\ell +2$ for $\ell =2,3,\dots$, the slope of the active distance is $\sigma =1$, and the free distance is $d_f=4$.

Proof. 

For this code, the shortest length of a loop is $\ell =2$; hence, we should consider loops of length $\ell =2,3,\dots$. It follows from (27) that the weight $w_R\left(v_t\right)=\mathrm{rank} v_t$ of a branch in the code trellis that diverges from or merges to zero state is 2. A branch connecting two nonzero states has weight at least 1. Indeed, for odd t, the branch label $v_t$ in (27) is a linear combination of vectors $(\alpha ,{\alpha }^2)$ and $(1,{\alpha }^2)$ that are ${\mathbb{F}}_{q^m}$-linearly independent, and $v_t$ can’t be 0 for nonzero coefficients $u_{t-1},u_t$. The same is true for even t. Hence, $d_{\ell }^{\mathrm{burst}}\ge \ell +2$. On the other hand, the path, corresponding to the information sequence $u_0=u_1=\dots =u_{\ell -1}\ne 0$, $u_{\ell }=0$, is an ℓ-loop of weight $\ell +2$. Hence, $d_{\ell }^{\mathrm{burst}}\le \ell +2$, and the statement of the lemma follows. □

Combining Lemmas 3 and 4, we obtain the following corollary.

Corollary 3.

In the Hamming metric, the skew convolutional code $\widehat{\mathcal{C}}$ defined by $G\left(D\right)$ in (22) has the ℓ-th active burst distance $d_{\ell }^{burst}=\ell +2$ for $\ell =2,3,\dots$, the slope of the active distance is $\sigma =1$ and free distance is $d_f=4$.

For both metrics, the Hamming and the sum-rank, the upper bounds for the free distance (28) and for the slope (30) for the unit memory $[2,1]$ code $\widehat{\mathcal{C}}$ become

$$d_f\le 2n-k+1=4,\mathrm{and}\sigma \le n-k=1.$$

Hence, the skew code $\widehat{\mathcal{C}}$ defined by (22) achieves the Singleton-type upper bound on $d_f$ and can be called MDS codes like in [23]. The Heller bound (29) gives $d_f\le 4$ as well. The slope of $\widehat{\mathcal{C}}$ also reaches the upper bound (30).

A generator matrix $G\left(D\right)$ of a skew convolutional code (and corresponding encoder) is called catastrophic if there exists an information sequence $u\left(D\right)$ of infinite weight such that the code sequence $v\left(D\right)=u\left(D\right)G\left(D\right)$ has finite weight. The generator matrix $G\left(D\right)$ in (22) of skew convolutional code $\widehat{\mathcal{C}}$ with $\theta ={(.)}^q$ is non-catastrophic, since the slope $\sigma >0$. Note that, in case of fixed convolutional code ${\mathcal{C}}^{\prime }$, i.e., for $\theta =id$, the generator matrix (22) is catastrophic, and the code has $d_f=2$ and $\sigma =0$.

4.5. Blocking of Skew Convolutional Codes

A skew convolutional code $\mathcal{C}$, represented as a $\tau$-periodic $[n,k]$ code, can be considered as a $[\tau n,\tau k]$ fixed code ${\mathcal{C}}^{\left(\tau \right)}$ by τ-blocking, described in [21]. The only difference between $\mathcal{C}$ and ${\mathcal{C}}^{\left(\tau \right)}$ is that the code symbols are grouped in blocks $v_t$ of different lengths in these codes. In this way, known methods to analyze fixed codes can be applied to skew convolutional codes.

For example, the $[2,1]$ skew code $\widehat{\mathcal{C}}$ with generator matrix (24) has period $\tau =m=2$ and can be written as $[4,2]$ fixed code ${\mathcal{C}}^{\left(\tau \right)}={\mathcal{C}}^{\left(2\right)}$ defined by the scalar generator matrix

$$G^{\left(2\right)}=\left(\begin{array}{cc}1\alpha \alpha {\alpha }^2& 0000\\ 001\alpha & {\alpha }^2\alpha 00\\ & 1\alpha \alpha {\alpha }^2& 0000\\ & 001\alpha & {\alpha }^2\alpha 00\\ & \dots \end{array}\right)$$

which coincides with the matrix G in (24) but is written in 2-blocked form. From $G^{\left(2\right)}$, we obtain the generator polynomial matrix of the $[4,2]$ blocked code ${\widehat{\mathcal{C}}}^{\left(2\right)}$ as

$$G^{\left(2\right)}\left(D\right)=\left(\begin{array}{cccc}1& \alpha & \alpha & {\alpha }^2\\ {\alpha }^{2}D& \alpha D& 1& \alpha \end{array}\right).$$

In general, for any skew convolutional code $\mathcal{C}$ and for any i-blocking ${\mathcal{C}}^{\left(i\right)}$, $i\in {\mathbb{N}}_1$, the codewords, represented by sequences v of elements from ${\mathbb{F}}_{q^m}$ in (16), are the same for codes $\mathcal{C}$ and ${\mathcal{C}}^{\left(i\right)}$. Hence, the codes have the same properties, e.g., we have

$$deg\mathcal{C}=deg{\mathcal{C}}^{\left(i\right)}.$$

(32)

5. Dual Skew Convolutional Codes

5.1. Definitions of Duality

The duality of skew convolutional codes can be defined in different ways.

First, consider a skew convolutional code $\mathcal{C}$ over $\mathbb{F}$ in a scalar form as a set of sequences as in (16). For two sequences v and $v^{\prime }$, where at least one of them is finite, define the scalar product $(v,v^{\prime })$ as the sum of products of corresponding components, where missing components are assumed to be zeros. We say that the sequences are orthogonal if $(v,v^{\prime })=0$.

Definition 3.

The dual code ${\mathcal{C}}^{\perp }$ to a skew convolutional $[n,k]$ code $\mathcal{C}$ is an $[n,n-k]$ skew convolutional code ${\mathcal{C}}^{\perp }$ such that $(v,v^{\perp })=0$ for all finite length words $v\in \mathcal{C}$ and for all words $v^{\perp }\in {\mathcal{C}}^{\perp }$.

Another way to define orthogonality is, for example, as follows. Consider two n-words $v\left(D\right)$ and $v^{\perp }\left(D\right)$ over ${\mathcal{Q}}^n$. We say that $v^{\perp }\left(D\right)$ is left-orthogonal to $v\left(D\right)$ if $v^{\perp }\left(D\right)v\left(D\right)=0$ and right-orthogonal if $v\left(D\right)v^{\perp }\left(D\right)=0$. A left dual code to a skew convolutional code $\mathcal{C}$ can be defined as

$${\mathcal{C}}_{\mathrm{left}}^{\perp }=\{v^{\perp }\in {\mathcal{Q}}^n:v^{\perp }\left(D\right)v\left(D\right)=0 \mathrm{for} \mathrm{all} v\in \mathcal{C}\}.$$

The dual code ${\mathcal{C}}_{\mathrm{left}}^{\perp }$ is a left submodule of ${\mathcal{Q}}^n$, hence it is a skew convolutional code.

Later on, we consider dual codes according to Definition 3 only, since it is more interesting for practical applications.

5.2. Parity Check Matrices

Given a code $\mathcal{C}$ with generator matrix G, we next show how to find a parity check matrix H, such that $G{H}^T=0$.

Let a skew $[n,k]$ code $\mathcal{C}$ of memory $\mu$ be defined by a polynomial generator matrix $G\left(D\right)$ in (12), which corresponds to the scalar generator matrix G in (18). For the dual $[n,n-k]$ code ${\mathcal{C}}^{\perp }$, we write a transposed parity check matrix $H^T$ of memory ${\mu }^{\perp }$, similar to classical convolutional codes, as

$$H^T=\left(\begin{array}{cccccc}{H}_0^T& H_1^T\hfill & \dots & H_{{\mu }^{\perp }}^T& & \\ & \theta \left(H_0^T\right)\hfill & \dots & \theta \left(H_{{\mu }^{\perp }-1}^T\right)& \theta \left(H_{{\mu }^{\perp }}^T\right)& \\ & \hfill & \dots \end{array}\right)$$

(33)

where $\mathrm{rank}\left(H_0\right)=n-k$. Similar to [20], we call the matrix $H^{\perp }$ the syndrome former and write it in polynomial form as

$$H^T\left(D\right)=H_0^T+H_1^{T}D+\cdots +H_{{\mu }^{\perp }}^T{D}^{{\mu }^{\perp }}.$$

(34)

Then, we have the following parity check matrix of the causal code $\mathcal{C}$ with the generator matrix (21)

$$H=\left(\begin{array}{c}{H}_0\\ H_1& \theta \left(H_0\right)\hfill \\ ⋮& ⋮\hfill \\ H_{{\mu }^{\perp }}& \theta \left(H_{{\mu }^{\perp }-1}\right)\hfill & ⋮\\ & \theta \left(H_{{\mu }^{\perp }}\right)\hfill \end{array}\right)$$

(35)

which, in the case of $\theta =$ id, coincides with the check matrix of a classical fixed convolutional code.

From Definition 3, we have that $v{H}^T=0$ for all sequences $v\in \mathcal{C}$ over $\mathbb{F}$. On the other hand, from (4), we have that every codeword $v\left(D\right)\in \mathcal{C}$ can be written as $v\left(D\right)=u\left(D\right)G\left(D\right)$. Hence, if we find an $n\times (n-k)$ matrix $H^T\left(D\right)$ over $\mathcal{R}$ of full rank such that $G\left(D\right)H^T\left(D\right)=0$, then every codeword satisfies $v\left(D\right)H^T\left(D\right)=u\left(D\right)G\left(D\right)H^T\left(D\right)=0$ and, vice versa, i.e., if $v\left(D\right)H^T\left(D\right)=0$ then $v\left(D\right)$ is a codeword of $\mathcal{C}$.

Theorem 4.

We have $G\left(D\right)H^T\left(D\right)=0$ if and only if $G{H}^T=0$.

Proof. 

We show the proof for the code of memory $\mu =1$ (like in Example 2). For the general memory case, the proof follows similarly. Consider the code with generator matrices $G\left(D\right)$ and G given by (12) and (18). Let us find a check matrix with memory ${\mu }^{\perp }=\mu =1$. Then, we have

$$H^T\left(D\right)=H_0^T+H_1^{T}D$$

(36)

and

$$H^T=\left(\begin{array}{cc}{H}_0^T& H_1^T\hfill \\ & \theta \left(H_0^T\right)\hfill & \theta \left(H_1^T\right)\\ & \hfill & {\theta }^2\left(H_0^T\right)& {\theta }^2\left(H_1^T\right)\\ & \hfill & \dots \end{array}\right).$$

(37)

From the condition $G\left(D\right)H^T\left(D\right)=0$, we have the following system of equations for unknowns $H_0^T,H_1^T$

$$\left\{\begin{array}{c}{G}_0{H}_0^T=0\hfill \\ G_0{H}_1^T+G_1\theta \left(H_0^T\right)=0\hfill \\ G_1\theta \left(H_1^T\right)=0.\hfill \end{array}\right.$$

(38)

From the condition $G{H}^T=0$, we obtain the following equations: by multiplying the first row of G by $H^T$ we get the system (38), by multiplying the second row of of G by $H^T$ we get the system

$$\left\{\begin{array}{c}\theta \left(G_0\right)\theta \left(H_0^T\right)=0\hfill \\ \theta \left(G_0\right)\theta \left(H_1^T\right)+\theta \left(G_1\right){\theta }^2\left(H_0^T\right)=0\hfill \\ \theta \left(G_1\right){\theta }^2\left(H_1^T\right)=0\hfill \end{array}\right.$$

which is equivalent to (38). Multiplication of other rows of G by $H^T$ does not give new equations. Hence, conditions $G\left(D\right)H^T\left(D\right)=0$ and $G{H}^T=0$ give the same system (38). □

Example 3.

For the code $\widehat{\mathcal{C}}$ from Example 2, we write $H_0=(a,c)$ and $H_1=(b,d)$. Using $G_0,G_1$ from (22) and solving the system (38), we obtain $H_0=(\alpha ,1)$ and $H_1=(1,\alpha )$. Hence, $H\left(D\right)=(\alpha +D,1+\alpha D)$ and a parity check matrix H of the code $\widehat{\mathcal{C}}$, which is a generator matrix for the dual code ${\widehat{\mathcal{C}}}^{\perp }$, is as follows:

$$H=\left(\begin{array}{c}\alpha 1\\ 1\alpha & {\alpha }^{2}1\\ & 1{\alpha }^2& \alpha 1& ⋮\\ & & 1\alpha \end{array}\right).$$

5.3. Trellises of Dual Codes

Similar to fixed convolutional codes, we have the following theorem:

Theorem 5.

For a skew convolutional code $\mathcal{C}$ and its dual ${\mathcal{C}}^{\perp }$, we have $deg\mathcal{C}=deg{\mathcal{C}}^{\perp }$.

Proof. 

Denote by $\tau$ and ${\tau }^{\perp }$ periods of the codes $\mathcal{C}$ and ${\mathcal{C}}^{\perp }$, respectively. Let ℓ be the least common multiple of periods $\tau$ and ${\tau }^{\perp }$; then, the ℓ-blocked codes ${\mathcal{C}}^{(\ell )}$ and ${\left({\mathcal{C}}^{\perp }\right)}^{(\ell )}$ are both fixed convolutional codes. The fixed codes ${\mathcal{C}}^{(\ell )}$ and ${\left({\mathcal{C}}^{\perp }\right)}^{(\ell )}$ are dual to each other, since blocking does not change code sequences, hence $deg{\mathcal{C}}^{(\ell )}=deg{\left({\mathcal{C}}^{\perp }\right)}^{(\ell )}$, see, e.g., Theorem 2.69, [20] for fixed dual convolutional codes. From (32), we have $deg\mathcal{C}={\mathcal{C}}^{(\ell )}$, $deg{\mathcal{C}}^{\perp }=deg{\left({\mathcal{C}}^{\perp }\right)}^{(\ell )}$, hence $deg\mathcal{C}=deg{\mathcal{C}}^{\perp }$. □

It follows from Theorem 5 that the number of states at one level of the code trellis (trellis complexity) is the same for an original code $\mathcal{C}$ and for its dual ${\mathcal{C}}^{\perp }$ and equals $Q^{deg\mathcal{C}}$.

The trellis of the dual code ${\widehat{\mathcal{C}}}^{\perp }$ obtained from the matrix H in Example 3 is shown in Figure 4. The trellis has $Q^{deg\widehat{\mathcal{C}}}=4^1=4$ states labeled by elements of the set $\mathcal{S}=\{0,1,\alpha ,{\alpha }^2\}$. Every word of the dual code ${\widehat{\mathcal{C}}}^{\perp }$ is represented by a path in the trellis that starts from a state $s_{-1}\in \mathcal{S}$ and goes to the right. For the trellis section corresponding to time $t=0,1,\dots$, the edge connecting states $s_{t-1}$ and $s_t$ are labeled by $v_t^{\perp }$ computed as follows:

$$v_t^{\perp }=\left\{\begin{array}{cc}{s}_{t-1}({\alpha }^2,1)+s_t(1,{\alpha }^2)\hfill & \mathrm{for} \mathrm{odd}t,\hfill \\ s_{t-1}(\alpha ,1)+s_t(1,\alpha )\hfill & \mathrm{for} \mathrm{even}t.\hfill \end{array}\right.$$

6. Trellis Decoding of Skew Convolutional Codes

For a given skew convolutional code $\mathcal{C}$, we showed how to obtain a code trellis using a generator matrix of the code. Another way to obtain a code trellis of $\mathcal{C}$ using a parity check matrix H was proposed in [27]. Having a code trellis, one can use the Viterbi decoder [4] for maximum likelihood sequence decoding or the BCJR decoder [28] for symbol-wise decoding.

For an $[n,k]$ skew convolutional code, the complexity of the Viterbi decoder has order $\varkappa =n{Q}^k{Q}^{deg\mathcal{C}}$ operations (additions and binary selections), which exponentially increases in k and might be high for high rate codes. Using detailed code trellis [27,29], where every edge is labeled by a single field element, the decoding complexity can be reduced to

$$\varkappa =n{Q}^{min\{k,n-k\}}{Q}^{deg\mathcal{C}}.$$

(39)

Another advantage of the method in [29] is that it can be applied to every trellis section separately, which is convenient for time-varying codes. The decoding complexity of a particular code can also be decreased using methods in [30]. The complexity of the BCJR decoding algorithm has the same order as in (39) as well.

Symbol-wise decoding of a skew convolutional code $\mathcal{C}$ can be implemented using a trellis of the dual code ${\mathcal{C}}^{\perp }$, see [31,32,33]. The order of decoding complexity in this case is also given in (39).

7. Conclusions

A new class of non-binary skew convolutional codes was defined that extends the class of fixed convolutional codes. The skew convolutional codes are equivalent to periodic time-varying classical convolutional codes but have as compact a description as fixed convolutional codes.

Given a field $\mathbb{F}={\mathbb{F}}_{p^M}={\mathbb{F}}_{q^m}$ of characteristic p and code parameters $n,k$ and $\mu$; for every authomorphism $\theta \left(a\right)=q^a$ of the field, the subclass $SCC\left(\theta \right)$ of skew convolutional $[n,k]$ codes of memory $\mu$ over the field is defined. All the subclasses have the same number of codes. In case of the identity automorphism $\theta =\mathrm{id}$, we obtain the subclass $SCC\left(\mathrm{id}\right)$ of classical fixed convolutional codes. Any other automorphism $\theta$ of the field gives a subclass $SCC\left(\theta \right)$ of skew convolutional codes that can be represented as a periodic time-varying convolutional code with typical period m. The total number of the subclasses $SCC\left(\theta \right)$ is equal to the number of divisors of M, which is usually not a large number. The class of m-periodic time-varying convolutional codes is larger than the class of skew convolutional codes. Every code in the subclass $SCC\left(\theta \right)$ is defined by a $k\times n$ polynomial generator matrix $G\left(D\right)$ over the ring of $\theta$-skew polynomials; hence, the descriptions of skew codes and fixed codes are the same, and the description is given by the same matrix $G\left(D\right)$.

Every $\tau$-periodic convolutional $[n,k]$ code can be written as a fixed [$\tau n,\tau k]$ code; hence, skew convolutional codes can be analyzed by methods known for fixed codes. We showed how to design generator and parity check matrices in polynomial and scalar forms, encoders and code trellises for skew convolutional codes, and their duals. Using code trellises for original and dual codes, in the case of channels without memory, one can apply Viterbi or BCJR decoding algorithms, or the dualized BCJR algorithm.

Future work. We gave just a first encounter with skew convolutional codes. There are many open problems remaining. The algebraic structure of classical fixed convolutional codes is well understood, see, e.g., [20,21] and references therein. The questions such as how to obtain a canonical generator matrix of a skew convolutional code and its dual, or how to design encoders of a fractional generator matrix can be considered in the future. Another open problem is to find good skew convolutional codes reaching an upper bound on the free distance. One possibility to obtain skew convolutional codes is based on unwrapping skew quasi-cyclic (QC) block codes (see such codes in [17]) in a way similar to [34] or [35], where it is shown how fixed classical convolutional codes can be obtained by unwrapping QC block codes and vice versa.