A Low Complexity Algorithm and Architecture for Systematic Encoding of Hermitian Codes

TL;DR

This paper introduces a low complexity, VLSI-implementable algorithm and architecture for systematic encoding of Hermitian codes, significantly reducing computational complexity and resource usage.

Contribution

It proposes a novel algorithm and encoder architecture that achieves O(q^2) runtime and space complexity for Hermitian code encoding.

Findings

Achieves O(q^2) runtime complexity

Suitable for VLSI implementation

Uses q varying-rate Reed-Solomon encoders

Abstract

We present an algorithm for systematic encoding of Hermitian codes. For a Hermitian code defined over GF(q^2), the proposed algorithm achieves a run time complexity of O(q^2) and is suitable for VLSI implementation. The encoder architecture uses as main blocks q varying-rate Reed-Solomon encoders and achieves a space complexity of O(q^2) in terms of finite field multipliers and memory elements.

Figures

Equations

$$\chi :x^{q+1}=y^q+y$$

$$L(m{P}_{\infty })=⟨x^a{y}^b:aq+b(q+1)\le m,0\le a,0\le b<q⟩$$

$$P_{\alpha ,\beta }=(\alpha ,{\alpha }^{q+1}(y_0+\beta )+\delta (\alpha )\beta ),$$

$$\{\mathbf{c}\in {\mathbb{F}}_{q^2}^{q^3}:\sum _{\alpha \in {\mathbb{F}}_{q^2}}\sum _{\beta \in {\mathbb{F}}_q}{\mathbf{c}}_{\beta ,\alpha }f(P_{\alpha ,\beta })=0,\forall f\in L(m{P}_{\infty })\}$$

$$S_{a,b}(\mathbf{r})=\sum _{\alpha \in {\mathbb{F}}_{q^2}}\sum _{\beta \in {\mathbb{F}}_q}{\mathbf{r}}_{\beta ,\alpha }(x(P_{\alpha ,\beta }){)}^a(y(P_{\alpha ,\beta }){)}^b$$

$$S_{a,b}(\mathbf{r})=\sum _{\alpha \in {\mathbb{F}}_{q^2}}\sum _{\beta \in {\mathbb{F}}_q}{\alpha }^a({\alpha }^{(q+1)}(y_0+\beta )+\delta (\alpha )\beta {)}^b{\mathbf{r}}_{\beta ,\alpha }$$

