IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1269
On Algebraic Construction of Gallager and CirculantLow-Density Parity-Check Codes
Heng Tang, Member, IEEE, Jun Xu, Member, IEEE, Yu Kou,Shu Lin, Life Fellow, IEEE, and Khaled Abdel-Ghaffar, Member, IEEE
Abstract—This correspondence presents three algebraic methods forconstructing low-density parity-check (LDPC) codes. These methods arebased on the structural properties of finite geometries. The first methodgives a class of Gallager codes and a class of complementary Gallagercodes. The second method results in two classes of circulant-LDPC codes,one in cyclic form and the other in quasi-cyclic form. The third method is atwo-step hybrid method. Codes in these classes have a wide range of ratesand minimum distances, and they perform well with iterative decoding.
Low-density parity-check (LDPC) codes were introduced by Gal-lager in early 1960s [1], [2]. After being overlooked for almost 35years, this class of codes has been recently rediscovered and shownto form another class of Shannon-limit approaching codes [3]–[13],besides turbo codes [14]. This class of codes decoded with an iterativesoft-input and soft-output decoding algorithm, such as the sum–productalgorithm (SPA) [9], [11], [13], [15]–[18], performs amazingly well.Long LDPC codes have been constructed and they perform only a fewtenths (or even a few thousandths [10]) of a decibel away from theirtheoretical Shannon limits.Ever since the rediscovery of LDPC codes, a great deal of research
effort has been expended in construction, decoding, performance anal-ysis, structural study, and applications of these remarkable codes. Var-ious methods for constructing LDPC codes have been proposed anddevised. Most, if not all, of these methods are combinatoric in na-ture. They can be classified into threemajor categories: graph-theoretic,geometric, and experimental design methods. The graph-theoretic ap-proach is by far the most popular one. With this approach, codes areconstructed based on random bipartite graphs, specific graphs, or con-strained paths of connected graphs [4], [7], [10]–[12], [19], [20]. Thegeometric approach is to construct regular LDPC codes based on thelines and hyperplanes of finite geometries over finite fields, such asEuclidean and projective geometries [13], [21]–[23]. The experimentaldesign approach is to construct LDPC codes based on combinatoric de-signs, especially balanced incomplete block designs [24]–[27].In this correspondence, we present three new combinatoric methods
for constructing LDPC codes. These methods are based on the struc-
Manuscript received November 14, 2001; revised January 29, 2004. Thiswork was supported by the National Science Foundation under Grants CCR-0096191, CCR-0117891, ECS-0121469, and by the National Aeronautics andSpace Administration under Grants NAG 5-10480 and 5-12789. The material inthis correspondence was presented in part at the IEEE International Symposiumon Information Theory, Lausanne, Switzerland, June/July 2002.H. Tang is with PMC-Sierra Inc., Portland, OR 97223 USA (e-mail:
[email protected]).J. Xu is with the Department of Mathematics, the University of Notre Dame,
Notre Dame, IN 46556 USA (e-mail: [email protected]).Y. Kou is with Marvell Semiconductor Inc., Sunnyvale, CA 94089 USA
(e-mail: [email protected]).S. Lin and K. Abdel-Ghaffar are with the Department of Electrical and
Computer Engineering, University of California, Davis, Davis, CA, 95616USA (e-mail: [email protected]; [email protected]).Communicated by R. Urbanke, Associate Editor for Coding Techniques.Digital Object Identifier 10.1109/TIT.2004.828088
tural properties of finite geometries. The first method of constructiongives a class of codes in Gallager’s original form, called Gallagercodes, and a class of codes associated with Gallager codes, calledcomplementary Gallager codes. The second method of constructionresults in two classes of LDPC codes whose parity-check matrices arein circulant form, called circulant-LDPC codes, one class in cyclicform and the other in quasi-cyclic form. The third construction isbased on a two-step hybrid method.This correspondence is organized as follows. The structural proper-
ties of the parity-check matrices of LDPC codes are defined in Sec-tion II. In Section III, we present a class of LDPC codes whose con-struction is based on partitioning the lines of an Euclidean geometryinto parallel bundles. The parity-check matrix of a code in this classhas exactly the same form as that proposed by Gallager [1], [2]. Sec-tion IV gives a class of LDPC codes associated with Gallager codes.Sections V and VI describe methods for constructing two classes ofLDPC codes based on partitioning the incidence vectors of lines inEuclidean and projective geometries into cyclic families. Parity-checkmatrices of codes in these two classes are arranged in circulant form.As a result, the codes in these two classes are either cyclic or can be putin a quasi-cyclic form. Section VII presents a two-step method for con-structing a class of hybrid finite-geometry LDPC codes. All the codesconstructed in Sections III–VII do not contain cycles of length four intheir Tanner graphs. Section VIII concludes the correspondence.
II. LDPC CODES
A binary regular LDPC code of length n is defined [1], [2] as thenull space of a sparse matrix H over GF (2) with the following struc-tural properties: 1) each row has constant weight �; 2) each column hasconstant weight ; 3) the number of 1-entries in common between anytwo rows (or two columns) is no greater than 1; and 4) both � and aresmall compared to the code length n. Since the rows and columns ofHhave constant weights � and , respectively,H is said to be ( ; �)-reg-ular. Property 3) ensures that the Tanner graph [28] of the code is freeof cycles of length four. For codes with such cycles in their Tannergraphs, iterative decoding becomes correlated after two iterations, anddecoding may not converge or may converge very slowly. In additionto the cycle structure, the performance of regular LDPC codes dependsalso on the minimum distance of the code. Since there are rows inHthat are orthogonal on each code bit, no columns ofH can be addedto zero [29], [30]. Therefore, the minimum distance of the code is atleast + 1. A reasonably large minimum distance is needed to guar-antee a low error floor. For practical applications, the choice of a codeis not only determined by its performance but also by implementationalcomplexity. It is desired to achieve encoding in linear time, i.e., withcomplexity linearly proportional to the code length.An LDPC code is said to be irregular if its parity-check matrix H
has varying column weights or varying row weights. For an irregularLDPC code, its performance with iterative decoding also depends onthe column and row weight distributions of its parity-check matrix.
III. GALLAGER CODES
Let k be a positive integer greater than 1. For any choice of �and , Gallager gave a general construction of a parity-check matrixHGA with the required structural properties given in Section II [2].Form a k � k� matrix over GF (2) which consists of submatricesH1; H2; . . . ; H . Each submatrix Hi is a k � k� matrix of rowweight � and column weight 1. Then no two rows in a submatrixhave any 1-entry in common and no two columns have more than one1-entry in common. The first submatrix H1 is constructed as follows:
1270 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004
for 1 � i � k, the ith row contains all its � 1-entries in columns(i � 1)� + 1 to i�. Then the other � 1 submatrices are simplyobtained by permuting the columns of H1. The overall parity-checkmatrix HGA of a Gallager code is given by
HGA =
H1
H2
...H
: (1)
The density of this matrix, defined as the ratio of the total number of1-entries in this matrix to its total number of entries, is 1=k. For a largek, the density of the matrix is low and hence it is a sparse matrix.Gallager did not provide any specific method for designing the �1
permutations to permute the columns of submatrixH1 to form the other �1 submatrices such that the matrixHGA meets the third property ofthe parity-checkmatrix given in Section II and the resultant LDPC codehas a good minimum distance. He simply suggested random permuta-tions of columns ofH1 to form the other �1 submatrices. For large kand small � and ,HGA is a very sparse matrix and the probability thatany two rows (or two columns) inHGA obtained by random permuta-tions of the columns of submatrix H1 have more than one 1-entry incommon is very small. Hence, with high probability,HGA meets all therequired properties. Gallager codes (especially long codes) are mostlygenerated by computers based on some design rules and guidelines toensure that their Tanner graphs do not contain short cycles.In the following, we present a specificmethod to construct a Gallager
code based on the parallel structure of lines in an Euclidean geometry.Form � 2, consider them-dimensional Euclidean geometry, denotedby EG (m; ps), over GF (ps)where p is a prime [30]–[33]. This geom-etry consists of n pms points and J p(m�1)s(pms� 1)=(ps� 1)lines. Each point is an m-tuple over GF (ps) and the all-zerom-tupleis called the origin of the geometry. Every line is either a one-dimen-sional subspace or a coset of a one-dimensional subspace of the vectorspace of all them-tuples over GF (ps). Each line consists of ps points.Two points are connected by one and only one line. Two lines are ei-ther disjoint or they intersect at one and only one point. For any pointin the geometry, there are (pms � 1)=(ps � 1) lines intersecting atthis point. Two parallel lines in the geometry EG (m; ps) correspondto two cosets of a one-dimensional subspace of the vector space of allthem-tuples overGF (ps). Since each one-dimensional subspace of thevector space of all the m-tuples over GF (ps) has p(m�1)s cosets (in-cluding the one-dimensional subspace itself), there are p(m�1)s linesin EG (m; ps) that are parallel to each other. These k p(m�1)s par-allel lines form a parallel bundle. Then the lines in EG (m;ps) can begrouped into K (pms � 1)=(ps � 1) parallel bundles, denoted byP1; P2; . . . ; Pk . Each parallel bundle contains all the pms points of thegeometry, every point appears once and only once.Number the points in EG (m;ps) from 1 to n = pms. The incidence
vector of a line L in EG (m;ps) is defined as an n-tuple over GF (2),vvvL = (v1; v2; . . . ; vn), where vi = 1 if and only if the ith point ofEG (m;ps) is on L [30], i.e., the incidence vector of a line displaysthe points on the line. For 1 � j � K , form a k � n matrix Hp(j)over GF (2), whose rows are the incidence vectors of the lines in thejth parallel bundle Pj and whose columns correspond to the n pointsof EG (m;ps). The matrix Hp(j) is the incidence matrix of the jthparallel bundle Pj . Each row ofHp(j) has weight � = ps. Notice thatn = k�. Since the p(m�1)s lines in each parallel bundle are disjointand they contain all the n = pms points in EG (m;ps), each column ofHp(j) contains one and only one “1.” For i 6= j,Hp(i) can be obtainedby permuting the columns of Hp(j). For 1 � � K , form a k � nmatrix HEG;GA(m;s; ) with Hp(1);Hp(2); . . . ; Hp( ) as its sub-matrices in the column form of (1). Then matrix HEG;GA(m;s; ) is
in the original Gallager’s parity-check matrix form for an LDPC code.The density of HEG;GA(m;s; ) is 1=k = p�(m�1)s, which can bemade very small by choosing m, s, and p properly. Since the rows ofHEG;GA(m;s; ) correspond to a set of lines in EG (m; ps), it followsfrom the structural properties of lines given above that no two rows(or two columns) in HEG;GA(m;s; ) have more than one 1-entry incommon. Therefore,HEG;GA(m;s; ) has all the structural propertiesrequired in the definition of an LDPC code.
The null space over GF (2) of HEG;GA(m;s; ) gives an LDPCcode of length n and rate at least (� � )=�, which we call aGallager Euclidean geometry-LDPC (EG-LDPC)code, denoted byCEG;GA(m;s; ). Since no two rows in HEG;GA(m;s; ) havemore than one 1-entry in common, the Tanner graph of the codedoes not contain cycles of length four. The minimum distance ofCEG;GA(m;s; ) is at least +1. For each choice ofm, s, and p, theabove construction based on the parallel bundles of lines in EG (m; ps)gives a sequence of Gallager EG-LDPC codes of length n = pms
for = 1; 2; . . . ; K . The codes in this sequence have various ratesand minimum distances. As increases, the code minimum distanceincreases but the code rate decreases.In the following, we give several examples to illustrate the construc-
tion of Gallager-LDPC codes. In computing the error performance, interms of the frame-error rate (FER) and the bit-error rate (BER), withiterative decoding using the SPA, we assume binary phase-shift keying(BPSK) transmission over an additive white Gaussian noise (AWGN)channel.
Example 1: Letm = s = 3 and p = 2. Consider the three-dimen-sional Euclidean geometry EG (3; 23) over GF (23). This geometryconsists of 512 points and 4672 lines. Each line consists of eight points.The 4672 lines can be grouped into 73 parallel bundles, each parallelbundle consists of 64 lines parallel to each other. For 1 � j � 73, wecan form a 64�512matrixHp(j)whose rows are the incidence vectorsof the lines in the jth parallel bundle Pj . This results in 73 matrices,one for each parallel bundle. The row and column weights of each ma-trixHp(j) are 8 and 1, respectively. For 1 � � 73, any selection of matricesHp(j)’s gives a matrixHEG;GA(3;3; ) of the form givenby (1). The null space of HG;GA(3;3; ) gives a Gallager EG-LDPCcode of length 512 with minimum distance at least + 1. By arbi-trarily choosing = 6 parallel bundles, we can construct a (512;256)code of rate 0:5. Its error performance with the SPA decoding is shownin Fig. 1. For comparison, the performance of the best computer gen-erated rate-1=2 MacKay code of about the same length from [34], a(504;252) code, is also included in Fig. 1. We see that the (512;256)Gallager EG-LDPC code slightly outperforms the (504;252) computergenerated code. 44
Example 2: This example gives two longer Gallager-Euclidean ge-ometry codes. The construction geometry is the two-dimensional Eu-clidean geometry EG (2; 26) over GF (26). This geometry consists of4096 points and 4160 lines. Each line consists of 64 points. The 4160lines of the geometry can be grouped into 65 parallel bundles, each con-sisting of 64 parallel lines. The incidencematrix of each parallel bundleis a 64 � 4096 matrix with column weight 1 and row weight 64. For1 � � 64, any choice of parallel bundles of lines in EG; (2; 26)gives a Gallager EG-LDPC code of length 4096 with minimum dis-tance at least + 1. Suppose we set = 8. Using the incidence ma-trices of eight parallel bundles of lines, we form a 512� 4096 matrixHEG;GA(2;6; 8) with column and row weights 8 and 64, respectively.The null space of this matrix gives a (4096;3687)Gallager EG-LDPCcode with rate 0:9 and minimum distance at least 9. The error perfor-mance of this code decoded with the SPA is shown in Fig. 2. At theBER of 10�5, it performs 1.3 dB from the Shannon limit. The code alsohas a good frame error performance. Suppose we set = 58. Using
IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1271
Fig. 1. Error performances of a Gallager EG-LDPC code based on six parallel bundles of EG(3; 23) and a computer generated MacKay code of Example 1.
the incidence matrices of 58 parallel bundles of lines in EG (2; 26), weform a 3712 � 4096 matrix HEG;GA(2; 6; 58) with column and rowweights 58 and 64, respectively. The null space of this matrix gives a(4096;3373)Gallager EG-LDPC code with rate 0:8235 and minimumdistance at least 59. Its BER with the SPA decoding is shown in Fig. 3with various numbers of iterations. We see that the decoding convergesvery fast. The performance gap between five iterations and 100 iter-ations is less than 0.2 dB. Since the code has a very large minimumdistance, if error floor exists it should be at a very low BER. 44
Given the parity-check matrix HEG;GA(m; s; ) of a GallagerEG-LDPC code, the column/row splitting technique proposed byKou, Lin, and Fossorier [13] can be used to generate new LDPCcodes. Column splitting is performed by replacing each column in theparity-check matrix by a number of columns and distributing the 1’sin the original column among the new columns in a rotating manner.Row splitting is performed in a similar way on rows rather than oncolumns.
Example 3: Consider the parity-check matrix HEG;GA(2;6; 8)constructed from the Euclidean geometry EG (2; 26) given in Example2. Suppose we split each column of the matrix into two columns ofweight 4 and split each row of the matrix into four rows of weight16. The column and row splittings result in a 2048 � 8192 regularmatrix H with column and row weights, 4 and 16, respectively. Sincethe Tanner graph of HEG;GA(2;6; 8) is free of cycles of length 4, theTanner graph ofH is also free of cycles of length 4. The null space ofH gives an (8192;6174) regular LDPC code with rate 0:7537 whoseerror performance with the SPA decoding is shown in Fig. 4. At theBER of 10�5, the code performs 1.25 dB from the Shannon limit andhas no error floor down to the BER of 10�8. It also has a very goodframe error performance and there is no error floor down to the FERof 10�6. 44
The lines of a projective geometry do not have the simple parallelstructure of the lines of an Euclidean geometry. As a result, LDPCcodes in Gallager form cannot be constructed from projective geome-tries.
IV. COMPLEMENTARY GALLAGER EUCLIDEAN GEOMETRY-LDPCCODES
Associated with each Gallager EG-LDPC code, there is a comple-mentary Gallager-LDPC (CG_LDPC) code. Let HEG;CG(m; s; ) bethe transpose of HEG;GA(m;s; ). Then HEG;CG(m;s; ) is an n �k matrix. The rows of this matrix correspond to the n = pms pointsof EG (m;ps) and its columns correspond to the lines in a set of parallel bundles. The row and column weights of HEG;CG(m;s; )are and �, respectively. This matrix has the same rank and densityas those of HEG;GA(m;s; ) and it has all the structural propertiesrequired for the parity-check matrix of an LDPC code given in Sec-tion II. Therefore, the null space ofHEG;CG (m; s; ) gives an LDPCcode. We call this code a complementary Gallager EG-LDPC code, de-noted byCEG;CG(m;s; ). The length of this code is k = p(m�1)s.For < ps, there are more rows in HEG;CG(m;s; ) than columns.In this case, the rate of the complementary Gallager EG-LDPC codeCEG;CG(m;s; ) may be very low. Therefore, to construct a high-ratecomplementary Gallager EG-LDPC code, we have to choose a large .For a given choice of m, s, and p, we can construct a sequence of
complementary Gallager EG-LDPC codes of increasing lengths andrates as increases to K = (pms
� 1)=(ps � 1). All codes haveminimum distances at least ps + 1.
Example 4: For m = s = 3 and p = 2, the three-dimensionalEuclidean geometry EG(3; 23) consists of 4672 lines. The 4672 lines
1272 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004
Fig. 2. Error performance of a Gallager EG-LDPC code based on eight parallel bundles of EG (2; 26) of Example 2.
Fig. 3. Decoding convergence of a Gallager EG-LDPC code based on 58 parallel bundles of EG (2; 26) of Example 2.
IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1273
Fig. 4. Error performance of a Gallager EG-LDPC code based on eight parallel bundles of EG (2; 26) with column and row splitting of Example 3.
can be grouped into 73 parallel bundles, each parallel bundle consists of64 lines, and each line consists of 8 points. Suppose we choose = 60.Then the parity check matrixHEG;CG(3; 3; 60) of the complementaryGallager EG-LDPC code with = 60 is a 512� 3840 regular matrixwith column weight 8 and row weight 60. The null space of this matrixgives a (3840;3467) complementary Gallager EG-LDPC code withrate 0:903 and minimum distance at least 9. The error performance ofthis code with the SPA decoding is shown in Fig. 5. At a BER of 10�5,the code performs 1.2 dB from the Shannon limit. 44
V. CIRCULANT EUCLIDEAN GEOMETRY LDPC CODES
For an n-tuple vvv = (v1; v2; . . . ; vn) over GF (2) and a nonegativeinteger i, let vvv(i) = (vn�i+1; vn�i+2; . . . ; vn; v1; . . . ; vn�i) be theith cyclic shift of vvv. It is clear that vvv(0) = vvv(n) = vvv. An n-tuple vvv issaid to have a cycle span of � if � is the smallest positive integer suchthat vvv(�) = vvv. It can be easily proved that � divides n. An n-tuple issaid to be primitive if its cycle span is n. A primitive n-tuple and itsn� 1 cyclic shifts give n different n-tuples. For a primitive n-tuple vvv,we can form an n � n square matrix whose rows are vvv and its n � 1cyclic shifts vvv(1); vvv(2); . . . ; vvv(n�1). The first row is vvv and then everyrow in the matrix is the cyclic shift of the row above it and the firstrow is the cyclic shift of the last row. Such a square matrix is calleda circulant matrix (or simply circulant). The null space of a circulantgives a cyclic code [30], [35].In the following, we present a method for constructing two classes
of LDPC codes based on the cyclic structure of lines in Euclidean andprojective geometries. The parity-check matrices of these two classesof codes are in circulant form. We call these codes circulant-LDPCcodes. We begin with the construction of circulant-LDPC codes basedon Euclidean geometries in this section.
Consider the m-dimensional Euclidean geometry EG (m; ps) overGF (ps) realized by the Galois field GF (pms) [30], [31], [33]. In thisrealization, the points of the geometry correspond to the elements ofGF (pms). The origin of the geometry is the point corresponding tothe zero element of the Galois field. This geometry consists of n0pms�1 nonorigin points and J0 (p(m�1)s�1)(pms�1)=(ps�1)lines that do not pass through the origin of the geometry. Let ! be aprimitive element of GF (pms). We number the n0 nonorigin points inEG (m;ps) such that for 0 � i � n0 � 1 = pms � 1, !i representsthe ith nonorigin point of the geometry.Let L be a line in EG (m;ps) that does not pass through the origin.
The incidence vector of this line is defined as an n0-tuple over GF (2),vvvL = (v1; v2; . . . ; vn ), whose components correspond to the n0nonorigin points of EG (m;pms), and for 1 � j � n0, vj = 1 if andonly if the point !j�1 of EG; (m;ps) is on L [30]. The incidencevector of a line in EG (m;ps) not passing through the origin has thefollowing structural properties: 1) it is a primitive n0-tuple with cyclespan n0 (see the Appendix) and 2) any cyclic shift of this incidencevector is the incidence vector of another line in EG(m;ps) not passingthrough the origin. Based on these structural properties, the incidencevectors of all the J0 lines in EG (m; ps) not passing through the origincan be partitioned into K0 (p(m�1)s � 1)=(ps � 1) cyclic classes,denoted by Q1; Q2; . . . ; QK [13]. Each of these K0 cyclic classesconsists of n0 different incidence vectors, each vector in the classcan be obtained by cyclically shifting any other vector in the class.Therefore, each incidence vector in a cyclic class can be used as therepresentative of the class and to generate the other vectors in the class.For 1 � i � K0, we form an n0 � n0 matrix Hc(i) whose rows
are simply the incidence vectors of lines in the ith cyclic classQi. ThematrixHc(i) is arranged in circulant form as described above such thateach row of Hc(i) is the cyclic shift of the row above it. The row andcolumn weights ofHc(i) are both ps. In fact, the set of columns is the
1274 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004
Fig. 5. Error performance of a complementary Gallager EG-LDPC code based on 60 parallel bundles of EG (3; 23) of Example 4.
same as the set of rows, read from right to left. Based on the struc-tural properties of lines in EG (m; ps), no two rows (or two columns)in either the same matrixHc(i) or in two different matricesHc(i) andHc(j) can have more than one 1-entry in common. Using theseK0 cir-culant matrices,Hc(1); . . . ; Hc(K0), we can construct two sequencesof LDPC codes whose Tanner graphs is free of cycles of length 4.
A. Class-I Circulant EG-LDPC Codes
For 1 � q � K0, form an n0 � qn0 matrix as follows:
which consists of circulantsHc(1);Hc(2); . . . ; Hc(q) as submatrices.Therefore, the columns of matrix H(1)
EG;c(m;s; q) correspond to a setof qn0 lines in EG (m;ps) not passing through the origin. The row andcolumn weights of H(1)
EG;c(m; s; q) are qps and ps, respectively. Thedensity of this matrix is ps=(pms
�1) � p�(m�1)s, which can bemadevery small by choosingm, s, and p properly. It follows from the struc-tural properties of lines in EG (m;ps) and the circulants Hc(i)’s thatno two rows (or two columns) of this matrix havemore than one 1-entryin common. Therefore,H(1)
EG;c(m;s; q) is a regular low-density matrixwhich has all the required structural properties of the parity-check ma-trix for an LDPC code defined in Section II. The null space over GF (2)of H(1)
EG;c(m;s; q) hence gives an LDPC code of length qn0, denoted
by C(1)EG;c(m;s; q) and called a Class-I circulant EG-LDPC code. The
Tanner graph of C(1)EG ;c(m; s; q) does not contain cycles of length 4
and the minimum distance of the code is at least ps + 1.The class-I circulant EG-LDPC code C(1)
EG;c(m;s; q) can be put in
quasi-cyclic form by rearranging the columns of H(1)EG;c(m;s; q). For
1 � j � n0, form an n0�q matrixHqc(j)whose ith column, for 1 �i � q, is the jth column of the circulant matrixHc(i). We can readily
see that the columns ofHqc(j) are simply the downward cyclic shifts ofthe q columns ofHqc(1) by j places. Then, the matrixH
(1)EG;c(m;s; q)
can be put in the form [Hqc(1);Hqc(2); . . . ; Hqc(n0)]. Each row ofH
(1)EG;c(m;s; q) is a q-bit cyclic shift of the row above it. The null space
of H(1)EG;c(m;s; q) is a quasi-cyclic code [13]. Cyclically shifting the
components of a codeword q places to the right results in another code-word in the code.For 1 � q � K0, any selection of q circulants from the set
Hc(1);Hc(2); . . . ; Hc(K0) results in a class-I circulant EG-LDPCcode. Therefore, for a given choice ofm, s, and p, we can construct asequence of class-I circulant EG-LDPC codes with q = 1; 2; . . . ; K0.As q increases, both the code length and rate increase but the minimumdistance (the lower bound ps + 1) of the code remains the same.For q = 1, the first code in the sequence C(1)
EG;c(m;s; 1) is the nullspace of a single circulant, say Hc(1). Since each row in Hc(1) is acyclic shift of the row above it, C(1)
EG;c(m;s; 1) is a cyclic code andhence it is characterized by its generator polynomial [30], [35]. Eachrow in Hc(1) can be represented by a polynomial of X with degreen0 � 1 = pms
� 2 or less. Let hhh(1)(X) be the greatest commondivisor (GCD) of the polynomials representing the rows ofHc(1). Letr be the degree of hhh(1)(X). Then
ggg(X) = (X(p �1)� 1)=Xrhhh(1)(X�1)
is the generator polynomial of C(1)EG;c(m;s; 1).
Example 5: Consider the geometry EG (3; 23) given in Example 4.This geometry has 4599 lines not passing through the origin. The inci-dence vectors of these lines can be partitioned into nine cyclic classes,each class consists of 511 incidence vectors. Therefore, nine 511�511circulants can be formed. Both row and columnweights of each of these
IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1275
Fig. 6. Error performance of a class-I circulant EG-LDPC code based on eight circulants of EG (3; 23) of Example 5.
nine circulants are 8. Suppose we set q = 8. Using eight of these cir-culants, we form a 511�4088matrixHEG;c(3; 2; 8)with column androwweights 8 and 64, respectively. The null space of this matrix gives a(4088;3716) circulant EG-LDPC code with rate 0:909 and minimumdistance at least 9. The error performance of this circulant code withthe SPA decoding is shown in Fig. 6. At a BER of 10�5, it performs1.2 dB from the Shannon limit. 44
B. Class-II Circulant EG-LDPC Codes
Let H(2)EG;c(m; s; q) be the transpose of the matrix H(1)
EG;c(m;s; q)
given by (2). ThenH(2)EG;c(m;s; q) is a qn0�n0 matrix. It has the same
rank and density as those ofH(1)EG;c(m;s; q).H(2)
EG;c(m;s; q) is also anLDPC matrix and hence its null space gives an LDPC code of lengthn0 = pms�1, denoted byC(2)
EG;c(m;s; q) and called the class-II circu-
lant EG-LDPC code. Since a cyclic shift of a row inH(2)EG;c(m;s; q) is
also a row in the matrix, C(2)EG;c(m;s; q) is a cyclic code. Study shows
that there are cases for which all choices of q with 1 � q � K0 givethe same code, i.e.,
C(2)EG;c(m;s; 1) = � � � = C
(2)EG;c(m;s;K0) = C:
In these cases, each circulant matrixHc(i) contains a base whose nullspace isC . For a given choice of q, the matrixH(2)
EG;c(m;s; q) has qn0rows which give qn0 check sums for SPA decoding. Consequently, wecan decode the code C with different numbers of check sums whichresult in different error performances and require different computa-tional complexities. Larger q requires larger computational complexitybut gives better error performance. Therefore, various q’s offer varioustradeoffs between error performance and decoding complexity.It is possible to obtain different class-II circulant EG-LDPC codes
for different q’s by splitting the columns of the parity-check matrix
H(2)EG;c(m;s; q) as explained before Example 3. Column splitting does
not change the row weight. Hence, the row weight of the new matrixis still ps. The null space ofH(2)
EG;ext(m; s; q) gives an LDPC code oflength of n0ps which is quasi-cyclic.
Example 6: For m = 3, s = 4, and p = 2, the three-dimensionalEuclidean geometry EG (3; 24) consists of 69 615 lines that do not passthrough the origin. The incidence vectors of these lines can be par-titioned into 17 cyclic classes, each class consists of 4095 incidencevectors. Based on these 17 cyclic classes, we can form 17 4095�4095circulant matrices. The rank of each of these 17 circulants is 2718. For1 � q � 17, any selection of q circulants gives the same (4095;1377)class-II circulant EG-LDPC code. This code can be decoded with SPAdecoding based on different numbers of check sums. This results indifferent computational complexities and different error performances.To generate different codes for different q’s, we split the columns ofthe parity-check matrix H(2)
EG;c(3;4; q). Suppose we choose q = 4
and split each column of H(2)EG;c
(3;4; 4) into 16 columns. We obtain
a new matrix H(2)EG;ext(3; 4; 4) with 65 520 columns. The column and
row weights of this new matrix are 4 and 16, respectively. The nullspace of the new matrix gives a (65520;49140) extended class-II cir-culant EG-LDPC code with rate 0:75 whose error performance withSPA decoding is depicted in Fig. 7. At a BER of 10�5, it performs only0.9 dB away from the Shannon limit. Next, suppose we choose q = 6
and split each column of H(2)EG;c(3;4; 6) into 32 columns. We obtain
a new matrix H(2)EG;ext(3; 4; 6) with 131 040 columns and column and
row weights of 3 and 16, respectively. The null space of this matrixgives a (131040;106470) extended class-II circulant EG-LDPC codewith rate 0:8125 whose error performance with SPA decoding is de-picted in Fig. 7. At a BER of 10�5, it performs only 0.7 dB away fromthe Shannon limit. The error performances of two computer generated(65520;49140) and (131040;106470) codes whose parity-check ma-
1276 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004
Fig. 7. Error performances of two class-II circulant EG-LDPC codes based on four and six circulants of EG (3; 24) with column splitting and two computergenerated codes of Example 6.
trices have column weights 4 and 3, respectively, are also includedin the figure for comparison. The class-II circulant EG-LDPC codesslightly outperform the computer generated codes. 44
VI. CIRCULANT PROJECTIVE GEOMETRY LDPC CODES
Circulant LDPC codes can also be constructed from projective ge-ometries [30], [31], [33]. Since there are some differences between aprojective geometry and an Euclidean geometry, the construction ofcirculant projection geometry-LDPC (PG-LDPC) codes is slightly dif-ferent from that of circulant EG-LDPC codes.For m � 2, consider the m-dimensional projective geometry
PG (m;ps) over GF (ps), which consists of
n1 (p(m+1)s� 1)=(ps � 1)
points and
J1(pms � 1)(p(m+1)s � 1)
(p2s � 1)(ps � 1)(3)
lines [30]–[33]. Each line in PG (m; ps) consists of ps+1 points. Twolines in PG (m; ps) either do not have any points in common or theyintersect at one and only one point. Any two points in PG (m; ps) areconnected by one and only one line in PG (m;ps). For each point inPG (m;ps), there are (pms � 1)=(ps � 1) lines that intersect at thispoint. The points of PG (m;ps) can be represented by n1 elements ofGF (p(m+1)s) (see [30, Sec. 8.3]). The incidence vector of a line inPG (m;ps) has weight ps + 1. The cyclic structure of the incidencevectors of the lines in PG (m;ps) depends on whether m is even orodd (see the Appendix). For evenm, the incidence vector of each linein PG (m; ps) is primitive and the incidence vectors of the J1 lines canbe partitioned intoK1 (pms�1)=(p2s�1) cyclic classes, each classconsists of n1 incidence vectors which can be obtained by cyclically
shifting any vector in the class. However, for odd m � 3, it is shownin the Appendix that there are � = (p(m+1)s � 1)=(p2s � 1) linesin PG (m;ps) whose incidence vectors are nonprimitive. The incidentvectors of all the other lines are primitive. The set of these � nonprim-itive incidence vectors can be obtained by cyclically shifting any non-primitive incidence vector in the set � times. The cycle span of each ofthese � nonprimitive incidence vectors is �. The ps + 1 nonzero com-ponents of each of these � nonprimitive incidence vectors are equallyseparated by ��1 zeros (including end-around zeros). Removing these� nonprimitive incidence vectors, there are
J2 (p(m+1)s� 1)(p(m�1)s � 1)ps=(p2s � 1)(ps � 1)
primitive incidence vectors of lines in PG(m;ps). These J2 primitiveincidence vectors can be partitioned into
K2 ps(p(m�1)s � 1)=(p2s � 1)
cyclic classes, each class consisting of n1 primitive incidence vectorsof lines in PG (m; ps).Based on the cyclic classes of incidence vectors of lines in
PG (m; ps), we can construct two classes of circulant PG-LDPC codesjust like the construction of circulant EG-LDPC codes described inSection V. For 1 � q � K1 (for even m) or K2 (for odd m), we canconstruct either a class-I or a class-II circulant PG-LDPC code usingq circulant matrices constructed based on q cyclic classes of incidencevectors of lines in PG (m; ps). A class-I circulant PG-LDPC code canbe put in quasi-cyclic form and a class-II circulant PG-LDPC code canbe put in cyclic form. Let C(1)
PG;c(m; s; q) and C(2)PG;c(m;s; q) denote
the two classes of circulant PG-LDPC codes, respectively. Class-Icode C(1)
PG;c(m;s; q) has length qn1 and minimum distance at least
ps+2. For q = 1, the class-I circulant PG-LDPC codeC(1)PG;c(m;s; 1)
IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1277
Fig. 8. Error performance of a class-I circulant PG-LDPC codes based on six circulants of EG (3; 23) of Example 7.
is cyclic. There are cases in which for q = 1; 2; . . . ; K1 (or K2), allthe class-II circulant PG-LDPC codes are the same code. To obtaindifferent class-II circulant PG-LDPC codes for different q’s, we canperform column splitting of the parity-check matrices as described forclass-II circulant EG-LDPC codes.
Example 7: Let m = s = 3 and p = 2. Consider the three-di-mensional projective geometry PG (3; 23) over GF (23). This geom-etry consists of 585 points and 4745 lines. The incidence vector of aline in PG (3; 23) is a 585-tuple of weight 9. There are 65 lines whoseincidence vectors are nonprimitive. The incidence vectors of the other4680 lines are primitive and they can be partitioned into eight cyclicclasses. Each of these eight cyclic classes consists of 585 incidencevectors. Form eight 585� 585 circulant matrices based on these eightcyclic classes. The row and column weights of each of these eight cir-culant matrices are both 9. For any 1 � q � 8, we can construct aclass-I circulant PG-LDPC code of length 585q with minimum dis-tance at least 10 by using q circulant matrices as submatrices to form a585� 585q parity-check matrix as given in (2). Set q = 6. Using sixcirculants we form a 585 � 3510 matrix HPG;c(3; 3; 6) with columnand row weights 9 and 54, respectively. The null space of this matrixgives a (3510;3109) class-I circulant PG-LDPC codewith rate 0:8858.Its error performance with SPA decoding is shown in Fig. 8. At a BERof 10�5, it performs 1.2 dB from the Shannon limit. 44
VII. HYBRID GEOMETRY LDPC CODES
In the last four sections, we have shown that we can construct LDPCcodes from either parallel bundles or circulants of lines of finite ge-ometries. In this section, we show that it is possible to construct LDPCcodes by combining parallel bundles and circulants of lines of finitegeometries together. This hybrid construction results in a large class ofLDPC codes.
Let B = [bi;j ] be an n1 � n1 circulant constructed from anm1-di-mensional Euclidean geometry EG (m1; p
s1 ), where n1 = p
m s1 �1.
Both the column and row weights are � = ps1 . Let H1; H2; . . . ; H�
be a set of � incidence matrices of � parallel bundles of lines fromanm2-dimensional Euclidean geometry EG (m2; p
s2 ). Each incidence
matrix Hj is a k2 � n2 matrix, where k2 = p(m �1)s2 and n2 =
pm s2 . The column and row weights ofHj are 1 and p
s2 , respectively.
Replacing the 1-entries of the first row of B by the incidence matricesH1; . . . ; H� , and all the 0-entries by k2�n2 zero matrices, we obtaina row of n1 submatrices of size k2 � n2, [G1; G2; . . . ; Gn ], whereGt is either an incidence matrix Hj with 1 � j � � or a zero ma-trix. Cyclically shifting the row matrix [G1; G2; . . . ; Gn ] to the rightn1 � 1 times, we obtain the following n1 � n1 array of matrices ofGi’s:
M =
G1 G2 � � � Gn
Gn G1 � � � Gn �1
......
. . ....
G2 G3 � � � G1
which is an n1k2 � n1n2 matrix with column and row weights � and�p
s2 , respectively. Basically,M is obtained by replacing the 1-entries
ofB with the incidence matricesH1; . . . ; H� in a cyclic manner. Thisreplacement is called cyclic replacement. It is clear that all the nonzeromatrices in a row or in a column of M are all distinct. Since no four1-entries are at the four corners of a rectangle in B, no four nonzerosubmatrices are at the four corners of a rectangle in the arrayM . Thisimplies that no two rows (or two columns) ofM have more than one1-entry in common. Therefore, the Tanner graph ofM has no cycles oflength 4. Since B’s and Hj ’s are sparse matrices, M is also a sparsematrix. Then the null space of M gives a quasi-cyclic LDPC code oflength n1n2 with minimum distance at least �+1, whose Tanner graph
1278 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004
Fig. 9. Error performance of the hybrid EG-LDPC code of Example 8.
is free of cycles of length 4. This code is called a hybrid EG-LDPCcode. In this hybrid construction, B is called the base matrix and theincidence matrices Hj ’s are called the constituent matrices. Note thatin construction, the base and constituent matrices can be constructedfrom the same Euclidean geometry, and furthermore the base matrixcan be constructed from a projective geometry.
Example 8: Let the base matrixB be the circulant constructed fromthe geometry EG (2; 5). ThenB is a 24�24 circulant with both columnand row weights 5. To replace the 1-entries in B, we use the incidencematrices H1; . . . ; H5 of five parallel bundles of lines from EG (3; 23)given in Example 4. Each Hi is a 64 � 512 matrix with column androw weights 1 and 8, respectively. Replacing the 1-entries of B by theincidence matrices H1; . . . ; H5, with cyclic replacement, we form a24 � 24 array M of 64 � 512 matrices, which is a 1536 � 12288matrix with column and row weights 5 and 40. The null space of Mgives a (12288;10752) quasi-cyclic hybrid geometry LDPC code withrate 0:875. Its error performance with SPA decoding is shown in Fig. 9.At a BER of 10�5, it performs 1.0 dB from the Shannon limit. 44
VIII. CONCLUSION
In this correspondence, three methods for constructing regularLDPC codes have been presented. These methods are devised basedon the parallel and cyclic properties of the lines of Euclidean andprojective geometries, and they result in five classes of LDPC codeswith various lengths, rates, and minimum distances. Among these fiveclasses of codes, three classes are either cyclic or quasi-cyclic. Cyclicor quasi-cyclic LDPC codes have encoding advantage over other typesof LDPC codes. Their encoding can be implemented using simpleshift registers with complexity linearly proportional to the number ofparity bits.
APPENDIX
Let vvv be the incidence vector of a line in a finite (Euclidean or pro-jective) geometry (not passing through the origin for an Euclidean ge-ometry). Let n, w, and � be the length, the weight, and the cycle spanof vvv, respectively. If � < n, then we will argue that
w� = n: (4)
Indeed, consider the matrix V whose rows are vvv; vvv(1); . . . ; vvv(��1) inthis order. Since the span of vvv is �, the columns in V are cyclic shiftsof each other and, in particular, all columns have the same weight. Toprove (4), it suffices to show that each column has weight 1 since, inthis case, both w� and n give the number of “1-entries” in V .Suppose, to get a contradiction, that the jth column of V has weight
greater than 1. Then, for some 0 � i1 < i2 < �, the jth componentsof vvv(i ) and vvv(i ) are both equal to 1, i.e., v(i )
j = v(i )j = 1. Since
both vvv(i ) and vvv(i ) have span �, then v(i )j+� = v
(i )j+� = 1, where the
subscript indexes are reduced modulo n. As � < n, it follows thatj+ � is not congruent to j modulo n. This implies that the lines whoseincidence vectors are vvv(i ) and vvv(i ) intersect at more than one point,contradicting the structure of the geometry, and proving (4).In the Euclidean geometry EG (m; ps), each line not passing through
the origin has an incidence vector of length pms � 1 and weight ps.Since these two numbers are relatively prime, it follows from (4) that allsuch incidence vectors are primitive. The same conclusion holds for theprojective geometry PG (m;ps) where m is even since the incidencevectors of lines have length n1 = (p(m+1)s � 1)=(ps� 1) and weightps + 1. These two numbers are relatively prime for even values ofm.Finally, consider the projective geometry PG (m;ps), where m is
odd. Again, incidence vectors of lines have length n1 = (p(m+1)s �
1)=(ps � 1) and weight ps + 1. However, notice that sincem is odd,
IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 50, NO. 6, JUNE 2004 1279
ps + 1 divides n1. Suppose that vvv is the incidence vector of a lineof cycle span � < n1. Let xmax be the maximum number of zerosbetween two cyclically consecutive ones in vvv. Clearly
which implies that equalities hold throughout. Thus, any two cyclicallyconsecutive ones in vvv are separated by at most ��1 = n1=(p
s+1)�1zeros. As vvv has length n1 and weight ps + 1, then “on average” anytwo cyclically consecutive ones are separated by that many zeros and,therefore, they are separated by exactly n1=(ps + 1) � 1 zeros. Weconclude that ifvvv is nonprimitive, then its ps+1 ones are equally spacedcyclically. Since all cyclic shifts ofvvv, and none other, have this property,it follows that if there is a line whose incidence vector is nonprimitive,then there are exactly n1=(ps + 1) such lines.If all lines have primitive incidence vectors, then the lines in
PG (m; ps) can be partitioned into classes, each containing n1 lines.In particular, the total number of lines, which is J1 as given in (3), isdivisible by n1, which implies that pms � 1 is divisible by p2s � 1.For odd values ofm this is not true. Thus, not all lines have primitiveincidence vectors and, therefore, our argument proves that there areexactly
n1=(ps + 1) = (p(m+1)s
� 1)=(p2s � 1)
lines in PG (m;ps), wherem is odd, whose incidence vectors are non-primitive.
REFERENCES
[1] R. G. Gallager, “Low-density parity-check codes,” IRE Trans. Inform.Theory, vol. IT-18, pp. 21–28, Jan. 1962.
[2] , Low-Density Parity-Check Codes. Cambridge, MA: MIT Press,1963.
[3] D. J. C. MacKay and R. M. Neal, “Near Shannon limit performance oflow density parity check codes,” Electron. Lett., vol. 32, pp. 1645–1646,1996.
[4] M. Sipser and D. Spielman, “Expander codes,” IEEE Trans. Inform.Theory, vol. 42, pp. 1710–1722, Nov. 1996.
[5] D. Spielman, “Linear-time encodable error-correctable codes,” IEEETrans. Inform. Theory, vol. 42, pp. 1723–1731, Nov. 1996.
[6] M. C. Davey and D. J. C. MacKay, “Low density parity check codes overGF ( ),” IEEE Commun. Lett., vol. 2, pp. 165–167, June 1998.
[7] M. G. Luby, M. Mitzenmacher, M. A. Shokrollahi, and D. A. Spielman,“Improved low-density parity-check codes using irregular graphs andbelief propagation,” IEEE Trans. Inform. Theory, vol. 47, pp. 585–598,Feb. 2001.
[8] D. J. C. MacKay, “Gallager codes that are better than turbo codes,” inProc. 36th Allerton Conf. Communications, Control, and Computing,Monticello, IL, Sept. 23–25, 1998.
[9] , “Good error-correcting codes based on very sparse matrices,”IEEE Trans. Inform. Theory, vol. 45, pp. 399–432, Mar. 1999.
[10] S. Y. Chung, G. D. Forney, Jr., T. J. Richardson, and R. Urbanke, “Onthe design of low-density parity-check codes within 0.0045 dB of theShannon limit,” IEEE Commun. Lett., vol. 5, pp. 58–60, Feb. 2001.
[11] T. J. Richardson and R. Urbanke, “The capacity of low-density parity-check codes under massage-passing decoding,” IEEE Trans. Inform.Theory, vol. 47, pp. 599–618, Feb. 2001.
[12] T. J. Richardson, M. A. Shokrollahi, and R. Urbanke, “Design ofcapacity-approaching irregular low-density parity-check codes,” IEEETrans. Inform. Theory, vol. 47, pp. 619–637, Feb. 2001.
[13] Y. Kou, S. Lin, andM. Fossorier, “Low-density parity-check codes basedon finite geometries: A rediscovery and new results,” IEEE Trans. In-form. Theory, vol. 47, pp. 2711–2736, Nov. 2001.
[14] C. Berrou, A. Glavieux, and P. Thitimajshima, “Near Shannon limiterror-correcting coding and decoding: Turbo codes,” in Proc. Int.Conf. Communications (ICC’93), Geneva, Switzerland, May 1993, pp.1064–1070.
[15] N.Wilberg, H.-A. Loeliger, and R.Kötter, “Codes and iterative decodingon general graphs,” Europ. Trans. Telecommun., vol. 6, pp. 513–525,Sept.-Oct. 1995.
[16] R. J. McEliece, D. J. C.MacKay, and J.-F. Cheng, “Turbo decoding as aninstance of Pearl’s belief propagation algorithm,” IEEE J. Select. AreasCommun., vol. 16, pp. 140–152, Feb. 1998.
[17] R. Lucas, M. Fossorier, Y. Kou, and S. Lin, “Iterative decoding ofone-step majority logic decodable codes based on belief propagation,”IEEE Trans. Commun., vol. 48, pp. 931–937, Jun. 2000.
[18] F. R. Kschischang, B. J. Frey, and H.-A. Loeliger, “Factor graphs andthe sum-product algorithm,” IEEE Trans. Inform. Theory, vol. 47, pp.498–519, Feb. 2001.
[19] J. Rosenthal and P. O. Vontobel, “Constructions of regular and irreg-ular LDPC codes using Ramanujan graphs and ideas from Margulis,” inProc. 2001 IEEE Int. Symp. Information Theory (ISIT’01), Washington,DC, June 2001, p. 4.
[20] I. Djurdjevic, S. Lin, and K. Abdel-Ghaffar, “Graph-theoretic construc-tion of low density parity check codes,” IEEE Commun. Lett., vol. 7, pp.171–173, Apr. 2003.
[21] Y. Kou, J. Xu, H. Tang, S. Lin, and K. Abdel-Ghaffar, “On circulantlow density parity check codes,” in Proc. IEEE Int. Symp. InformationTheory (ISIT’02), Lausanne, Switzerland, June/July 2002, p. 200.
[22] H. Tang, J. Xu, Y. Kou, S. Lin, and K. Abdel-Ghaffar, “On algebraic con-struction of Gallager low density parity check codes,” in Proc. IEEE Int.Symp. Information Theory (ISIT’02), Lausanne, Switzerland, June/July2002, p. 482.
[23] S. Lin, H. Tang, and Y. Kou, “On a class of finite geometry low densityparity check codes,” in Proc. 2001 IEEE Int. Symp. Information Theory(ISIT’01), Washington, DC, June 2001, p. 2.
[24] B. Ammar, B. Honary, Y. Kou, and S. Lin, “Construction of low densityparity check codes: A combinatoric design approach,” in Proc. IEEE Int.Symp. Information Theory (ISIT’02), Lausanne, Switzerland, June/July2002, p. 311.
[25] B. Ammar, B. Honary, Y. Kou, J. Xu, and S. Lin, “Construction oflow-density parity-check codes based on balanced incomplete block de-signs,” IEEE Trans. Inform. Theory, vol. 50, pp. 1257–1268, June 2004.
[26] B. Vasic, “Combinatorial construction of low-density parity-checkcodes for iterative decoding,” IEEE Trans. Inform. Theory, vol. 50, pp.1156–1176, June 2004.
[27] S. Sankaranarayanan, B. Vasic, and E. M. Kurtas, “A systematic con-struction of irregular low-density parity-check codes from combinato-rial designs,” in Proc. IEEE Int. Symp. Information Theory (ISIT’03),Yokohama, Japan, 2003, p. 1.
[28] R. M. Tanner, “A recursive approach to low complexity codes,” IEEETrans. Inform. Theory, vol. IT-27, pp. 533–547, Sept. 1981.
[29] J. L. Massey, Threshold Decoding. Cambridge, MA:MIT Press, 1963.[30] S. Lin and D. J. Costello, Jr., Error Control Coding: Fundamentals and
Applications. Englewood Cliffs, NJ: Prentice-Hall, 1983.[31] H. B. Mann, Analysis and Design of Experiments. New York: Dover,
1949.[32] R. D. Carmichael, Introduction to the Theory of Groups of Finite Or-
ders. New York: Dover, 1956.[33] A. P. Street and D. J. Street, Combinatorics of Experimental De-
signs. Oxford, UK: Oxford Sci., Clarendon, 1987.[34] D. J. C. MacKay, private communication.[35] W. W. Peterson and E. J. Weldon, Jr., Error-Correcting Codes, 2nd
