This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

Low complexity encoder for generalized quasi-cyclic codes coming from finite geometries Vo Tam Van, Hajime Matsui, Seiichi Mita Dept. Electronics and Information Science Toyota Technological Institute 2–12–1 Hisakata, Tenpaku, Nagoya, 468–8511, Japan Email: {sd07501,hmatsui,smita}@toyota-ti.ac.jp Abstract—We define generalized quasi-cyclic (GQC) codes as linear codes with nontrivial automorphism groups. Therefore, GQC codes, unlike quasi-cyclic codes, can include many important codes such as Hermitian and projective geometry (PG) codes; this capability is important in practical applications. Further, we propose the echelon canonical form algorithm for computing Gr¨obner bases from their parity check matrices. Consequently, by applying Gr¨obner base theory, GQC codes can be systematically encoded and implemented with simple feedback shift registers. Our algorithm is based on Gaussian elimination and requires a sufficiently small number of finite-field operations, which is related to the third power of code-length. In order to demonstrate our encoder’s efficiency, we prove that the number of circuit elements in the encoder architecture is proportional to the code-length for finite geometry (FG) LDPC codes (a class of GQC codes). We show that the hardware complexity of a serialin-serial-out encoder architecture for FG-LDPC codes is related to the linear order of the code-length; less than 2n adder and 2n memory elements are required to encode a binary codeword of length n. Index Terms—automorphism group, Buchberger’s algorithm, division algorithm, circulant matrix, finite geometry low density parity check (LDPC) codes.

I. I NTRODUCTION Low-density parity-check (LDPC) codes were first discovered by Gallager [4] in 1962 and were rediscovered and generalized by MacKay [13] in 1999. The methods for constructing LDPC codes can be divided into random and algebraic construction methods. The performance of irregular LDPC codes with long code lengths greater than 107 bits constructed by random construction [2][13] has been observed to be close to the Shannon limit. However, the encoding of these LDPC codes is quite complex because of the lack of code structure such as cyclic or quasi-cyclic structure. Therefore, we concentrate on algebraic constructions of LDPC codes that belong to a class of quasi-cyclic (QC) codes. One remarkable algebraic method is based on finite geometry (FG) codes [7]; these codes are divided into Euclidean (or affine) geometry (EG) codes, which are included in QC codes, and projective geometry (PG) codes, which are included not in QC codes but in broader GQC codes (cf. Fig. 1). In short, GQC codes increase the randomness for QC codes and vary the length of each cyclic part in QC codes. For several classes of QC LDPC codes, some efficient encoding methods [3][9] that use circulant matrices and di-

vision techniques have been proposed. For GQC codes, which include algebraic LDPC codes, Heegard et al. [5] showed that systematic encoding was equivalent to the division algorithm based on Gr¨obner bases, which generalize the generator polynomials in cyclic codes. On the basis of this work, Chen et al. [1] constructed an encoder architecture. Thus, the encoding problem for GQC codes was transformed into the computation of Gr¨obner basis. To compute Gr¨obner bases for encoding GQC codes, et al. [8] and Lally et al. [8] presented algorithms for Hermitian codes and QC codes, respectively. However, no algorithm applicable to all GQC codes has been developed. We propose the echelon canonical form algorithm for computing Gr¨obner bases from their parity check matrices. A part of our algorithm for computing Gr¨obner bases was already known to some specialists in coding theory. Kamiya et al. [6] stated that an encoder was obtained with a fundamental row operation for a QC LDPC code from Euclidean geometry. Recently, Little [12] presented a similar result for a Hermitian code. Our aim is to present algorithms for computing the Gr¨obner bases for all GQC codes, even when column permutation is required. Although the size of the encoder architecture for general GQC codes exceeds the linear order of code-length because of the number of orbits (cyclic parts), Chen et al. [1] proved that it had the linear order for Hermitian codes. We present the first proof that it also has the linear order for FG codes. While the method of Richardson et al.’s [15] for general LDPC codes is of the linear order of finite-field operations, our encoder architecture for FG codes can achieve both the linear order of operations and the linear order of circuit elements without latency. Additionally, our encoder architecture for the binary FG LDPC codes requires only adder elements without multiplication (i.e., no AND element). This study deals with all GQC codes; Siap et al. [16] mainly focused on one-generator GQC codes. Another example of GQC codes is the class of algebraic geometry codes with automorphism groups [5], including Hermitian codes [11]. It is worth noting that GQC codes include two remarkable classes of Hermitian codes and some PG codes outside QC codes. Thus, GQC codes form the largest algebraic class of linear codes that supports compact encoder architectures. Therefore, we can choose more appropriate high-performance codes from among GQC codes than QC codes.

