### Combinatorial Constructions of Low-Density Parity-Check Codes for Iterative Decoding

*Bane Vasic, Senior Member, IEEE, and Olgica Milenkovic, Member, IEEE*

**Abstract—This paper introduces several new combinatorial****constructions of low-density parity-check (LDPC) codes, in**
**contrast to the prevalent practice of using long, random-like**
**codes. The proposed codes are well structured, and unlike**
**random codes can lend themselves to a very low-complexity**
**implementation. Constructions of regular Gallager codes based**
**on cyclic difference families, cycle-invariant difference sets, and**
**affine** **1-configurations are introduced. Several constructions of**
**difference families used for code design are presented, as well as**
**bounds on the minimal distance of the codes based on the concept**
**of a generalized Pasch configuration.**

**Index Terms—Cyclic difference families, iterative decoding, low-****density parity-check (LDPC) codes, Pasch configurations.**

I. INTRODUCTION

**A**

FTER the discovery by MacKay and Neal [1] that
long Gallager codes [2] can achieve near-optimum
performance when used for transmission over white additive
Gaussian noise (AWGN) channels, it became a challenge to
construct codes that would come as close as possible to the
Shannon limit [3]. In the past few years, several low-density
parity-check (LDPC) codes were designed with performances
very close to this limit [4], [5]. Also, a significant insight
into iterative decoding was gained due to its interpretation in
terms of message passing and belief propagation in graphical
*models [6], as described, among others, by Kschischang et*

*al. [7], [8], and McEliece et al. [9]. The graphical model*that provides a natural setting in which to describe message passing was introduced by Tanner [10] and reintroduced by

*Wiberg et al. [11]. Although these requirements related to error*performance are important, complexity issues tend to dominate system architecture and design considerations, especially for extremely high-speed applications such as magnetic recording and optical communications. Iterative decoders proposed so far have very high hardware complexity and are incapable of operating at rates above 1 Gb/s, the speed of electronics in the next generation of these channels. The high complexity of the proposed schemes is a direct consequence of the fact that for random codes a large amount of information is necessary to

Manuscript received August 23, 2001; revised January 30, 2004. This work was supported by the National Science Foundation under Grant CCR-0208597 and by Seagate Technology. The material in this paper was presented in part at the IEEE Information Theory Workshop, Cairns, Australia, September 2001.

B. Vasic is with the Department of Electrical and Computer Engineering, Uni- versity of Arizona, Tucson AZ 85721 USA (e-mail: vasic@ece.arizona.edu).

O. Milenkovic is with the Department of Electrical and Computer Engi- neering, University of Colorado, Boulder CO 80303 USA.

Communicated by R. Urbanke, Associate Editor for Coding Techniques.

Digital Object Identifier 10.1109/TIT.2004.828066

specify positions of the nonzero elements in a parity-check ma- trix. In this paper, we introduce well-structured LDPC codes, a concept opposed to the prevalent practice of using random-like code constructions, with the exception of the results by Kou, Lin, and Fossorier [12], [13], Tanner, Sridhara, and Fuja [14], Rosenthal and Vontobel [15], and Johnson and Weller [16]. The parity-check matrices of our codes are completely determined by a small set of parameters, and can lend themselves to very low complexity implementations.

Although bipartite graphs are quite useful for visualizing message passing, they are not very convenient for code de- sign. Several constructions presented in this paper are purely combinatorial and based on balanced incomplete block designs (BIBDs) [17], extensively studied in connection with a large number of problems in applied mathematics and communica- tion theory [18]. More specifically, our codes are constructed from the incidence matrix of BIBDs [19]–[21], where corresponds to the number of parity bits, and corresponds to the column weight of the regular parity-check matrix. The bipartite graphs of codes based on BIBDs have girth six, which is acceptable in high speed–low complexity applications where one cannot afford more than just a few iterations (up to five); additionally, BIBD-based codes can be designed to have very high rate ( ) and relatively short length (less than 5000 bits). High rates are necessary to keep down the equalization loss (an important issue in recording channels), while short block lengths are required to maintain compatibility with existing data formats and to provide for a simpler system architecture [22]–[24].

In this paper we present three general code construction tech- niques. The first is based on difference families and the addi- tive group of integers , and it makes use of the Bose [25], [26], Netto [27], and Buratti [28] difference families, leading to BIBDs for which , where is a power of a prime.

This family of codes gives the best tradeoff between code rate and code length. Unfortunately, there are not very many high- rate, short-length codes in this class, especially for large values of . We also introduce the notion of -fold cycle-invariant dif- ference sets over (with ), and construct LDPC codes by using circulant permutation matrices determined by such dif- ference sets. Codes constructed by using this new class of dif- ference sets have both minimum distance and girth at least six, and exhibit excellent performance under iterative decoding. The third code construction, based on affine -configurations (in- teger lattices) is conceptually simple and produces a large family of codes, at the expense of the code rate. The number of parity bits of these codes is equal to , where is a prime and the

0018-9448/04$20.00 © 2004 IEEE

blocks are defined as lines of different slopes connecting points
of a integer lattice and the number of blocks is equal to .
Designs and codes are very closely connected combinato-
rial entities, since one can be used to construct the other. For
example, codewords of fixed weight in many codes, including
the Golay code and the class of quadratic residue codes, sup-
port designs (see, for example, [29] and [30]). On the other
hand, the incidence matrix of a design defines a nonlinear code
if the rows of the matrix are viewed as codewords [31]. De-
signs have also been successfully used for constructing LDPC
codes. A construction method for LDPC codes, based on Eu-
clidean and projective geometries (subclasses of BIBDs) was
*recently proposed by Kou et al. [12], [13] (the last section of*
[13] mentions block designs, but the authors did not developed
the idea in detail). Two other approaches for designing struc-
tured LDPC codes are a method based on using subgroups of the
multiplicative group of a prime field [14] and a method based
on Ramanujan graphs [15]. Recently, Johnson and Weller [16],
as well as Vasic [32], presented almost identical approaches to
the design of LDPC codes using combinatorial designs. The
ideas in [32] and [33] were further developed in the series of pa-
pers [34]–[37]. MacKay and Davey [38] also used Steiner sys-
tems (a subclass of BIBDs) to construct Gallager codes. The ap-
proach presented in this paper differs from the aforementioned
approaches in the sense that it is both conceptually simpler, and
as will be shown, gives much simpler construction algorithms.

The encoding complexity of our BIBD codes is extremely low and is basically determined by the size of a cyclic difference family upon which a block design is based, or by the “ver- tical” dimension of the lattice in the case of lattice construction.

We will also give the bounds on the minimum distance of the BIBD codes. Bounds on the minimal distance of regular Gal- lager codes with column weight three were first discussed by MacKay in [4]. Here, we present tighter bounds for this case, as well as new bounds for the case . Our bounds are derived using simple combinatorial arguments, and are solely a function of the parity-check matrix column weight. Tanner’s bounds on the minimum distance based on the eigenvalues of the product of the adjacency matrix of the code graph and its transpose [39]

can be shown to be trivial for the codes presented in this paper.