$$S_{a,b}({\bf{r}})=\left\{\begin{array}[]{ll}\sum_{\alpha\in\mathbb{F}_{q^{2}}\backslash\{0\}}\sum_{\beta\in\mathbb{F}_{q}}\alpha^{a}\alpha^{b(q+1)}{(y_{0}+\beta)}^{b}{\bf{r}}_{\beta,\alpha}&\textrm{a $\neq$ 0}\\ \sum_{\alpha\in\mathbb{F}_{q^{2}}}\sum_{\beta\in\mathbb{F}_{q}}(\alpha^{b(q+1)}(y_{0}+\beta)^{b}+\delta(\alpha)\beta^{b}){\bf{r}}_{\beta,\alpha}&\textrm{a = 0}\end{array}\right.$$

$$S_{a,b}({\bf{r}})=\left\{\begin{array}[]{ll}\sum_{i=0}^{q^{2}-2}\epsilon^{i(a+b(q+1))}(y_{0}^{b}{\bf{r}}_{0,i}+\sum_{j=0}^{q-2}{(y_{0}+\gamma^{j})}^{b}{\bf{r}}_{j+1,i})&\textrm{a $\neq$ 0}\\ \sum_{i=0}^{q^{2}-2}\epsilon^{ib(q+1)}(y_{0}^{b}{\bf{r}}_{0,i}+\sum_{j=0}^{q-2}{(y_{0}+\gamma^{j})}^{b}{\bf{r}}_{j+1,i})+\sum_{j=0}^{q-2}\gamma^{jb}{\bf{r}}_{j+1,q^{2}-1}&\textrm{a = 0}\end{array}\right.$$

$$\mathbf{A}=\left(\begin{array}[]{ccccc}(y_{0}+0{)^{0}}&(y_{0}+\gamma^{0})^{0}&(y_{0}+\gamma^{1})^{0}&\ldots&(y_{0}+\gamma^{q-2})^{0}\\ (y_{0}+0{)^{1}}&(y_{0}+\gamma^{0})^{1}&(y_{0}+\gamma^{1})^{1}&\ldots&(y_{0}+\gamma^{q-2})^{1}\\ (y_{0}+0{)^{2}}&(y_{0}+\gamma^{0})^{2}&(y_{0}+\gamma^{1})^{2}&\ldots&(y_{0}+\gamma^{q-2})^{2}\\ \vdots&\vdots&\vdots&\ddots&\vdots\\ (y_{0}+0{)^{q-1}}&(y_{0}+{\gamma^{0}})^{q-1}&(y_{0}+\gamma^{1})^{q-1}&\ldots&(y_{0}+{\gamma^{q-2}})^{q-1}\\ \end{array}\right)$$

$$\mathbf{A^{\prime}}=\left(\begin{array}[]{ccccc}1&(\gamma^{0})^{0}&(\gamma^{1})^{0}&\ldots&(\gamma^{q-2})^{0}\\ 0&(\gamma^{0})^{1}&(\gamma^{1})^{1}&\ldots&(\gamma^{q-2})^{1}\\ 0&(\gamma^{0})^{2}&(\gamma^{1})^{2}&\ldots&(\gamma^{q-2})^{2}\\ \vdots&\vdots&\vdots&\ddots&\vdots\\ 0&(\gamma^{0})^{q-1}&(\gamma^{1})^{q-1}&\ldots&(\gamma^{q-2})^{q-1}\\ \end{array}\right)$$

$$\overline{A}=(A_{0},A_{1},\dots,A_{q^{2}-1}),\ A_{i}=\left\{\begin{array}[]{ll}A^{\prime}&\textrm{i = $q^{2}$-1 }\\ A&\textrm{otherwise}\end{array}\right.$$

$${\tilde{\mathbf{r}}}_j=A_j{\mathbf{r}}_j$$

$$\{c\in {\mathbb{F}}_q^q:\sum _{i=0}^{q-2}{c}_i{\xi }^i=0,\forall \xi \in \Re \backslash \{{\xi }_0\},c_{q-1}+\sum _{i=0}^{q-2}{c}_i{{\xi }_0}^i=0\}$$

$$E_i=EC(({ϵ}^{0+i(q+1)},{ϵ}^{1+i(q+1)},\dots ,{ϵ}^{\hat{a}(i)+i(q+1)}),q^2)$$

$$\mathbf{A^{-1}}=\left(\begin{array}[]{cccc}1-(y_{0}+0{)^{q-1}}&(y_{0}+0{)^{q-2}}&\ldots&(y_{0}+0{)^{0}}\\ 1-(y_{0}+1{)^{q-1}}&(y_{0}+1{)^{q-2}}&\ldots&(y_{0}+1{)^{0}}\\ 1-(y_{0}+\gamma{)^{q-1}}&(y_{0}+\gamma{)^{q-2}}&\ldots&(y_{0}+\gamma{)^{0}}\\ \vdots&\vdots&\ddots&\vdots\\ 1-(y_{0}+{\gamma^{q-2}}{)^{q-1}}&(y_{0}+{\gamma^{q-2}}{)^{q-2}}&\ldots&(y_{0}+{\gamma^{q-2}}{)^{0}}\\ \end{array}\right)$$

$$\mathbf{A^{\prime-1}}=\left(\begin{array}[]{cccccc}1&0&0&\ldots&0&-1\\ 0&-(1{)^{q-2}}&-(1{)^{q-3}}&\ldots&-(1{)^{1}}&-1\\ 0&-(\gamma{)^{q-2}}&-(\gamma{)^{q-3}}&\ldots&-(\gamma{)^{1}}&-1\\ \vdots&\vdots&\vdots&\ddots&\vdots\\ 0&-({\gamma^{q-2}}{)^{q-2}}&-({\gamma^{q-2}}{)^{q-3}}&\ldots&-({\gamma^{q-2}}{)^{1}}&-1\\ \end{array}\right)$$

$$\begin{array}[]{ll}C_{\mu,\nu}=&(1-(y_{0}+\mu)^{q-1}(y_{0}+\nu)^{0}-(y_{0}+\mu)^{q-2}(y_{0}+\nu)^{1}\\ &\dots-(y_{0}+\mu)^{0}(y_{0}+\nu)^{q-1})\\ &\\ &=1-\sum_{i=0}^{q-1}(y_{0}+\mu)^{q-1-i}(y_{0}+\nu)^{i}\\ &\\ &=1-\dfrac{(y_{0}+\mu)^{q}-(y_{0}+\nu)^{q}}{y_{0}+\mu-(y_{0}+\nu)}\\ \end{array}$$

$$1-(\mu-\nu)^{q-1}=\left\{\begin{array}[]{ll}1&\textrm{$\mu=\nu$}\\ 0&\textrm{$\mu\neq\nu$}\end{array}\right.$$

$$\begin{array}[]{ll}\hat{C}=&\{c\in\mathbb{F}_{q^{2}}^{q^{3}}\ :\ S_{a,b}(c)=0,\\ &\ a=0,1,\dots,\hat{a}<q^{2}-1,\,\ b=0,1,\dots,q-1\}\\ \end{array}$$

$$EC(({ϵ}^{0+i(q+1)},{ϵ}^{1+i(q+1)},\dots ,{ϵ}^{\hat{a}(i)+i(q+1)}),q^2)$$

$$Algorithm2$$

$${\tilde{\mathbf{r}}}_{i,j}=({\varphi }_i(({\tilde{\mathbf{r}}}_{i,0},{\tilde{\mathbf{r}}}_{i,1},\dots ,{\tilde{\mathbf{r}}}_{i,q^2-\hat{a}(i)-2})){)}_j$$

$$A_j({\mathbf{d}}_{0,j},{\mathbf{d}}_{1,j},\dots ,{\mathbf{d}}_{\hat{b}(j)-1,j},y_{\hat{b}(j),j},y_{\hat{b}(j)+1,j},\dots ,y_{q-1,j}{)}^T=({\tilde{\mathbf{r}}}_{0,j},{\tilde{\mathbf{r}}}_{1,j},\dots ,{\tilde{\mathbf{r}}}_{q-1-\hat{b}(j),j},u_{q-\hat{b}(j),j},u_{q-\hat{b}(j)-1,j},\dots ,u_{q-1}{)}^T$$

$$c_i=({\mathbf{d}}_{0,j},{\mathbf{d}}_{1,j},\dots ,{\mathbf{d}}_{\hat{b}(j)-1,j},y_{\hat{b}(j),j},y_{\hat{b}(j)+1,j},\dots ,y_{q-1,j})$$

$${\tilde{\mathbf{r}}}_i=({\tilde{\mathbf{r}}}_{0,j},{\tilde{\mathbf{r}}}_{1,j},\dots ,{\tilde{\mathbf{r}}}_{q-1-\hat{b}(j),j},u_{q-\hat{b}(j),j},u_{q-\hat{b}(j)-1,j},\dots ,u_{q-1})$$

$$\mathbf{D(l)}=\left(\begin{array}[]{c|c}I_{l}&0\\ \hline\cr P&0\end{array}\right)$$

$$\mathbf{A^{-1}D}=\left(\begin{array}[]{c|c}0&0\\ \hline\cr\tilde{P}&0\end{array}\right)$$

$$\begin{array}[]{ll}A(x_{0},x_{1},\dots,x_{n-l-1},y_{n-l},y_{n-l+1},\dots,y_{n-1})^{T}=&\\ \ \ \ \ (v_{0},v_{1},\dots,v_{l-1},u_{l},u_{l+1},\dots,u_{n-1})^{T}&\\ \end{array}$$

$$Algorithm3$$

$$\begin{array}[]{ll}&A(x_{0},x_{1},\dots,x_{n-l-1},y_{n-l},y_{n-l+1},\dots,y_{n-1})^{T}\\ &=\tilde{b}^{T}+b^{T}\\ &=A(A^{-1}D\hat{b}^{T})+b^{T}\\ &=D\hat{b}^{T}+b^{T}\\ &=D(v_{0},v_{1},\dots,v_{l-1},0,0,\dots,0)^{T}\\ &\ \ \ -D(b_{0},b_{1},\dots,b_{l-1},0,0,\dots,0)^{T}+b^{T}\\ &=(v_{0},v_{1},\dots,v_{l-1},u_{l},u_{l+1},\dots,u_{n-1})^{T}\\ \end{array}$$

Full text

I Introduction

Algebraic-Geometric (AG) codes [1] offer desirable properties such as large code lengths over small finite fields, the potential to find a large selection of codes and good error-correction at high code rates [2]. In recent years, an important class of one-point AG codes, called Hermitian codes, has been frequently discussed [3]-[6].

For a Hermitian code defined over $GF(q^{2})$, a brute-force way to design an encoder is to multiply the information vector by a generator matrix. The space complexity of a serial-in serial-out architecture for this systematic encoder is $O(q^{5})$ in terms of finite field multipliers and $O(q^{3})$ in terms of memory elements. The encoder requires $2n$ clock cycles to generate a codeword of length $n$, thus, the latency is $n$.

By considering a Hermitian code as a superposition of several generalized Reed Solomon (RS) codes, an encoding scheme is introduced in [4]. In [5], an encoding algorithm by forming a bivariate information polynomial and evaluating this polynomial at every finite rational point on the Hermitian curve is proposed. However, both such schemes are nonsystematic and involve the evaluation of bivariate polynomials at $n$ finite rational points, thus, they may not have efficient hardware architecture for implementations.

A computationally efficient approach for systematic encoding was proposed in [7]. A serial-in serial-out architecture for this approach was proposed in [8]. This architecture requires $n$ clock cycles to encode a codeword of length $n$. The space complexity for this architecture is $O(q^{3})$, both in terms of finite field multipliers and memory elements.

In this paper, we present an algorithm for systematic encoding and syndrome computation of Hermitian codes. We give an outline for the encoder architecture, which uses $q$ varying-rate RS encoders as main blocks and requires $n^{2/3}$ clock cycles for encoding a codeword of length $n$. The space complexity of the architecture is $O(q^{2})$ in terms of both, memory elements and finite field multipliers.

II Hermitian Codes and Syndrome Computation

We consider codes from a Hermitian curve

[TABLE]

over a finite field $\mathbb{F}_{q^{2}}$. The space $L(mP_{\infty})$ consists of all functions on $\chi$ that have a pole of multiplicity at most $m$ only at the unique point at infinity. For $L(mP_{\infty})$, we choose a basis

[TABLE]

Let $y_{0}$ be an element of $\mathbb{F}_{q^{2}}$ such that $y_{0}+{y_{0}}^{q}=1$. The affine rational points on $\chi$ are of the form

[TABLE]

where $\delta$ is the Kronecker-delta and $\alpha$ and $\beta$ represent arbitrary elements in $\mathbb{F}_{q^{2}}$ and $\mathbb{F}_{q}$ respectively.

Let $\epsilon$ be a primitive element in $\mathbb{F}_{q^{2}}$ and let $\gamma$ be a primitive element in $\mathbb{F}_{q}$. We label the positions in a codeword by the corresponding elements $\alpha$ = $\epsilon^{i}$, $\beta$ = $\gamma^{j}$ and we thus naturally consider a codeword as a $q\times q^{2}$ matrix ${\bf{c}}$. Occasionally we will index elements in this array by elements of the fields $\mathbb{F}_{q^{2}}$ and $\mathbb{F}_{q}$, otherwise we index starting with [math].

A Hermitian code $C(m)$ is defined as

[TABLE]

For an in-depth treatment of AG codes we refer to [9]. Throughout this paper we consider $m$ and thus the Hermitian code as being fixed.

Given a $q\times q^{2}$ matrix ${\bf{r}}$ we can check if ${\bf{r}}$ is a codematrix in a Hermitian code by computing the syndromes

[TABLE]

${\bf{r}}$ is a code-matrix iff $S_{a,b}({\bf{r}})$ is zero for all $x^{a}y^{b}\in L(mP_{\infty})$. Substituting the explicit form of the points we get

[TABLE]

These equations can further be developed to give specific forms as shown in (1) and (2).

From the structure of (2), it comes naturally to define a matrix as in (3) to convert the expression into a matrix multiplication.

Similarly we define a matrix $A^{\prime}$ as

[TABLE]

For later use we give here the following Lemma.

II-A Lemma 1

*The $l\times l$ submatrices of $A$ consisting of the elements indexed by $i,j$ and that of $A^{\prime}$ consisting of the elements indexed by $j,i$, $i=q-l,\ q-l+1,\dots,q-1$, $j=0,\ 1,\dots,l-1$ are non-singular.

Proof:

This lemma follows in both cases from the properties of Vandermonde matrices. ∎

It will be convenient to define an array $\overline{A}$ of matrices of type $A$ and $A^{\prime}$.

[TABLE]

Given a $q\times q^{2}$ array ${\bf{r}}$ with columns ${\bf{r}}_{j}$, we define a $q\times q^{2}$ matrix ${\bf{\tilde{r}}}$ with columns ${\bf{\tilde{r}}}_{j}$ as

[TABLE]

One of the main ingredients in both the syndrome calculation and a systematic encoding is the use of techniques for cyclic codes which are extended by one extra position. Let $\hat{a}(b)=\lfloor(m-(q-1-b)(q+1))/q\rfloor=max(a:x^{a}y^{b}\in L(mP_{\infty}))$.

II-B Definition 1

Let an ordered set $\Re=\{\xi_{0},\xi_{1},\dots\}$ of elements from $\mathbb{F}_{q}$ be given. We define the code $EC(\Re,q)$ as

[TABLE]

For the natural indexing of elements in $\mathbb{F}_{q}$ and $\mathbb{F}_{q^{2}}$ induced by $\gamma$ and $\epsilon$ we have the following Lemma.

II-C Lemma 2

Let a $q\times q^{2}$ matrix ${\bf{r}}$ be given. The matrix ${\bf{r}}$ is a code matrix in the Hermitian code $C(m)$ iff the $i$th row of $\tilde{{\bf{r}}}$ is a codeword in $EC((\epsilon^{0+i(q+1)},\epsilon^{1+i(q+1)},\dots,\epsilon^{\hat{a}(i)+i(q+1)}),q^{2})$.

Proof:

The proof follows immediately from the syndrome definition. ∎

Codes of type $EC((\epsilon^{i(q+1)},\epsilon^{1+i(q+1)},\dots,\epsilon^{\hat{a}(i)+i(q+1)}),q^{2})$ will play a central roll in the sequel. We define codes $E_{i}$ as

[TABLE]

From Lemma 2 we can derive an efficient way to compute the syndrome for a Hermitian code. Given a received matrix r we obtain a matrix $\tilde{{\bf{r}}}$ with columns $\tilde{{\bf{r}}}_{j}$ = $A_{j}{\bf{r}}_{j}$.

Given $\tilde{{\bf{r}}}$ we can easily solve the task of computing syndromes provided we can compute the corresponding syndromes for codes $E_{i},\ i=0,1,\dots,q-1$.

III Systematic Encoding

The idea behind the systematic encoding of Hermitian codes is to use the well known techniques for the systematic encoding of cyclic codes. Lemma 2 almost immediately gives a nonsystematic encoding procedure for Hermitian codes. To this end let $\tilde{{\bf{r}}}$ be a $q\times q^{2}$ matrix such that the $j$th row of $\tilde{{\bf{r}}}$ is a codeword in $E_{j}$. It follows from Lemma 2 that we can obtain a code-matrix for a Hermitian code by multiplying the columns of $\tilde{{\bf{r}}}$ with matrices $A^{-1}$ and $A^{\prime-1}$ respectively. We can obtain such a matrix $\tilde{{\bf{r}}}$ using eg. systematic encoding procedures for codes of type $E_{j},\ j=0,\dots,q-1.$

We will need $A^{-1}$ and $A^{\prime-1}$.

III-A Lemma 3

The matrices $A$ and $A^{\prime}$ have inverses given in (4) and (5).

Proof:

The inverse of $A^{\prime}$ is straight forward to verify. We only show the inverse of $A$. The rows of $A^{-1}$ and the columns of $A$ may be thought of as being indexed by elements of $\mathbb{F}_{q}$. Let $C$ be the matrix obtained as $C=A^{-1}A$. The entry $C_{i,j}$ is thought of as being indexed by $\mu,\nu\in\mathbb{F}_{q}$.

[TABLE]

[TABLE]

∎

We note that we are entirely free to choose ”virtual information symbols” in matrix $\tilde{{\bf{r}}}$. Let a sequence of information symbols be given that are to be encoded systematically in a codeword of a Hermitian code. The trick in obtaining a systematic encoding procedure is to choose the information symbols in $\tilde{{\bf{r}}}$ so that the mapping with $A^{-1}$ and $A^{\prime-1}$ respectively, gives the primary information symbols that we really want to encode.

Before we derive a systematic encoding procedure for Hermitian codes, we treat a somewhat simpler case, which will elucidate the idea of systematic encoding. Let $\hat{C}$ be a code on a Hermitian curve defined as

[TABLE]

The code $\hat{C}$ has dimension $(q^{2}-\hat{a}-1)q$. The following algorithm may be used for systematic encoding of code $\hat{C}$.

III-B Algorithm 1

Write the $(q^{2}-\hat{a}-1)q$ information symbols in an array $d$ of size $q\times(q^{2}-\hat{a}-1)$ 2. 2.

Compute $\hat{\bf{r}}=Ad^{T}$ 3. 3.

*Encode the *$i$th row of $\hat{\bf{r}}$ independently in a systematic way into codewords of the code

[TABLE]

Denote the resulting $q\times q^{2}$ matrix with $\hat{\bf{r}}^{\prime}$. 4. 4.

Compute columns $c_{i}$ = $A_{i}^{-1}\hat{\bf{r}}^{\prime}_{i}$

Algorithm 1 yields a systematic encoding procedure for the code $\hat{C}$ because $c$ is a code matrix by Lemma 2 and the first $(q^{2}-\hat{a}-1)\times q$ symbols are the original information symbols. The first $(q^{2}-\hat{a}-1)$ columns of $d$ determine the first $(q^{2}-\hat{a}-1)$ columns of $\hat{\bf{r}}$. It is the first $(q^{2}-\hat{a}-1)$ columns of $\hat{\bf{r}}$ that contain the virtual information symbols for the encoding of the cyclic codes.

The situation for Hermitian codes is complicated by the fact that the codes $E_{i}$ have different rates. Thus at some instance of the algorithm we have to process the columns that are in one part determined by information symbols and the other part is determined by redundancy symbols generated by the systematic encoders of the codes $E_{i}$. For simplicity, we will restrict our attention to codes $C(m)$ of dimension $k$ that is less than $(q^{3}-g-q)$.

Let $\phi_{i}\ :\ \mathbb{F}_{q^{2}}^{q^{2}-\hat{a}(i)-1}\ \longrightarrow\mathbb{F}_{q^{2}}^{q^{2}}$ be a systematic encoder for a code $E_{i}$. The input sequence to the encoder $\phi_{i}$ are symbols from an array $\tilde{{\bf{r}}}={\tilde{{\bf{r}}}_{i,j}}$ for $j=0,1,\dots,q^{2}-\hat{a}(i)-2$.

We want to construct an algorithm that takes as input an array d of size $q\times q^{2}$ with arbitrarily chosen symbols in positions ${(a,b):b=0,1,\dots,q-1;a=0,1,\dots,q^{2}-\hat{a}(b)-2}$ and zero in the remaining positions and that produces as output a code-array ${\bf{c}}$. Let $\hat{b}(j)$ be defined as the number of information symbols in the $j$th column of ${\bf{d}}$. The columns of ${\bf{d}}$ thus have the form ${\bf{d}}_{j}=({\bf{d}}_{0,j},{\bf{d}}_{1,j},\dots,{\bf{d}}_{\hat{b}(j)-1},0,0,\dots,0)$.

We give a systematic encoder procedure in the following algorithm. During the procedure we also construct an array $\tilde{{\bf{r}}}$. The $i$th row of $\tilde{{\bf{r}}}$ is a codeword in $E_{i}$. Thus the first $q^{2}-\hat{a}(i)-1$ positions in the $i$th row of $\tilde{{\bf{r}}}$ determine the $i$th row of $\tilde{{\bf{r}}}$ completely.

III-C Algorithm 2

The algorithm is shown in (6).

Theorem 1

Algorithm 2 computes a code array $c$ of the Hermitian code $C=(ev_{D}(mP_{\infty}))^{\bot}$.

Proof:

The matrix $\tilde{{\bf{r}}}$ in the algorithm satisfies the conditions $\tilde{{\bf{r}}}_{j}$ = $A_{j}$ $c_{j}$ and the $i$-th row of $\tilde{{\bf{r}}}$ is a codeword in $E_{i}$. Thus $c$ is a code-array by Lemma 2. ∎

Algorithm 2 outlines the mathematical procedure to achieve systematic encoding of a Hermitian code. The real difficulty lies in an efficient implementation of the algorithm. We give such an implementation in Section IV but before proceeding we will need a simple lemma.

Let $A$ be any $n\times n$ matrix with inverse $A^{-1}$. We assume that the submatrix of $A$ indexed by elements $i,j,i=n-l,\dots,n-1\ and\ j=0,1,\dots,l-1$ is nonsingular. This will always be true for the cases that we are interested in by Lemma 1. Let $I_{l}$ denote the $l\times l$ matrix and let $D(l)$ be a $n\times n$ matrix of the following form:

[TABLE]

such that

[TABLE]

for a $l\times l$ matrix $\tilde{P}$. We note that $D(l)^{T}$ is just a systematic encoding matrix for a code which has a parity check matrix the first $l$ rows of $A^{-1}$.

III-D Lemma 5

*Let $x_{0},x_{1},\dots,x_{n-l-1}$ and $v_{0},v_{1},\dots,v_{l-1}$ be given. The solution for $y_{n-l},y_{n-l+1},\dots,y_{n-1}$ and $u_{l},u_{l+1},\dots,u_{n-1}$ to the linear system of equations

[TABLE]

can be found with the following algorithm.

III-E Algorithm 3

Algorithm 3 is given as shown in (7).

Proof:

$A^{-1}\tilde{b}^{T}=A^{-1}D\hat{b}^{T}$ which proves that $y_{0},y_{1},\dots,y_{n-l-1}$ equal zero.

Now it follows that

[TABLE]

∎

IV Efficient Implementation of a Systematic Encoder

Inspecting Algorithm 2 and Lemma 4, we see that we need modules for multiplication of an array with matrix $A$, $A^{-1}$, systematic encoding of codes $E_{j}$, and a systematic encoding module for codes $D_{l}$ defined as

[TABLE]

Before describing the modules in detail we give a black box description and the overall description of the implementation.

IV-A Module A: Multiplication with Matrix $A,A^{\prime}$

The module has as parallel input a vector $d$ of length $q$ and produces as serial output the numbers $(Ad^{T})_{i},\ i=0,1,\dots,q-1$ during the next $q$ clock cycles.

IV-B Module B: Multiplication with Matrix $A^{-1},A^{\prime-1}$

Module B has as serial input a vector $d$ of length $q$. After $q$ clock cycles the parallel output is a vector $A^{-1}d^{T}$.

IV-C Module C: Systematic Encoding of Codes $E_{i}$

The module has a serial input of $q^{2}-\hat{a}(i)-1$ symbols and produce one symbol per clock cycle. The clocking frequency is $1/q$ of the overall clock rate.

IV-D Module D: Systematic Encoding of Codes $D_{l}$

Module D takes a serial input of length $l$ and produces as serial output a codeword of length $D_{l}$.

IV-E Encoder

Figure 1 outlines the overall implementation. When the left hand input becomes valid, the output of Module A is added to the negative output of Module C, effectively implementing steps 1 and 2 of Algorithm 3. The sum is fed to Module D which implements step 3 of Algorithm 3. The output of Module D is combined with the output of Module A to implement step 4 of Algorithm 3. Simultaneously it is fed to module B of the implementation. After $q$ clock cycles the output of Module B is added to the input thus implementing step 5 of Algorithm 3.

Module C can be implemented as an obvious modification of a systematic encoding circuits for RS codes [10].

Module D implements systematic encoding of a code with parity check matrix given by first $l$ rows of matrix $A^{-1}$. From the form of matrices $A^{-1}$, we see that code $D_{l}$ may be defined as

[TABLE]

and we can use standard encoding techniques for shortened cyclic codes which are modified in the obvious way.

V Final Remarks

A low complexity algorithm for systematic encoding and syndrome computation of Hermitian codes has been presented. The algorithm has a run time complexity of $O(n^{2/3})$ and is suitable for VLSI implementation. We give an outline for the encoder architecture, which uses as main blocks, $q$ varying-rate Reed Solomon encoders. The architecture achieves a much lower space complexity in terms of finite field multipliers and memory elements when compared to earlier reported works.

VI Acknowledgement

The authors would like to thank Science Foundation Ireland, Claude Shannon Institute and Deutsche Forschungsgemeinschaf for supporting parts of this research work.