978-1-4244-3435-0/09/$25.00 ©2009 IEEE

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

Generalized quasi-cyclic (GQC) codes AG codes with Aut Hermitian codes

FG-LDPC codes Projective

Quasi-cyclic codes Array codes, etc

Euclidean

Random LDPC codes

Cyclic codes

Fig. 1.

Inclusion-exclusion relation of various linear codes.

This paper is organized as follows. In section 2, a definition of GQC codes and the techniques for computing Gr¨obner bases are presented. In section 3, the details of the echelon canonical form algorithm are presented. In section 4, the linearity of the encoder architecture with respect to the circuit-scale is proved for FG LDPC codes. The paper is concluded in section 5. II. G ENERALIZED QUASI - CYCLIC CODES AND ¨ BASES SYSTEMATIC ENCODING BASED ON G R OBNER In this section, we first present the definition and module structure of GQC codes. Then, we review the Gr¨obner basis of the modules over polynomial rings. Finally, we present a systematic encoding scheme for GQC codes by using Gr¨obner bases, as developed in [5]. A. Definitions Fqn

of length n, where q is Consider a linear code C ⊂ a prime power and Fq is a q-element finite field. Let S be the set of locations (i.e., coordinate positions) of codewords in C: C  c = (cs )s∈S . Without loss of generality, we set S = {1, 2, · · · , n}. Now, suppose there is a decomposition of S, m m   Oi , |S| = n = li , li := |Oi |, (1) S= i=1

i=1

and accordingly, any codeword c ∈ C is split into m shortened codewords: (2) c = (c1 , c2 , · · · , cm ), where ci is a shortened codeword obtained by removing components outside Oi . Consider simultaneous local cyclic shifts σ of each ci satisfying σ(c) := (σ(c1 ), · · · , σ(cm )), σ(ci ) := (ci,li −1 , ci,0 , · · · , ci,li −2 )

(3)

for ci = (ci,0 , ci,1 , · · · , ci,li −1 ). Definition 1: If m < n and σ(c) ∈ C for all c ∈ C, then we call a pair of C and σ a GQC code. 2 This, if C is GQC, we obtain a nontrivial σ of the automorphism group Aut(C) of C. Conversely, if Aut(C) includes σ = 1, then the cyclic group σ generated by σ defines the orbit O(s) := {σ l (s) | σ l ∈ σ} of s ∈ S. Note that we have O(s) = O(s ) for s ∈ O(s), and that we have O(s) = {s} if σ(s) = s. Then, S is equal to the disjoint union of distinct orbits, as described in (1), where Oi := O(si ) for some si ∈ S.

We can condider σ as the simultaneous shift (3) of {ci }. Thus, we have shown that the class of GQC codes is equivalent to the class of linear codes with nontrivial Aut(C) ⊃ σ. Remark 1: Siap et al. [16] define GQC codes as Fq [t]submodules of the module M in (4) in the next subsection, where we will show that their definition of GQC codes is equivalent to ours. Note that if l1 = l2 = · · · = lm , then C is a quasi-cyclic code [8][10]. Moreover, if m = 1, then we once again obtain a cyclic code. In order to increase the randomness of the codes, the ability to combine various circulant matrices to generate new GQC codes is desired. B. Module structure of generalized quasi-cyclic codes Let C be a GQC code with a permutation σ. Under the action of σ, we can decompose c ∈ C into m shortened codes as shown in (2). Pick ci and represent it as ci = (ci,j ) where j = 0, · · · , li − 1 with li := |Oi |. For convenience, the second index is assumed to be an integer modulo li , and the permutation σ of (3) represents σ(ci,j ) = ci,(j−1 mod li ) for all i = 1, · · · , m and j = 0, · · · , li − 1. Then, a codeword in C can be represented as an m-tuple of polynomials in Fq [t]: c = (c1 (t), c2 (t), · · · , cm (t)), where ci (t) =

li −1 j=0

ci,j tj . Thus, C is regarded as a linear

subspace of M , where M :=

m  

  Fq [t]/ tli − 1