The outline of the paper is as follows. Section II introduces BIBDs and describes their relation to bipartite graphs and parity-check matrices of regular Gallager codes. Section III describes a code-design method involving sys- tems (Steiner triple systems), derived from cyclic difference families, and presents bounds on the minimum distance of the codes, derived by using the concept of a Pasch configuration.

Section IV presents three constructions of cyclic difference families for , , and , and gives a list of known infinite families. Section V contains the description of several new construction techniques for designs that can be used to derive high-rate LDPC codes. Additionally, this section includes the description of a code construction based on circulant permutation matrices and a novel class of combinatorial objects termed cycle-invariant difference sets (CIDSs). The description of another novel BIBD construction based on integer lattices is given in Section VI, while Section VII contains the results

of computer simulations. Concluding remarks are presented in Section VIII.

II. BALANCEDINCOMPLETEBLOCKDESIGNS ANDTHEIR

EQUIVALENCEWITHBIPARTITEGRAPHS

In this section, we introduce the definitions and the notation
used throughout the paper. A BIBD with parameters is
an ordered pair ( ), where is a -element set and is a
collection of -subsets^{1}of , called blocks, such that every el-
ement of is contained in exactly blocks and every -subset
of is contained in exactly blocks. Notice that , so
that the parameter is uniquely determined by the remaining pa-
rameters of the design. A design for which every block contains
the same number of points, and every point is contained in
the same number *of blocks is called a tactical configuration.*

Hence, BIBDs are tactical configurations. The notation BIBD
will henceforth be used to specify a BIBD on points,
with block size , and index . A BIBD with block size is
called a Steiner triple system (henceforth, STS). A BIBD is re-
solvable if there exists a partition of its block set into parallel
classes, each of which partitions the set *. Resolvable STS with*
index *are called Kirkman systems [40]. These combina-*
torial objects have been intensively studied in the combinato-
rial literature, and some construction methods for them are de-
scribed in [19], [20], [41]. Besides resolvable STSs, we will also
*use –configurations for LDPC code design. A –configuration*
is an incidence structure of points and blocks such that each
block contains points, each point is incident with blocks, and
*two different points are contained in at most* blocks.

*Definition 2.1: The point-block incidence matrix of a*

design is a matrix , in which if the

th element of occurs in the th block of , and

otherwise. The block-point matrix is the transpose of the point-block incidence matrix.

*Example 2.1: The collection*

of blocks , , ,

, , , and

is a BIBD system or an STS with and . The point-block incidence matrix is of the form

If , and hence *, the BIBD is symmetric, and is for*
equivalent to a finite projective plane [42].

If one thinks of points as parity-check equations and of blocks as bits of a linear block code, then defines a parity-check matrix of an LDPC code [2]. The column weight of is ,

1The standard notation for the subset size isk, but we will use c instead; in this way, we will avoid the subset size being confused with the dimension of the code, typically denoted byk.

the row weight is , and the code rate is , where the rank is evaluated over the field GF . Since the rank of is usually quite hard to determine, one can bound the rate of an LDPC code based on a design as follows:

(1)

It should be noticed that the bound given by (1) is generally loose. For example, for the case of codes constructed from pro- jective planes, the bound is trivially equal to zero, while the ac- tual rate of the codes is quite high (see, e.g., [12], [13]). There- fore, for a given designed code rate, many BIBD codes will have a larger dimension than predicted by (1).

*Remark 2.1: A more precise characterization of the rank*
(and “ -rank”) of the incidence matrix of -designs is given by
Hamada [43].

If every -element subset of is contained in exactly
*blocks, the underlying design is known as a -design. In this*
paper, we will restrict our attention to -designs only; more
specifically, to -designs with index . We will henceforth
refer to them just as BIBDs. The constraint implies that
no more than one block contains the same pair of points, or
equivalently, that no pair of columns of the parity-check matrix
contains two ones at the same positions.

From the lower bound on the code length for a given code rate for codes based on the BIBD systems one can see that if the required code rate is higher than (which is typically the rate of interest in recording and optical communi- cations channels), it is impossible to construct codes shorter than approximately 500 bits. Issues regarding the existence and the number of BIBD families for a given set of parameters are ad- dressed in Section V. The construction of maximum-rate BIBD codes with is trivial and reduces to finding , the com- plete graph [42].

To visualize the decoding algorithm for LDPC codes, the parity-check matrix is represented as a bipartite graph with two types of vertices [8]–[10]. The first subset of vertices is comprised of code bits, and the second subset of vertices is com- prised of parity-check equations . An edge between a bit and an equation exists if the bit is involved in the check. Translated to the terminology of block designs, the two sets of vertices corre- spond to and , respectively, and an edge between and exists if and only if . Hence, the parity-check matrix of the LDPC code is the block-point incidence matrix

.

*Example 2.2: The bipartite graph representation of the*
Steiner system whose incidence matrix is given in
Example 2.1 is shown in Fig. 1.

In order to have good error-control characteristics, it is desir-
able to have each bit “checked” by as many equations as pos-
sible, but due to the iterative character of the decoding algorithm
it is also important that the bipartite graph does not contain short
*cycles. In other words, the girth of the graph (i.e., the length of*
the shortest cycle) must be large. The girth constraint is related

Fig. 1. The bipartite graph representation of the Steiner(7; 3; 1) system.

to the constraint that every -element subset of is contained in as few blocks as possible. On the other hand, check nodes should not have too large a degree in order to allow for efficient iterative decoding. These two requirements are contradictory, and the tradeoff is especially difficult when one is interested in constructing codes with short length and high rate.

*Remark 2.2: The constraint* imposed on BIBDs im-
plies that there are no cycles of length four in the bipartite graph
of the code.

III. CODEDESIGNBASED ONDIFFERENCEFAMILIES

As pointed out in Section III, BIBDs offer a combinatorial tool for designing codes without short cycles. In this section, we present several simple construction of STSs using difference families of Abelian groups.

*Definition 3.1: Let* be a finite additive Abelian group of

order . Then -element subsets of , ,

, form a *difference family (henceforth, DF)*
if every nonzero element of can be represented in exactly
ways as a difference of two elements within the same member
of the family. In other words, every nonzero element of oc-

curs times among the differences , ,

. The sets *are called base blocks. If* is iso-
morphic to , the additive group of integers modulo , then the
corresponding DF is called a cyclic difference family
(henceforth, CDF).

*Example 3.1: The block* is a base block of
a CDF. To illustrate this, we create an array

, of differences

As can be seen, each nonzero element of occurs exactly once in .

*Example 3.2: The blocks* and

are the base block of a CDF based on the group , since the nonzero elements of the difference arrays

TABLE I

THEORBITS OFBASEBLOCKSf0; 1; 4g^{AND}f0; 2; 7g^{IN A}(13; 3; 1) BIBD

formed according to ( and ),

are all different.

*Definition 3.2: If* is a group that acts on a set , then the
set , *, is called the orbit of . For the*
case that is a cyclic group of order and , where
is the set of all base blocks of a CDF, a BIBD can be defined as
the union of the orbits of . If the number of base blocks is ,
the number of blocks in a BIBD is .