(4)

i=1

  Fq[t]/ tli − 1  is the quotient ring by an ideal and tli − 1 := tli − 1 Fq [t]. Moreover, the action of σ can be regarded as the multiplication of t as follows: tci (t) =

l i −1 j=0

ci,j tj+1 ≡

l i −1

ci,j−1 mod li tj =

j=0

l i −1

σ(ci,j )tj ,

j=0

(5) where “≡” denotes equality modulo tli − 1 . It is clear that multiplying c by t is equivalent to locally and cyclically permuting the codeword by σ. Thus, C is closed under multiplication by t and C is considered an Fq [t]-submodule of M . For convenience in computing Gr¨obner basis, we consider the following natural map: π : Fq [t]m → M . Let ei be the i-th standard basis vector in the Fq [t]-module Fq [t]m , i.e., 



e1 := (1, 0, 0, · · · , 0), e2 := (0, 1, 0, · · · , 0), · · · , em := (0, 0, 0, · · · , 1), l  and Xi := t i − 1 ei for i = 1, · · · , m. Define C := π −1 (C), which is a submodule of Fq [t]m and is generated by all codewords in C (regarded as vectors in Fq [t]m ) and all Xi ’s: C = C + Xi | i = 1, · · · , m ,

(6)

where Xi | i = 1, · · · , m denotes the submodule generated by all Xi .

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

C. Gr¨obner basis of Fq [t]-module j

m

We call an element of the form t ei a monomial in Fq [t] . Then, any polynomial vector in Fq [t]m can be represented as a linear combination of monomials. Although the Gr¨obner basis of a submodule in Fq [t]m is determined for each monomial ordering, only the following ordering is required in this paper. The position over term (POT) ordering [5] on Fq [t]m is defined by tl ei >POT tk ej if i < j, or i = j and l > k. Then, we have e1 >POT e2 >POT · · · >POT em . Definition 2: We define the POT Gr¨obner basis of C as the following set G = {g1 , g2 , · · · , gm } of polynomial vectors g1 g2 .. .

= =

gm

=

(g11 (t), (0, .. . (0,

g12 (t), g22 (t), .. .

··· , ··· , .. .

g1m (t)), g2m (t)), .. .

··· ,

0,

gmm (t))

(7)

such that g1 , · · · , gm ∈ C and gii (t) has the minimum degree among the vectors of the form (0, · · · , 0, ci (t), · · · , cm (t)) ∈ C with ci (t) = 0. If gii ’s are monic and G satisfies deg gij < deg gjj for all 1 ≤ i < j ≤ m, then we call it a reduced POT Gr¨obner basis. 2 The Gr¨obner basis of C has two important functions: it generates C and and is used in the division algorithm (presented in the next subsection). Any element c ∈ C is of the following form: (8) c = P1 (t)g1 + · · · + Pm (t)gm , where Pi (t) ∈ Fq [t]. If deg(Pi gii ) < li for all i, then we have c ∈ C strictly. For the purposes of encoding, we define a redundant monomial as tj ei with 0 ≤ j < deg gii (t) (a standard monomial in [5]). The other types of monomials tj ei with deg gii (t) ≤ j < li are called non-redundant (or information) monomials. It follows from (8) that the number of information monomials equals the dimension of C. By minimizing deg gii , we can obtain G from the generator matrix. This procedure is called Buchberger’s algorithm. 2 D. Systematic encoding algorithm Once a Gr¨obner basis G = {g1 , · · · , gm } of C is obtained, the division algorithm with respect to G can be applied to u ∈ Fq [t]m to obtain the following representation: u = Q1 (t)g1 + · · · + Qm (t)gm + u,

(9)

where Qi (t) ∈ Fq [t], and u = (u1 (t), · · · , um (t)) with deg ui < deg gii . In other words, u is a unique linear combination of redundant monomials. It follows from (8) and (9) that u ∈ C ⇔ u = (0, · · · , 0), ; this generalizes the condition on codewords in cyclic codes. Then, the encoding of C is described as follows: Systematic encoding algorithm : Input: Information symbols u ∈ Fkq and Gr¨obner basis G = {g1 , · · · , gm }. Output: Encoded codeword c ∈ C. Step 1. Calculate u ∈ Fq [t]m as a linear combination of

information symbols and information monomials. Step 2. Set u1 = (u11 (t), · · · , u1m (t)) := u; For i = 1 to m; ⎡ Find Qi (t) and ui (t) such that ⎢ u (t) = Q (t)g (t) + u (t), deg u < deg g . ii i ii i i ii ⎢ ⎢ ⎣ Calculate ui+1 := ui − Qi (t)gi (∈ M ) = (u1 (t), · · · , ui (t), ui+1,i+1 (t), · · · , ui+1,m (t)). m Put u := (u1 (t), · · · , um (t)) = u − i=1 Qi (t)gi in M . Step 3. By subtraction c := u − u, and we obtain the encoded codeword c ∈ C. 2 Step 2 is called the division algorithm, which is a generalization of the classical polynomial division in the encoding of cyclic codes. Thus, another merit of the reduced Gr¨obner basis is that it reduces the computational complexity of the division algorithm. ¨ BASIS FROM PARITY CHECK III. C OMPUTING G R OBNER MATRIX WITH ECHELON CANONICAL FORM

In this section, we consider the computation of the Gr¨obner basis, which generates a GQC code from a given parity check matrix. Often, each GQC code C is specified by a parity check matrix, i.e., the generator matrix of its dual code C ⊥ . Since we have Aut(C) = Aut(C ⊥ ), both codes are considered submodules of the same M in (4). Before describing our algorithm, we point out that elementary row operations can be used to simplify a matrix and obtain an echelon canonical form [14]. For example, we consider the following matrices: ⎞ ⎛ ⎛ ⎞ 10111100 10100001 ⎜ 01100100 ⎟ ⎜ 01100100 ⎟ ⎟ ⎜ ⎜ ⎟ ⎜ 0 0 0 1 0 0 0 1 ⎟, ⎜ 1 0 1 0 1 1 1 0 ⎟. ⎟ ⎜ ⎜ ⎟ ⎝ 11010100 ⎠ ⎝ 00001100 ⎠ 00000011 01100111 The matrix on the left is the echelon canonical form of one on the right. By using the echelon canonical form, we can compute the Gr¨obner basis of C from the parity check matrix. The flow of our algorithm is as follows: Echelon canonical form algorithm : Input: Parity check matrix H of a GQC code C. Output: POT Gr¨obner basis G of C. Step 1. Transform H to an echelon canonical form H  by Gaussian elimination. Step 2. Select a permutation τ satisfying H1 := τ (H  ) = [I|A], and then set G1 := [−AT |I]. Step 3. Compute a generator matrix G = τ −1 (G1 ). Step 4. Obtain G from G by Buchberger’s algorithm. 2 In step 2 of the above algorithm, G1 satisfies the equations G1 × H1T = 0 and τ −1 (G1 ) × {τ −1 (H1 )}T = τ −1 (G1 ) × T H  = 0. Therefore, we permute the column vectors of G1 by τ −1 to obtain a generator matrix G of the GQC code C.

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