Generally, given a CDF with base blocks

, , the point-block inci-

dence matrix of the BIBD can be written in the form

(2) where each submatrix is of dimension . The orbits of the base block are represented by the positions of nonzero ele- ments in the submatrix .

*Example 3.3: The blocks* and

are the base block of a CDF of the group . The orbits of and are given in Table I.

The parity-check matrix corresponding to the BIBD in Table I is given by

and contains only columns of weight three. The CDF codes described above have a quasi-cyclic structure similar in form to the self-orthogonal quasi-cyclic structure of Townsend and Weldon’s [44] codes and Weldon’s difference set codes [45].

Each orbit of a base block in the design corresponds to one circulant submatrix in the quasi-cyclic parity-check matrix of

the code. Hence, the self-orthogonal codes of Townsend and Weldon represent a special class of LDPC codes.

The codes based on are of special interest because they are conceptually very simple and have a structure that can be easily implemented in hardware. Notice also that for a given constraint the CDF-based construction maximizes the code rate (see (1)), because for a given the number of blocks is maximized. The code rate is independent from the choice of the representation of the underlying group as long as the base blocks belong to a CDF. Other choices for the groups may lead to similar or better codes, but they are not considered in this paper.

The rest of this section is devoted to establishing bounds on the minimum distance of BIBD-based codes constructed from CDFs. The minimum distance determines code per- formances under maximum-likelihood (ML) decoding at high signal-to-noise ratios (SNRs), the region where most of the prac- tical systems typically operate. Additionally, small minimum distance may result in undesirable high error-floors. Bounds for of Gallager codes with column weight were first de- rived in [38]. Another, more general technique for establishing a lower bound for is due to Tanner [39]. It pertains to an arbitrary linear code with parity-check matrix , represented by a bipartite graph, and is based on combinatorial optimiza- tion. The calculation of the bound involves finding the second largest eigenvalue of the matrix . For the codes based on CDF, these eigenvalues can be found in closed form, but they result in trivial bounds (see Lemma 3.1). Here, we present tight bounds for and also establish bounds for . These combinatorial bounds are derived using simple counting argu- ments, and are solely function on the column weight of .

*Lemma 3.1: Let* be a parity-check matrix of the form
given by (2). Then the largest eigenvalue of is equal to
, while all the remaining eigenvalues are equal
to . In the last expression, denotes the number of
times each point occurs in different blocks belonging to a given

, i.e., for , .

**Proof: The proof is given in Appendix A.**

Based on Lemma 3.1, one can use Tanner’s lower bounds [39] to find bounds on the minimum distance of the CDF codes.

Tanner’s bounds are expressed in terms of the second largest

eigenvalue of (see also [61]), and for the case of interest are of the form

The first bound is trivial for , i.e., for . The second bound is trivial for , i.e., for

.

A general, nontrivial lower bound on for codes based on BIBDs with block size can be easily obtained by using two different arguments. The first one is based on the idea of majority logic decoding [31]. A code is one-step majority logic decodable if for every bit there exists a set of parity-check equations that are orthogonal on that bit. In this context, the or- thogonality condition imposes the requirement that each of the check equations include the bit under consideration, and that no other bit is checked more than once by any of the equations. If a code is one-step majority decodable, then the minimum distance of the code is at least . From the described construction of the LDPC codes based on BIBDs, it follows that and that therefore . The same result can be obtained by considering the Tanner graph of the code as follows. Start by selecting a bit node and assume that its value is one. It has check nodes at distance one and bit nodes at distance two. Since , the girth of the code graph is at least six, and therefore all bit nodes at distance two are distinct. However, to satisfy the parity-check node equations at distance one, at least of the bit nodes at distance two must have the value one. There- fore, the minimum weight of a codeword has to be at least . In order to improve the previously derived lower bound on

, we need to define a generalized Pasch configuration.

*Definition 3.3: An* *configuration in a* D is a
subset of blocks of , whose union is an -element subset
of *. A Pasch configuration or a quadrilateral is a*
configuration in a STS.

*Example 3.4: Consider an STS and a subset of six points,*
. Then the set of blocks

forms a Pasch configuration.

Using the definition of a Pasch configuration for , we can now define a generalized Pasch configuration as a

configuration of a BIBD. A generalized Pasch

configuration can always be visualized by creating a

array of points , as shown

at the bottom of the page. It is easy to see that no pair of points occurs more than once in the same row. Hence, the rows of represent blocks of a configuration.

*Example 3.5: A generalized Pasch configuration of a BIBD*
with and can be represented by the rows of the
matrix shown as follows:

. ..

. ..

*Lemma 3.2: The rows of* *define the smallest configura-*
*tion of a* BIBD in which each point occurs exactly twice.

**Proof: The proof is given in Appendix B.**

*Remark 3.2: The existence of a Pasch configuration in an*
STS is directly related to the minimum distance of the derived
LDPC code. If an STS has at least one Pasch configuration, each
point occurs exactly twice in the configuration, and therefore
there exist four linearly dependent columns in . This implies
that . If the triple system is Pasch-free, then the min-
imum distance of the corresponding LDPC code is equal to six.

For example, the Bose construction to be described in Section V produces LDPC codes with minimum distance . The CDFs following from the first construction by Netto result in codes that have , while the ones obtained from the second construction by Netto result in codes with (see Section IV). This result can be extended to arbitrary designs. If a CDF and the underlying design contain a generalized Pasch configuration, then , and if the underlying design does not contain a generalized Pasch configuration then

.

*Example 3.6: For the example in Table I,* ,
, and

and each of the points occurs twice in

this group of blocks. Hence, the minimum distance of the code constructed from this CDF is . Furthermore, since the

TABLE II

THEONLY2-(15; 3; 1) P^{ASCH}-FREEDESIGN

sum of all rows of the parity-check matrix is the all-one code- word, the corresponding LDPC code is even (i.e., all codewords of the code have even weight). Hence, since no two columns are identical, the minimum distance of the code also satisfies

.

*Remark 3.3: Pash-free STSs are extremely rare. In other*
words, most known STSs will result in codes with .
In [19], Colbourn lists 80 nonisomorphic - designs,
only one of which is Pasch-free (see Table II) (this particular
design is also described in [19]). In their recent work, Ling
*et al. [46] present a construction techniques for anti-Pasch*
STSs. However, these designs do not necessarily lead to codes
with quasi-cyclic structure. The existing connection between
Pasch configurations in designs and bounds on the minimum
distance calls for investigating the effects of other types
of configurations on and the girth of a bipartite graph. For
example, Beezer [47] defines the girth of a -design through the
*concept of Erdös configurations, a generalization of the Pasch*
configurations.

On the other hand, one can easily establish the following upper bound for the minimum distance of a code constructed from a CDF BIBD.

*Theorem 3.1: For a CDF BIBD code with column weight ,*

one has .

**Proof: The proof is given in Appendix C.**

IV. CONSTRUCTION OFCDFS BYNETTO ANDBURATTI

It is straightforward to construct a BIBD design once the CDF is known. However, finding the CDF is a much more complex problem and it is solved only for certain values of , , and . In this section, we will present several constructions for CDFs.