Example 1: Let C2 be a GQC code defined by the following parity check matrix H2 : ⎞ ⎛ 110110 101100 110 ⎜ 011011 010110 011 ⎟ ⎟ ⎜ ⎜ 101101 001011 101 ⎟ ⎟. ⎜ H2 := ⎜ ⎟ ⎜ 110110 100101 110 ⎟ ⎝ 011011 110010 011 ⎠ 101101 011001 101 We see that C2 has a locally cyclic property with the column permutation σ = (1 · · · 6)(7 · · · 12)(13 · · · 15); ; here, for example, (1 · · · 6) denotes the permutation 1 → 2 → · · · → 6 → 1. C2 has 3 orbits: l1 = l2 = 6 and l3 = 3. First, we use Gaussian elimination to transform H2 to the equivalent echelon canonical form ⎞ ⎛ 10 1101 0000 10101 ⎜ 01 1011 0000 11011 ⎟ ⎟ ⎜ ⎜ 00 0000 1000 11000 ⎟ ⎟ ⎜ (10) ⎜ 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 ⎟. ⎟ ⎜ ⎝ 00 0000 0010 01000 ⎠ 00 0000 0001 11000 If we choose the column permutation τ such that the set of column locations (1, 2, · · · , 14, 15) is mapped by τ to (1, 2, 7, 8, 9, 10, 3, 4, 5, 6, 11, 12, 13, 14, 15) , then the matrix (10) is transformed to the standard form matrix [I|A]: ⎞ ⎛ 10 0000 1101 10101 ⎜ 01 0000 1011 11011 ⎟ ⎟ ⎜ ⎜ 00 1000 0000 11000 ⎟ ⎟ ⎜ ⎜ 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 ⎟. ⎟ ⎜ ⎝ 00 0010 0000 01000 ⎠ 00 0001 0000 11000 Note that in this case, τ is not related to the orbit decomposition. Then, we permute the corresponding matrix [−AT |I] by τ −1 to obtain the generator matrix G2 of C2 . ⎞ ⎛ 111000 000000 000 ⎜ 100100 000000 000 ⎟ ⎟ ⎜ ⎜ 010010 000000 000 ⎟ ⎟ ⎜ ⎜ 110001 000000 000 ⎟ ⎟ ⎜ ⎟ G2 = ⎜ ⎜ 110000 110110 000 ⎟ ⎜ 010000 101101 000 ⎟ ⎟ ⎜ ⎜ 100000 000000 100 ⎟ ⎟ ⎜ ⎝ 010000 000000 010 ⎠ 110000 000000 001 By using Buchberger’s algorithm, we can compute the reduced POT Gr¨obner basis {g1 , g2 , g3 } of the generator matrix G2 : ⎤ ⎡ ⎤ ⎡ g1 1, 0, 1 ⎦. ⎣ g2 ⎦ = ⎣ 0, 1 + t + t3 + t4 , 1+t 2 g3 0, 0, 1+t+t 2 Although this example is binary, our algorithm can be applied to all parity check matrices H of Fq -entries.

IV. E STIMATION OF THE CIRCUIT In the previous sections, we proposed an algorithm to calculate a reduced Gr¨obner basis that generates an m-orbit GQC code C. In [1], Chen et al. have developed a serialin-serial-out hardware architecture to systematically encode information symbols with the POT Gr¨obner basis presented in Heegard et al. [5]. The architecture generalizes the classical encoder of cyclic codes and consists of circuits for division by gii (t) and multiplication with gij (t) (i < j). We quote the estimated hardware complexity for the above mentioned architecture from [1]. The total number of finitefield adder elements Am and memory elements (shift registers) Dm are given as Am ≤

m 

deg gii +

i=1

m  i=1

m 

(deg gij + 1)

i=1 j=i+1

≤ (n − k) + Dm ≤

m−1 

m−1 

(m − i) deg gii ≤ m(n − k),

i=1 m−1 

deg gii +

m 

i=1 j=i+1

deg gij +

m−1 

(δi + 1)

i=1

≤ m(n − k) + k, where δi := max (k1 − 2, k2 − 2, · · · , ki−1 − 2, ki − 1), and ki := li − deg gii . We conclude that the hardware complexity for GQC codes is nearly proportional to the code-length since m is small compared to n. For more practical estimation, we focus on FG LDPC codes [7] as an important class of GQC codes. These codes have good minimum distances and their Tanner graphs have a girth of 6. There are four classes of FG LDPC codes: 1) type-I EGLDPC codes, 2) type-II EG-LDPC codes, 3) type-I PG-LDPC codes, and 4) type-II PG-LDPC codes. Type-I EG-LDPC codes are defined as follows. Let EG(μ, 2s ) be a μ-dimensional Euclidean geometry where μ and s are two positive integers (see, e.g., [7][10]). This geometry consists of q µ points and q µ−1 (q µ − 1)/(q − 1) lines where q := 2s . Every point lies on (q µ − 1)/(q − 1) lines and every line contains q points. 1 be a parity check matrix whose rows are the Let HEG(µ,q) incidence vectors of J := (q µ−1 − 1)(q µ − 1)/(q − 1) lines in EG(μ, q) that do not pass through the origin (all-zero μtuple) and whose columns correspond to the q µ − 1 non-origin points in EG(μ, q). In this manner, we can associate with the 1 with parity check matrix EG(μ, q) plane the code CEG(µ,q) 1 HEG(µ,q) . 2 1 2 Let HEG(µ,q) = [HEG(µ,q) ]T . Then HEG(µ,q) is a matrix µ 2 with q − 1 rows and J columns. The null space of HEG(µ,q) gives an LDPC code and is called a type-II μ-dimensional EG1 LDPC code. For μ = 2, since the parity check matrix HEG(2,q) 1 2 is a square matrix, CEG(µ,q) and CEG(µ,q) are identical. For any positive integer s, the type-I 2-D EG-LDPC code has the

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

TABLE I A LIST OF COMMON TYPE -I AND TYPE -II EG LDPC CODES ; n AND k ARE THE CODE LENGTH AND INFORMATION SYMBOL , RESPECTIVELY. code type EG type-I 2-D, s = 2 ,s=3 ,s=4 ,s=5 EG type-I 3-D, s = 2 ,s=3 ,s=4 ,s=5 EG type-I 4-D, s = 2 ,s=3 ,s=4 EG type-II 3-D, s = 2 ,s=3 ,s=4 ,s=5 EG type-II 4-D, s = 2 ,s=3 ,s=4

n 15 63 255 1023 63 511 4095 32767 255 4095 65535 315 4599 69615 1081311 5355 298935 17891055

k 7 37 175 781 13 139 1377 13012 21 406 7761 265 4227 66896 1061555 5121 295245 17833281

n−k 8 26 80 242 50 372 2718 19755 234 3690 57774 50 372 2719 19756 234 3690 57774

code rate 0.467 0.587 0.686 0.763 0.206 0.272 0.336 0.397 0.082 0.099 0.118 0.841 0.919 0.961 0.982 0.956 0.988 0.997

following parameters [7][10]: Length Number of information bits Minimum distance Row weight Column weight

n = q2 − 1 k = n − 3s + 1 dmin = q + 1 wrow = q wcol = q

2 In general, for μ = 2, CEG(µ,q) is not cyclic but it can be put in quasi-cyclic form. The incidence vectors of all the lines that do not pass through the origin can be partitioned into K = (q µ−1 − 1)/(q − 1) cyclic classes or m = K orbits [7]. Some common EG-LDPC codes are given in Table I. Similarly, type-I PG LDPC codes are defined as follows. Let PG(μ, 2s ) be a μ-dimensional projective geometry where μ and s are two positive integers (see, e.g., [7][10]). This geometry consists of (q µ + · · · + q + 1) points and (q µ + · · · + q + 1)(q µ−1 + · · · + q + 1)/(q + 1) lines, where q := 2s . Every point lies on (q µ−1 + · · · + q + 1) lines and every line contains (q + 1) points. Let HP1 G(µ,q) be a parity check matrix whose rows are the incidence vectors of all the lines in the PG(μ, q) plane and whose columns correspond to all the points in PG(μ, q). Once again, we obtain a PG(μ, q)-based code CP1 G(µ,q) with parity check matrix HP1 G(µ,q) . Let HP2 G(µ,q) = [HP1 G(µ,q) ]T . Then HP2 G(µ,q) is a matrix with (q µ +· · ·+q +1) rows and (q µ−1 −1)(q µ−1 +· · ·+q +1) columns. The null space of HP2 G(µ,q) gives an LDPC code and is called a type-II μ-dimensional PG-LDPC code. For μ = 2, since HP1 G(2,q) is a square matrix, CP1 G(µ,q) and CP2 G(µ,q) are identical. With an arbitrary positive integer s, the type-I 2-D PG-LDPC code has the following parameters [7][10]:

Length Number of information bits Minimum distance Row weight Column weight

n = q2 + q + 1 k = n − 3s − 1 dmin = q + 2 wrow = q + 1 wcol = q + 1

TABLE II A LIST OF COMMON TYPE -I AND TYPE -II PG LDPC CODES ; n AND k ARE THE CODE LENGTH AND INFORMATION SYMBOL , RESPECTIVELY. code type PG type-I 2-D, s = 2 ,s=3 ,s=4 ,s=5 PG type-I 3-D, s = 2 ,s=3 ,s=4 ,s=5 PG type-I 4-D, s = 2 ,s=3 ,s=4 PG type-II 3-D, s = 2 ,s=3 ,s=4 ,s=5 PG type-II 4-D, s = 2 ,s=3 ,s=4

n 21 73 273 1057 85 585 4369 33825 341 4681 69905 357 4745 70161 1083425 5797 304265 17965585

k 11 45 191 813 24 184 1568 13824 24 184 1568 296 4344 67630 1063424 5507 299768 17897248

n−k 10 28 82 244 61 401 2531 20001 290 4497 68337 61 401 2531 20001 290 4497 68337