One of the first known constructions due to Bose [25], [26] is described next.

The idea for the construction is based on the use of combina- torial objects known as mixed difference sets. Mixed difference sets are formed by taking elements from multiple copies of the additive group (say, ) of the elements of the design, distin- guished by different subscripts [50]. One can show that the sets

where the elements are taken modulo , and the subscripts are taken modulo three, form a DF.

Most constructions of CDFs that followed Bose’s work are based on the use of finite fields. The following constructions belong to this category.

TABLE III

SOMESMALLPRIME(v; 3; 1) C^{YCLIC}DIFFERENCEFAMILIES

*A. The First Construction by Netto*

This construction is applicable for and a power of a prime of the form [27]. For a power of a prime, is to be replaced by GF , the Galois field of order . Let be the elements of the multiplicative group of the field GF . Let be a primitive element of the field, and hence a generator of the multiplicative group [48]. Write as

, , and for , let be the group of th powers in GF , and let be a coset of th powers of . Then the set defines an STS difference family with parameters [27] (see also [49]). The base blocks are typically given in the form

rather than as .

*Example 4.1: As an illustration, the difference families for*
some small primes are given in Table III.

An alternative combinatorial method for constructing a CDF with parameters , that can also be extended to the case, was proposed by Rosa in [41]. Furthermore, in [45], Weldon presents a list of constructions for CDFs with the same set of parameters as described above, as well as a list of the resulting codes of rate .

*B. The Second Construction by Netto*

This construction can be used to create CDFs when the number of points is a power of a prime and

[27]. As in the first construction, let be a generator of the multiplicative group of the field GF and let be the group of th powers in GF . Then the set

defines base blocks that are also called a Netto triple system.

One more design construction technique is known as Netto’s construction. It is not directly based on CDFs, but is strongly related to the previously described constructions.

*C. The Third Construction by Netto*

Let , where is a prime of the form

. Let and be two sixth roots of unity in GF . It is

straightforward to verify that and that

and , and that neither and are

perfect squares in GF . Define a relation as follows:

holds if and only if is a nonzero square in GF . Then exactly one of the relations is true: or . Define

a function as , for all pairs

such that holds. A Netto system [27] obtained by utilizing the function is an STS with points and blocks GF ,

, repsectively.

Netto systems are of interest because of the following property.

TABLE IV

BASEBLOCKSPARAMETER FORBURATTICDF

*Theorem 4.1: Netto triple systems for* a power of a prime
of the form and the third Netto triple system
described above are Pasch-free.

*Proof: The proofs can be found in [19] (see also [51]).*

*Consequence: The Netto triple systems described in*
Theorem 4.1 achieve the upper bound on minimum distance,

i.e., .

*Example 4.2: The base blocks of the Netto triple system dif-*

ference family for , are: ,

, , ,

, , and . The re-

sulting code is quasi-cyclic, has , length ,

and .

*D. The Construction by Buratti (* *and* *)*

Buratti’s method [28] gives CDFs with points and block size , provided that is a prime of the form . The CDF is a set , where base blocks have the form , and denotes a primitive element in GF . The numbers GF for several different values of are given in Table IV. Similarly, for , the CDF is given

by , where , and

GF .

If a difference set family with parameters exists, it is possible to construct difference set families with parameters

, where , and , by

using the following simple augmentation method due to Col- bourn and Colbourn [51]: For each block , first subtract the smallest element from all elements of the set to

obtain . Then form the difference sets

with addition performed modulo .

V. OTHERRELATEDCONSTRUCTIONTECHNIQUES

*A. Finite Euclidean and Finite Projective Geometries*
The existence and construction of short designs

is an active area of research in combinatorial mathematics (the
handbook [19] edited by Colbourn and Dinitz is an excellent
reference). [19, Table 2.3] gives a summary of known results
concerning the existence of short designs. However, very
often the construction of these designs is somewhat heuristic
or works only for a given block size. In many cases, such
constructionsgive a very small set of designs with parameters
of practical interests. An important exception is the subclass of
*BIBDs called infinite families [19]. Infinite families of BIBDS*

include projective geometries, affine geometries, unitals, Denniston designs, as well as certain geometric equivalents of -designs [19]. The known infinite families of BIBDs are listed in Table V [19], [51]. For designs with a number of points that is a power of a prime, these families are known as finite Euclidean and finite projective geometries (for more details the reader is referred to [51]).

The first class of finite-geometry codes is comprised of codes
with parity-check matrix defined as the point-line incidence ma-
trix of finite geometries, such as the LDPC codes described by
Kou, Lin, and Fossorier [13]. The second class of codes is ob-
tained from algebraic curves in a projective plane. In a projec-
*tive plane, an algebraic curve is a collection of points that sat-*
isfy a fixed homogeneous algebraic equation of some degree
, i.e., *. An algebraic curve is irreducible if*
is an irreducible polynomial over the ground field
GF . A line meets the curve in at most *points. A conic is an*
algebraic curve of degree two, or more specifically

*A conic is irreducible if* is irreducible over the
ground field GF . For , an *-arc in PG* is a
set of points such that no points lie on a line. A -arc
in PG is a set of points such that no three points lie on the
*same line. A -arc is complete if it is not properly contained in*
any *-arc. A line of the plane is said to be a secant, a tan-*
*gent, or an exterior line with respect to the oval, if the number*
of common points of the line with the oval is 2,1, or 0, respec-
tively. For a given value of , -arcs of PG odd are
*called ovals, and* -arcs of PG even together with
a nucleus point (a point for which every line incident to it is a
*tangent of the oval) are called hyperovals.*

In PG *, an oval design is the incidence structure with*
points comprised from the lines exterior to the oval and blocks
specified by the points not on the oval. A block contains a point
if and only if the corresponding exterior point lies on the exte-
rior line. An oval design is a resolvable

Steiner -system, where . In the simulation result sec- tion, we will present the performance of the codes on a hyper- oval constructed from a nondegenerate conic specified by the equation . Similar results were presented in [55].

Unitals or Hermitian arcs are defined as follows. In PG ,
*a square, a Hermitian arc is a* -arc. The
arc is constructed from an algebraic curve of order such

that . The arc intersects any line of

the plane at or points. A unital constructed from an algebraic curve of order is a

Steiner system. A code based on this unital is described in terms of the incidence matrix of the corresponding Steiner system. For a power of , the rank of the incidence matrix is , and for a power of an odd prime, the rank of the incidence matrix is . Such designs are treated in great detail by Assmus and Key and in [56] and in [57].

As it can be seen from Table V, the most known infinite families of designs do not offer sufficient flexibility in choosing the code length and column weight, especially for the high-rate and/or moderate codeword length cases. In this region, the

TABLE V

KNOWNINFINITEFAMILIES OF2 0 (v; c; 1) D^{ESIGNS}

column weight must be small and one solution is to use a special class of short, cleverly constructed CDF as in [28].

Notice that in [13] different modifications (including code shortening, for example) of Euclidean and projective geometry codes are given so as to get a larger set of code parameters.

*B. The Latin Square Construction by Bose [59]*