code rate 0.524 0.616 0.700 0.769 0.282 0.315 0.363 0.409 0.132 0.126 0.133 0.829 0.915 0.964 0.982 0.950 0.985 0.996

In general, for μ = 2, CP2 G(µ,q) is not cyclic but it can be put in a GQC form in a similar manner as the type-II EG-LDPC code [7]. Again, we have m = (q µ−1 − 1)/(q − 1) orbits. Some common PG-LDPC codes are given in Table II. We see that type-I FG LDPC codes actually comprise low-rate and cyclic LDPC codes (cf. Table I and Table II). Therefore, we concentrate on type-II FG LDPC codes: highrate codes and GQC codes. We denote by n and k  the corresponding values of type-I FG-LDPC codes. We have the following: 1) l1 ≤ l2 = · · · = lm (In fact, the inequality becomes an equality for EG codes.) 2) g11 = · · · = gm−1,m−1 = 1 and deg gmm = n − k 3) (n − k) = (n − k  ) < n = lm Therefore, the reduced POT Gr¨obner basis G = {g1 , · · · , gm } of type-II FG LDPC codes can be arranged as ⎤ ⎡ ⎤ ⎡ 1 0 ··· 0 g1m (t) g1 ⎥ ⎢ . .. ⎢ g2 ⎥ ⎢ 0 1 . .. g2m (t) ⎥ ⎥ ⎥ ⎢ ⎢ ⎥ ⎥ ⎢ .. . . ⎢ .. .. .. = ⎥, ⎥ ⎢ ⎢ . . 0 . . ⎥ ⎥ ⎢ . ⎢ ⎥ ⎣ gm−1 ⎦ ⎢ .. .. ⎣ . . 1 gm−1,m (t) ⎦ gm 0 ··· ··· 0 gmm (t) where deg gim < deg gmm = n − k. The information block u is represented as the vector u = (u1 (t), · · · , um (t)), where ⎧ li −1 ⎪ ⎪ ⎪ ui,j tj i = 1, · · · , m − 1, ⎨ j=0 ui (t) = lm −1  ⎪ ⎪ ⎪ um,j tj i = m. ⎩ j=n−k

The parity block u = (0, 0, · · · , 0, um (t)), where um (t) = n−k−1  um,j tj , is the remainder of u with respect to the j=0

reduced Gr¨obner basis G. The corresponding codeword is the subtracted vector u − u, which is obtained at the output of the

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE ICC 2009 proceedings

output

storage of multiplying

control signal

storage of

output

multiplying

output

dividing by

Fig. 2. Serial-in-serial-out architecture for type-II FG (EG and PG) LDPC codes. Information {ui,j } is the input, and the output is redundant parity bits {um,j }. The control signal is used to switch for feedback shift registers after entering u1,0 , · · · , u1,l1 −1 .

serial-in-serial-out architecture for FG-LDPC codes, shown in Fig. 2. The total number Am of adder elements for FG codes satisfies the inequality Am ≤ m(n − k) ≤ mlm ≤ 2n.

(11)

In the case of EG-LDPC codes, the size of all the orbits is equal; hence, mlm = n, and the number of adder elements Am is strictly bounded by n. Moreover, the total number Dm of required memory elements satisfies Dm ≤ mlm +

m−1 

li = (m − 1)lm +

i=1

m 

li ≤ 2n.

(12)

i=1

Thus, we have proved that the hardware complexity of FG LDPC codes is O(n). 2 In order to show our encoder’s efficiency, we present a comparison with a serial-in-serial-out systematic encoder implemented by brute-force matrix multiplication. The number of adder elements Am and number of required memory elements  for FG codes needed are Dm  Dm = 2n − k,

Am ≤ k(n − k).

For several codes obtained from 3-D EG-LDPC and PGLDPC, we present the results for the computational hardware complexity in Table III. see that the actual number of circuit elements is much less than the above estimate in the inequalities in (11) and (12) and that the complexity of our architecture is much less than that of the architecture involving brute-force systematic encoding by matrix multiplication. V. C ONCLUSIONS In this study, we prove that the class of GQC codes is equivalent to the class of linear codes with cyclic automorphism groups. Further, we present an algorithm for computing a Gr¨obner basis for constructing an efficient systematic encoder of GQC codes. Our algorithm can be used not only for binary GQC LDPC codes but also for non-binary GQC LDPC codes

TABLE III H ARDWARE COMPLEXITY FOR SEVERAL 3-D TYPE -II EG AND TYPE -II PG LDPC CODES . type of codes EG type-II 3-D, s = 1 ,s=2 ,s=3 ,s=4 PG type-II 3-D, s = 1 ,s=2 ,s=3 ,s=4 – : very large number.

n 21 315 4599 69615 35 357 4745 70161

Am 12 76 1681 46223 16 138 1846 43027

Dm 27 328 5769 113136 36 438 6396 110657

Am 50 4466 785276 – 130 8684 858980 –

 Dm 27 365 4971 72315 46 418 5146 72692

and linear codes with nontrivial automorphism groups. We also demonstrate that the hardware complexity of the serialin-serial-out systematic encoder is of the linear order of codelength for FG codes and FG LDPC codes. Additionally, our algorithm can search effective codes rapidly in the polynomial (third power) order of code-length. We believe that many new, optimum codes can be constructed by exploiting the structure of GQC codes and that our results in systematic encoding might be a key step in the practical implementation of these codes. R EFERENCES [1] J.-P. Chen, C.-C. Lu, “A serial-in serial-out hardware architecture for systematic encoding of Hermitian codes via Gr¨obner bases,” IEEE Trans. on Comm., vol.52, no.8, pp.1322-1331, Aug. 2004. [2] S.Y. Chung, G.D. Forney, T.J. Richardson, R.L. Urbanke, “On the design of low density parity check codes within 0.0045dB of the Shannon limit,” IEEE Comm. Lett. , vol.5, no.2, pp.58-60, Feb. 2001. [3] H. Fujita and K. Sakaniwa, “Some classes of quasi-cyclic LDPC codes: Properties and efficient encoding method,” IEICE Trans. Fundamentals, vol.E88-A, no.12, pp.3627-3635, Dec. 2005 [4] R. G. Gallager, “Low density parity check codes,” IRE Trans. Inf. Theory, vol.IT-8, pp.21-28, Jan. 1962. [5] C. Heegard, J. Little, K. Saints, “Systematic encoding via Gr¨obner bases for a class of algebraic geometric Goppa codes,” IEEE Trans. Inf. Theory, vol.41, no.6, pp.1752-1761, Nov. 1995. [6] N. Kamiya, E. Sasaki, “Design and implementation of high-rate QCLDPC codes,” (in Japanese) Proc. 2006 SITA, Hakodate, Hokkaido, Japan, pp.545-548, Nov. 2006. [7] Y. Kou, S. Lin, M.P.C. Fossorier, “Low density parity check codes based on finite geometries: A rediscovery and new results,” IEEE Trans. Inf. Theory, vol.47, no.7, pp.2711-2761, Nov. 2001. [8] K. Lally, P. Fitzpatrick, “Algebraic structure of quasi-cyclic codes,” Discrete Applied Mathematics, 111, pp.157-175, Jul. 2001. [9] Z. Li, L. Chen, L. Zeng, S. Lin, W.H. Fong “Efficient encoding of quasicyclic low density parity check codes,” IEEE Trans. Comm., vol.54, no.1, pp.71-81, Jan. 2006. [10] S. Lin, D.J. Costello, “Error Control Coding: Fundamentals and Applications,” 2nd ed. Englewood Cliffs, NJ: Prentice-Hall, 2004. [11] J. Little, K. Saints, C. Heegard, “On the structure of Hermitian codes,” Journal of Pure and Applied Algebra 121, pp.293-314, Oct. 1997. [12] J. Little, “Automorphisms and encoding of AG and order domain codes,” to appear in volume from D1 Workshop on applications of Gr¨obner bases in coding theory and cryptography, RISC-Linz, 2007. [13] D.J.C. MacKay, “Good error-correcting codes based on very sparse matrices,” IEEE Trans. Inf. Theory, vol.IT-45, no.2, pp.399-431, Mar. 1999. [14] W.W. Peterson, E.J. Weldon, “Error correcting codes,” 2nd ed. Cambridge, MA: MIT Press, 1972. [15] T.J. Richardson, R.L. Urbanke, “Efficient encoding of low density parity check codes,” IEEE Trans. Inf. Theory, vol.47, no.2, pp.638-656, Feb. 2001. [16] I. Siap, N. Kulhan, “The structure of generalized quasi-cyclic codes,” Applied Mathematics E-Notes, vol.5, pp.24-30, Mar. 2005.