In order to describe this construction method for STSs due to Bose, we will first define a special class of Latin squares. A Latin square of order is an array such that each row and column contains the symbols in exactly once.

A Latin square is idempotent if cell contains symbol ,
, and commutative if cells and contain the
same symbol, *. Let SQ be an idempotent and commu-*
tative Latin square of order , let

and . Define a collection of triples , so that contains

• all triples of the form , where

;

• all triples of the form

where , and denotes the entry of

the Latin square SQ in row and column .

Then is an STS of order . If the Latin square SQ is chosen in such a way that , and that , then the STS resulting from the Bose construction is Pasch-free. This follows from the fact that under the given conditions there are no Latin subsquares of order two in SQ and cannot hold for distinct symbols . For more details, see [20].

*Example 5.1: Consider the following idempotent, commuta-*
tive Latin square of order :

This Latin square contains a sub-Latin square of order two, spec-

ified by the coordinates , containing

the elements . The four triples

derived by fixing the last coordinate of the first two pairs and choosing the first elements of the first two pairs in each block so as to include the points of the sub-Latin square of order two, form a Pasch configuration.

Closely related to the construction due to Bose described earlier is the Skolem construction [59]. This construction is also based on Latin squares, and it produces STSs of order

In this case, the Latin squares of interest are the so-called half-idempotent commutative squares of order . A square of order is half-idempotent if the cells

contain the symbol . For more details about the Skolem construction, the reader is referred to [59].

*C. Circulant LDPC Codes With Permutation Blocks: New*
*Constructions*

Based on the description of the Bose Latin square construc-
tion, it follows that the parity-check matrix of the corresponding
linear code has a block structure, where each block (except for
the set of blocks in the first column of blocks) is a permutation
matrix. Codes with such a structure are well known and have
been used in many applications. For example, in [39], Tanner
presented a class of codes of this type named Sparse Difference
*Codes. The so-called array codes introduced by Blaum, Farrell,*
and Tilborg [60], have parity-check matrices that are also com-
posed of powers of permutation matrices, and can be viewed as
LDPC codes [61]. Eleftheriou and Olcer [62] proposed this class
of LDPC codes for application in digital subscriber lines. More
*recently, Kim et al. [63] presented a construction of families of*
LDPC codes based on permutation matrices that have girth at
least eight.

We will present next a novel construction for a simple family of LDPC codes using a similar idea. We will define the parity-check matrix to be a block-circulant (cyclic) matrix with blocks that are permutation matrices. The structure of these codes is extremely simple and allows for finding simple lower bounds for the girth, as well as the minimum distance.

The girth of all the constructed codes can be shown to be at least six, while the minimum distance of a certain subclass of these codes is at least six. The rate of these codes can have a large range of values, and the family of codes produced in this way is quite large. It is interesting to observe that for these codes it is also possible to find the eigenvalues of either in closed form, or asymptotically [64]. Unfortunately, the bounds on minimum distance presented by Tanner in [39] can be shown to be very loose for these codes and are not included in the paper.

*Code Description: Let* be an block-circulant
matrix with permutation blocks, i.e., block-circulant with blocks

that are different powers of the basic permutation matrix of order , i.e.,

(5.1)

where are nonnegative integers and

is an circular permutation matrix.

The row weight of the code is , while the column weight is . The code generated by of the form given by (5.1) has to be even (i.e., all codewords of the code have to have even Hamming weight), because the sum of all codewords over one row-block is the all-one codeword. We will describe next several construction techniques for the exponent set that result in a Tanner graph free of cycles of length four.

*Lemma 5.1: Let* , and

, where . Then the

LDPC code specified by of the form given by (5.1) has girth at least six and for girth at least eight. Furthermore, no two columns of its parity-check matrix are identical, and no three columns are linearly dependent. Hence, the minimum distance of the code is at least four.

**Proof: The proof is given in Appendix D.**

*Example 5.2: Let* , , and ; then the

parity-check matrix is of the form

It can be easily shown that the generator matrix for this code is of the form

and is also a block-circulant matrix with permutation blocks.

This special form of the generator matrix can make the encoding procedure very fast.

Codes described by a parity-check matrix with regular
*column weight equal to two are also known as circuit codes*
[65]. As pointed out in [66], LDPC codes with column weight
two can outperform LDPC codes with larger column weight in
magnetic recording applications, despite the fact that the min-
imum distance of these codes can increase only logarithmically
with the block length. This is due to two reasons: first, these
codes have girth at least eight; second, in magnetic recoding
applications, LDPC codes are inner codes for Reed–Solomon
(RS) outer codes, and the block-error statistics of LDPC codes
with column weight two is a good match for the RS decoder.

The permutation-matrix codes described above can be easily shown to have minimum distance . For our example, it suffices to observe that columns 2, 14, 25, and 39 are linearly dependent. Because of the symmetry of the construction, codes

with all possible and values will have the same minimum distance.

In order to construct codes with minimum distance higher than four, the exponents of the permutation matrices have to be chosen with more care.

*Definition 5.1: Let* be an ordered difference set over ,
and let denote the operator that cyclically shifts a sequence
positions to the right. If for the ordered sets
are all different from each other (and
from ), and are themselves ordered difference sets, then we say
that is an -fold cycle invariant difference set over .
*Example 5.3: Consider* and the ordered difference set

. Then

which is easily seen to be a difference set. Since

is a -fold cycle invariant difference set over . On the other hand, the difference set over gives rise to three different ordered sets, namel,y

, none of which is a differ- ence set. Hence, is a -fold cycle invariant difference set (classical difference set) over .

The requirement for to be a difference set can be relaxed. It
suffices for *to be an incomplete difference set, i.e., a set such*
that the differences of its elements are all different, but do not
necessarily cover every possible value. From now on we will
refer to incomplete difference sets as difference sets.

One of the first constructions of classical difference sets is due to Bose [25], [26]. For this construction, the parameters of the difference family are , where is an odd prime.

Let be a primitive element in the field GF . Define the following set of integers:

GF

Clearly, consists of elements. It is also straightforward to show that is a difference set modulo , with . A similar construction method, which predates the Bose construc- tion, is due to Singer [58].

We will present next a construction for the new class of com- binatorial object described in Definition 5.1; the construction can be viewed as an extension of the result due to Bose.

*Theorem 5.1: Let* be a primitive element of the finite field
GF with an odd prime. Define a set of integers by

GF

Then the set forms a -fold cycle-invariant difference set .

**Proof: The proof is given in Appendix E.**

*Example 5.4: Let* and . The set

constructed by using the approach by Bose is clearly a difference set, since its differences modulo are . But the set is not two-fold cycle invariant,

since , and for the last set

. On the other hand, the set

constructed according to Theorem 5.1 with and primitive polynomial , can be easily checked to be a CIDS of order .

*Lemma 5.4: Let* , , be elements of an -fold
cycle invariant difference set. Then, the LDPC code specified
by of the form given by (3) has girth at least six.

*Proof: The proof follows along the same lines as the proof*
of Lemma 5.1.

*Theorem 5.2: Let* , , be elements of an -fold
cycle-invariant difference set, with . Then, the LDPC
code specified by of the form given by (5.1) has minimum
distance at least six.

**Proof: The proof is given in Appendix F.**

*Example 5.5: Consider the two blocks from Example 3.4,*
and , now viewed over rather than .
The first difference set is two-fold cycle-invariant in the general

setting, since ,

and the differences generated by are

, so that each element in appears at most once. Hence, an LDPC code specified by the parity-check matrix

where the dimension of is eleven, has minimum distance at least six and girth at least eight.

Similarly, if we take the two blocks in the cyclic difference family as exponents for the permutation matrices of two dif- ferent rows of blocks, we obtain

Notice that is not any longer block circulant, but the set generates a set of differ- ences such that each element of appears at most once. Hence, the underlying code has minimum distance at least six and girth at least eight.

VI. LATTICECONSTRUCTION OFLDPC CODES

In this section, we address the problem of constructing LDPC codes of large block lengths. As shown in the previous sections, the Buratti-type CDFs and the projective geometry approach offer a quite limited set of parameters and therefore small fam- ilies of codes. In this section, we give a novel construction of -configurations, in which every -tuple is contained in at most blocks. The blocks of these -configurations are lines connecting points of a rectangular integer lattice. The construc- tion problem can be seen as specifying a subset of points and a subset of lines that will result in a set of desired characteristics of the code. In this way, one can trade the code rate and number of blocks for the simplicity of construction and for the flexibility of choosing the design parameters. Also, as will be shown sub- sequently, -configurations greatly simplify the construction of codes with large girth.

Fig. 2. An example of the rectangular grid forq = 5 and c = 3.

*A. Codes on a Rectangular Subset of an Integer Lattice*
Consider a rectangular subset of the integer lattice defined
by

where is a prime. Let be a one-to-one

mapping from the set to the point set . An example of such

a mapping is the simple bi-linear map .

The numbers are referred to as point labels.

*Example 6.1: Fig. 2 depicts a rectangular subset of the in-*
teger lattice with and .

A set of points is referred to as a line of slope
*, starting at the point* , if it contains the points

, where . There are different classes of parallel lines in this geometry.

*Example 6.2: In Example 6.1, the lines of slope* are the

triples and so forth. We assume

that the point labels are periodic in the vertical dimension, and therefore the line containing the points also has slope . Examples of lines with slope two are and . Notice that lines of infinite slope are not included in the -configuration.

*Lemma 6.1: The set of point labels of lines with slopes*
forms the blocks of a -configuration.

**Proof: The proof is given in Appendix G.**

*Remark 6.1: In the lattice -configuration, the block size is*
, the number of points is , the number of blocks is .
*Lemma 6.2: A* lattice -configuration is Pasch-
free.

**Proof: The proof is given in Appendix H.**

More generally, we have the following result.

*Theorem 6.1: A lattice -configuration with* , for
even or , does not contain a generalized Pasch
configuration.

**Proof: The proof is given in Appendix I.**

Fig. 3 shows the rate–length characteristics of lattice designs for different line (block) sizes . The solid lines correspond to the designs with maximal number of blocks. As can bee seen, lattice families have a rate loss compared to theoretically op- timal designs. However, this loss becomes negligible for larger

and for longer codes.

The abundance of lattice designs compared to infinite family BIBDs can be easily observed from Fig. 4. White markers denote codes resulting from the known infinite family BIBDs, while dark markers correspond to LDPC codes constructed using lattice designs.

*Remark 6.3: The lattice construction can be extended to*
nonprime vertical dimensions , provided that the slopes are
co-prime to .

Fig. 5 shows the growth of the required code length with an upper bound on the minimum distance (of the form ) as parameter.

*Example 6.3: Table VI illustrates a -configuration based on*
a lattice shown in Fig. 2.

Notice that there are parallel classes of blocks (lines), each corresponding to a different slope. Denote the first block (the one incident with the point ) in the class as

. In our example ,

, , , and

.

The corresponding parity-check matrix is

Notice that in general, the parity-check matrix of a lattice codes can be written in the form

Fig. 3. The rate–length characteristics of lattice designs.

Fig. 4. Comparison of finite geometries and lattice design families.

where each submatrix is a circulant permutation matrix.

The power of which determines (i.e., the position of the bit the first column of ) can be found by using , the th element of the first base block of the class of blocks corresponding to the th slope, and is equal to

.

*Remark 6.4: Notice a similarity of the structure of the above*
parity-check matrix with that obtained in [63], [67]. The codes
denoted by LU in [63] have a square parity-check matrix,
while our codes have rectangular matrices of parity checks. This
is not surprising because it was shown in [63] that LU and
LU are equivalent to Euclidean geometry code [13], while
a square lattice design (which includes the lines with infinity
slope) is equivalent to the Euclidean plane.

TABLE VI

ANEXAMPLE OF ALATTICE1-CONFIGURATION

Fig. 5. The rate–length curve for lattice designs with the minimum distance as a parameter.

*Remark 6.5: The ensemble of LDPC codes described*
in terms of parity-check matrices constructed from random
permutation matrices has a well-defined asymptotic distance
distribution. Litsyn and Shevelev [68] showed that such an
ensemble (referred to as “Ensemble A”) has superior distance
distribution compared to other ensembles they considered in
[68], in the context of ML decoding.

*B. Integer Lattice Codes With Large Girth*

In this subsection, we will show that a Tanner graph with high girth can be obtained by a judicious selection of sets of paral- lellines included in an integer lattice -configuration. The re- sulting parity-check matrix is also in the form of a block matrix with permutation matrices. We will only discuss codes of girth eight, although a generalization for higher girths is possible.

A lower bound on the minimum distance of LDPC codes with girth and column weight is given by the following formula due to Tanner [10]:

odd

even.

Although it still remains unclear whether increasing the girth of a bipartite graph is the best way to improve code performance under message-passing decoding, our simulation results indi- cate that it is a valid approach, especially when the constraint imposed on a number of iterations is not strict.

Recently, Rosenthal and Vontobel [15] constructed some short codes and large girth, using ideas by Margulis [53], including -regular Caley graphs of the special linear group

SL GF , and the projective general group PGL GF .
*Kim et al. [63] gave another explicit construction of high-girth*
LDPC codes using Lazebnik and Ustimenko’s [67] method for
developing regular graphs. The construction of designs with
high girths appears to be a very difficult problem in general
[47]. However, the designs based on rectangular integer lattices
allow a simple algorithm for finding a girth-eight subdesign.

Moreover, for , there is an interesting connection between codes of girth eight and “arithmetically constrained” sequences defined by Odlyzko and Stanley [69].

Denote by a resolvability class corresponding to the set of lines of slope , and by a set of blocks of a subdesign composed of resolvability classes corresponding to the slopes from the set , i.e., . We are interested in the following problem: find a set of slopes with maximum possible cardinality such that specifies a set of blocks that result in a design with girth eight.

*Example 6.4: For a subset of an integer lattice shown in*
Fig. 2 (with , ), it can be shown by inspection that the
maximal set of slopes leading to a code of girth eight is of car-
dinality two (e.g., ). The resulting parity-check
matrix is obtained by deleting columns of a parity-check matrix
of the original code corresponding to lines with slopes ,
and is of the form

where is of order . Due to the small size of the set , this matrix is useless for coding purposes and represents only an illustration of the key idea.

*Definition 6.1: Let* be the set of all sequences of inte-
gers that do not contain a -term arithmetic progression. We
will refer to as the “earliest” sequence in if lexico-
graphically precedes all other sequences in . is of the form
, and is cataloged in [70] under number
M2353.

The sequence can be generated by the recurrence relation:

, and it has the property that it contains all numbers that only have the digits

and in their ternary expansion [69].

*Theorem 6.2: For an arbitrary integer* and for , the
set of slopes resulting in codes with girth eight is of the

form , i.e., it is a subsequence of

whose elements are less than or equal to .
**Proof: The proof is given in Appendix J.**

VII. SIMULATIONRESULTS

In this section, we present the bit-error rate (BER) perfor- mance of various regular LDPC codes that were constructed ei-

Fig. 6. Performance of LDPC codes on combinatorial designs under message-passing decoding.

ther combinatorially or randomly. The LDPC codes were de- coded iteratively by using the standard message-passing algo- rithm. More details on the message-passing algorithm for bipar- tite graphs can be found in [6], [7], [72]. The BER performance of an LDPC code was estimated by running Monte Carlo sim- ulations for at least 25 000 codewords and 15 message-passing iterations. Hence, we were able to obtain BER as low as .

Figs. 6–9 show the BER performance of LDPC codes, constructed using different combinatorial methods presented in this paper, and random regular LDPC codes obtained from Mackay’s online resource [73]. The rate of these codes vary from to , and all the BER curves shown in Figs. 6–9 have been adjusted for their respective rate loss (i.e., the SNR is determined from ). A legend in each figure gives the following information in the respective order: method used to construct the code, and a quadruple .

As can be observed from Fig. 6(a), codes from difference families, due to Bose and Netto, exhibit an error floor at approx- imately 5.75 dB, which is expected behavior. Fig. 6(b) shows the BER performance comparison between difference family codes and randomly constructed (regular and irregular) codes of similar length and rate. At BER of , a loss of 0.5 and 0.9 dB with respect to regular/irregular code, respectively, can be seen. In Fig. 7, a relatively short code from a projective plane exhibits a very good BER performance. In Fig. 8, we consider rate- codes on integer lattices for the following parameters:

1) , ; 2) , ; 3) , ;

4) , ; 5) , . In addition, we also con-

sider rate– CDF codes constructed using Buratti’s method

for and , and Wilson’s method

for . The BER curves of an integer lattice code and a MacKay code [73] of similar parameters is given in Fig. 8(b), demonstrating that short integer lattice codes have per- formance comparable to random-like MacKay codes. The BER performance of a girth-eight LDPC code with column weight

Fig. 7. Performance of LDPC codes on finite geometries.

four is the most impressive among other curves shown in Fig. 9.

This code exhibits a sharp fall and its BER reaches at ap- proximately 3.25 dB. A BER curve of a regular MacKay code in Fig. 9(a) is given as a reference point without any attempt to shorten it to match the length and rate of the given structured code. The comparison of girth-eight and random codes of the same lengths and rates is shown in Fig. 9(b). Random codes are constructed by Neil’s method [74], and are free of cycle-four.

It can be seen from Fig. 9(a) that girth-eight codes have almost identical performance with randomly constructed codes.

It is important to note that in simulations, that were run to estimate the BER performance of the girth-eight

Fig. 8. Performance of integer lattice codes.

Fig. 9. Performance of girth-eight integer lattice codes.

code, 100 message-passing iterations were performed before making the hard decision on a received word. An error floor was observed if only 15 iterations were performed in the above simulations.

As already described in the Introduction, due to stringent delay constraints some applications do not allow for more than several (5 to 6) iterations of message passing. Fig. 10 shows the BER performance of two girth-eight integer lattice codes after iterations, . It can be seen that a significant gain with respect to the uncoded system is achieved only after five itera-

tions, but that with another 10 iterations a performance gain of approximately 1 dB can be achieved.

Finally, the performance of several codes based on the con- structions presented in Section V is shown in Figs. 11 and 12.

Fig. 11 shows the performance of the codes described in Lemma 1, while Fig. 12(a) plots the performance of block-cir- culant codes with exponents taken from the Bose difference set

over GF , , with , i.e.,

Fig. 10. Performance of girth-eight integer lattice codes with respect to the number of iterationsi.

Fig. 12(b) shows the performance of CIDS-based codes, with the construction presented in Theorem 5.1 and .

VIII. CONCLUSION

In this paper, we introduced new combinatorial constructions for a class of high-rate iteratively decodable codes based on BIBD and -configurations. The resulting codes have girth at least six. We also constructed balanced incomplete block designs using Netto and Buratti cyclic difference families, as well as novel affine geometry lattice configurations. We derived tight bounds on a minimum distance of BIBD codes using the concept of a Pasch configuration.

APPENDIX A PROOF OFLEMMA3.1 Observe first that

Based on a well-known result, which states that

for any point-block incidence matrix of a design [20], it follows that for the STS of interest

where and are the identity matrix and the all-one matrix of order . The determinant of can be easily found to be of the form

This proves the claimed result. Q.E.D.

Fig. 11. Performance of codes based on block-circulant parity-check matrices.

APPENDIX B PROOF OFLEMMA3.2

Let us start from an empty array and create the rows of by minimizing the number of used points. The first row can always be filled with points from the set . Put in the firstposition of the second row (now occurs twice) and start filling out the rest of the second row. Since the first element in the row is , we cannot use any other point from the first row.

Therefore, we must use points from the set . These points completely describe the second row.

We can put any number as the first element in the third row. If we choose this entry to be , then since already occurs twice, another row containing must be added to keep the number of occurrences of even. Therefore, we chose not to make the first entry , but rather a different number from the first row. Let this one be . Now is the first entry in the third row and occurs twice in the array. We continue filling the rest of the third row.

The points from the first row must be excluded, since is also in the first row. The points from the second row, except for , are all allowed so let us take the first available number . The rest of the third row ( positions) must be now filled with (new) numbers that are not in the second row. For these,

we choose . Suppose we continuine

this process until we arrive at the th row. Every point in the set occurs twice in the first rows of , and the point occurs exactly once (in the first row). Therefore, we have to continue appending rows so as to achieve an even number of occurrences of the point . The above procedure continues until rows are formed. However, must have

rows because the point and the points in the last column of occur only once in the array. Since, at this stage, there are exactly points that do not occur twice, we can take the points from the last column of and append them as the th row of , which completes the procedure. The number of “new”

(nonrepeated) points used to fill the th row is . The

total number of points used is which is

Fig. 12. Performance of CIDS-based codes.

equal to , the number of points in a generalized Pasch

configuration. Q.E.D.

APPENDIX C PROOF OFTHEOREM3.1

Take any distinct and and consider two base blocks and and the corresponding blocks obtained by adding to and . Notice that by adding to elements of , the resulting blocks remain in the orbit of . Create a

array , where . (Notice that since

and are base blocks, all the elements in are different.) The columns of contain blocks , and the rows of

contain blocks . Each element of

occurs exactly once in and once in , and, therefore, exactly twice in the set

. Q.E.D.

*Example C.1: For the example in*
Table I, the array is

and

is given in Example 3.3.

APPENDIX D PROOF OFLEMMA5.1

In order to show that the girth of the code is at least six, we have to show that there are no “rectangles” in the matrix , i.e., four ones that lie at the corners of a rectangle. Without loss of generality, consider two ones in the first row of . Two ones

that belong to the same row must necessarily belong to different permutation matrices, and the same is true for ones that belong to the same column. Hence, the distance between two ones in the same column is of the form

(D1) where , , are the exponents of the permutation ma- trices containing these two ones, respectively, and where the subscripts are taken modulo .

Next, consider the component-wise difference of the ordered exponents of the first block-row of permutation matrices and the ordered exponents

of the th block-row

Then all ’s are different and negative up to subscript number , and all different and positive for subscripts larger than . Next, define the following two variables:

Based on (D1), it follows that the distance between two ones in the same column for the first block-columns is at least

Since

it follows that no two ones in the same column can be at the same distance as any other pair of ones within a different column.

It can be easily shown that the codes with have girth at least eight. This follows from the observation that in order to have a cycle of length six in the Tanner graph, there should exist three columns containing pairs of ones described by their corre-

sponding row positions . This clearly

implies that one pair of ones must belong to the same column of one permutation matrix, which is impossible. The result re- garding the minimum distance of the codes is a straightforward consequence of the previous argument. Q.E.D.

APPENDIX E PROOF OFTHEOREM5.1

The proof is an extension of the Bose construction [50] for difference sets.

Take an arbitrary ordering of the set and define Consider the following two polynomials:

(E1) where and the indexes in are taken modulo

.

Assume there exist indexes such that

and . The

polynomial has coefficients in GF , degree at most one, and as its root. Since is a primitive element of GF , no nonzero polynomial over GF of degree smaller than four can have as a root. Hence, it follows that . There-

fore, which implies

and, consequently, . This contradicts the starting assumption.

Based on the previous argument, it follows that the elements of form a difference set modulo .

Assume next that that the indexes are as described before and

(E2) where the indexes are taken modulo . If , then the polynomial has coefficients from GF , degree at most three and as one of its root. Since is a primitive element of GF it follows that . Hence,

and consequently

or equivalently

One can distinguish several possible cases for which the two sets above are equivalent.

• , which implies

contradicting the starting assumption.

• , contradicting the starting

assumption.

• or . In the

first case, one arrives at the conclusion that , and in the second case one arrives at . Both of these results contradict the starting assumption.

Therefore, is a -fold cycle invariant difference set. Q.E.D.

APPENDIX F PROOF OFTHEOREM5.2

The codes described by (5.1) are even, and it is straightfor- ward to see that no two columns in the parity-check matrix are identical. Hence, it suffices to show that for no two block-rows of permutation matrices one can find four columns that add up to the zero-vector. If the number of permutation blocks per row is less than or equal to three, the result follows trivially. Hence, let , and assume that, on the contrary, there exist four columns, that sum up to zero. Furthermore, assume that the row indexes of the four ones in the first block-row and within the given columns

are .

It is clear from the construction that either

• all four columns belong to different permutation matrices;

• two columns belong to the same permutation matrix and two belong to two different permutation matrices; or

• two columns belong to one, while the other two belong to another permutation matrix.

An illustrative example for the first case of options is shown at the bottom of the page. Consider the first case, and assume without loss of generality that

(F1) Based on the cyclic construction of the parity-check matrix, the positions of the ones in the second block-row of permutation matrices and within the same columns are given by

, where

(F2) for some nonnegative integers and for different

(i.e., different elements from one of the cyclic shifts of the -fold cycle invariant difference set). In order for the columns to add up to the zero vector, one has to have

which, based on (F1), implies that

But this is impossible, since the integers them- selves belong to a difference set, and hence no two differences can be the same. For the second case and for the given row po- sitions in the first set of blocks, the row-indexes of ones in the second block-row have to be of the form

. Hence, if then the following equation has to be satisfied as well:

As in the previous case, this result contradicts the starting as- sumption that belong to a difference set. The last case can be treated in a similar manner as the second case,

with , implying

. This again contradicts the assumption that belong to a difference set.

Notice that since the argument presented above holds for any choice of two rows of blocks, it follows that the minimum dis- tance will be at least six for any number of row blocks.

Q.E.D.

APPENDIX G PROOF OFLEMMA6.1

Since is a prime, for each lattice point there exists exactly one line with slope that passes through the point . For each pair of lattice points, there is no more than one line that passes through both points. Therefore, the set of lines with

slopes is a -configuration. Q.E.D.

APPENDIX H PROOF OFLEMMA6.2

Consider a periodically extended lattice. We will show that it is not possible to construct a quadilateral (with no sides with infinite slope allowed), in which each point lies on two lines.

Fig. 5 shows one such quadilateral. Without loss of generality, we can assume that the starting point of two of the lines is . The slopes of four lines in Fig. 13 are: , , , and

. The points and are all

different and each of them lies on two lines. The remaining four points will be on two lines if at lest one of the following three conditions holds:

1) and

2) and

3) and

with all additions performed modulo . Case 1) implies

which means that the points and are

identical, a contradiction. For the remaining two cases, would have to be , which would imply that the two leftmost points are identical, again leading to a contradiction. Q.E.D.

APPENDIX I PROOF OFTHEOREM6.1

Let be an even integer. Assume that there exists a general- ized Pasch configuration in the set of lines determined by the

set of ordered pairs , where and

denote the starting point and the slope of the line, respectively.

Fig. 13. Quadrilateral in a lattice finite geometry.

In a generalized Pasch configuration, each point has to occur exactly twice. This implies that for , the set of points has to be such that for each , for exactly one . This is clearly impossible for even values of . On the other hand, assume that is odd, and that the set of blocks forming a generalized Pasch configuration is again spec- ified by the ordered pairs . By rotating the set of lines in the generalized Pasch configuration appropri- ately, one of the lines, say , can be taken to correspond to the line . Since the point has to belong to exactly two lines, there must exist another line in the configuration specified by , . Based on the previous discussion regarding the points with , it follows that without loss of generality, the blocks can be divided into pairs as follows:

Here, , for for any

. We will show next that that all lines of the configuration, except for the one defined by , have to intersect the line (note that there are such lines). Since is prime, for each pair there exists a unique value of such that . This implies that all lines differing from the line intersect the line , and all the points on this line have to belong to exactly two lines in the configuration.

But this is impossible, since is by assumption equal to the odd

prime . Q.E.D.

Note that for the parity-check matrix (5.1) is of di- mension and hence of no practical importance for code description.

APPENDIX J PROOF OFTHEOREM6.2

In order to construct a -configuration with girth eight, one has to eliminate those lines from the lattice that lead to the for- mation of triangles. Before proceeding with the proof of the the-