See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/228977165

Introducing Low-Density Parity-Check Codes

Article · May 2010

CITATIONS READS
127 8,513

1 author:

Sarah J Johnson
The University of Newcastle, Australia
164 PUBLICATIONS 4,025 CITATIONS

SEE PROFILE

All content following this page was uploaded by Sarah J Johnson on 21 May 2014.

The user has requested enhancement of the downloaded file.

Introducing Low-Density Parity-Check
Codes

Sarah J. Johnson
School of Electrical Engineering and Computer Science
The University of Newcastle
Australia
email: sarah.johnson@newcastle.edu.au
 Topic 1: Low-Density
Parity-Check Codes

1.1 Introduction
Low-density parity-check (LDPC) codes are forward error-correction codes,
first proposed in the 1962 PhD thesis of Gallager at MIT. At the time, their
incredible potential remained undiscovered due to the computational demands
of simulation in an era when vacumm tubes were only just being replaced by
the first transistors. They remained largely neglected for over 35 years. In the
mean time the field of forward error correction was dominated by highly struc-
tured algebraic block and convolutional codes. Despite the enormous practical
success of these codes, their performance fell well short of the theoretically
achievable limits set down by Shannon in his seminal 1948 paper. By the late
1980s, despite decades of attempts, researchers were largely resigned to this
seemingly insurmountable theory–practice gap.
The relative quiescence of the coding field was utterly transformed by the
introduction of “turbo codes,” proposed by Berrou, Glavieux and Thitimajshima
in 1993, wherein all the key ingredients of successful error correction codes
were replaced: turbo codes involve very little algebra, employ iterative, distrib-
uted algorithms, focus on average (rather than worst-case) performance, and
rely on soft (or probabilistic) information extracted from the channel. Overnight,
the gap to the Shannon limit was all but eliminated, using decoders with man-
ageable complexity.
As researchers struggled through the 1990s to understand just why turbo
codes worked as well as they did, two researchers, McKay and Neal, intro-
duced a new class of block codes designed to posses many of the features of the
new turbo codes. It was soon recognized that these block codes were in fact a
rediscovery of the LDPC codes developed years earlier by Gallager. Indeed, the
algorithm used to decode turbo codes was subsequently shown to be a special
case of the decoding algorithm for LDPC codes presented by Gallager so many
years before.
New generalizations of Gallager’s LDPC codes by a number of researchers
including Luby, Mitzenmacher, Shokrollahi, Spielman, Richardson and Ur-
banke, produced new irregular LDPC codes which easily outperform the best
turbo codes, as well as offering certain practical advantages and an arguably
cleaner setup for theoretical results. Today, design techniques for LDPC codes
exist which enable the construction of codes which approach the Shannon’s
capacity to within hundredths of a decibel.
So rapid has progress been in this area that coding theory today is in many
ways unrecognizable from its state just a decade ago. In addition to the strong

3
theoretical interest in LDPC codes, such codes have already been adopted in
satellite-based digital video broadcasting and long-haul optical communication
standards, are highly likely to be adopted in the IEEE wireless local area net-
work standard, and are under consideration for the long-term evolution of third-
generation mobile telephony.

1.2 Error correction using parity-checks

Here we will only consider binary messages and so the transmitted messages
consist of strings of 0’s and 1’s. The essential idea of forward error control cod-
ing is to augment these message bits with deliberately introduced redundancy
in the form of extra check bits to produce a codeword for the message. These
check bits are added in such a way that codewords are sufficiently distinct from
one another that the transmitted message can be correctly inferred at the re-
ceiver, even when some bits in the codeword are corrupted during transmission
over the channel.
The simplest possible coding scheme is the single parity check code (SPC).
The SPC involves the addition of a single extra bit to the binary message, the
value of which depends on the bits in the message. In an even parity code, the
additional bit added to each message ensures an even number of 1s in every
codeword.

Example 1.1.
The 7-bit ASCII string for the letter S is 1010011, and a parity bit is to be added
as the eighth bit. The string for S already has an even number of ones (namely
four) and so the value of the parity bit is 0, and the codeword for S is 10100110.

More formally, for the 7-bit ASCII plus even parity code we define a code-
word c to have the following structure:

c = [c1 c2 c3 c4 c5 c6 c7 c8 ],

where each ci is either 0 or 1, and every codeword satisfies the constraint

c1 ⊕ c2 ⊕ c3 ⊕ c4 ⊕ c5 ⊕ c6 ⊕ c7 ⊕ c8 = 0. (1.1)

Equation (1.1) is called a parity-check equation, in which the symbol ⊕ repre-

sents modulo-2 addition.

Example 1.2.
A 7-bit ASCII letter is encoded with the single parity check code from Exam-
ple 1.1. The resulting codeword was sent though a noisy channel and the string
y = [1 0 0 1 0 0 1 0] was received. To check if y is a valid codeword we test y
with (1.1).

y1 ⊕ y2 ⊕ y3 ⊕ y4 ⊕ y5 ⊕ y6 ⊕ y7 ⊕ y8 = 1 ⊕ 0 ⊕ 0 ⊕ 1 ⊕ 0 ⊕ 0 ⊕ 1 ⊕ 0 = 1.

Since the sum is 1, the parity-check equation is not satisfied and y is not a
valid codeword. We have detected that at least one error occurred during the
transmission.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 4 version 1.1
 While the inversion of a single bit due to channel noise can easily be de-
tected with a single parity check code, this code is not sufficiently powerful to
indicate which bit, or indeed bits, were inverted. Moreover, since any even num-
ber of bit inversions produces a string satisfying the constraint (1.1), patterns of
even numbers of errors go undetected by this simple code. Detecting more than
a single bit error calls for increased redundancy in the form of additional parity
bits and more sophisticated codes contain multiple parity-check equations and
each codeword must satisfy every one of them.

Example 1.3.
A code C consists of all length six strings

c = [c1 c2 c3 c4 c5 c6 ],

which satisfy all three parity-check equations:

c1 ⊕ c 2 ⊕ c 4 = 0
c2 ⊕ c 3 ⊕ c 5 = 0 (1.2)
c1 ⊕ c 2 ⊕ c 3 ⊕ c 6 = 0

Codeword constraints are often written in matrix form and so the constraints
of (1.2) become
 
c1
   c2   
1 1 0 1 0 0   c3 
 0
 0 1 1 0 1 0   =  0 . (1.3)
 c4 
1 1 1 0 0 1    0
| {z } c5 
H c6

The matrix H is called a parity-check matrix. Each row of H corresponds

to a parity-check equation and each column of H corresponds to a bit in the
codeword. Thus for a binary code with m parity-check constraints and length n
codewords the parity-check matrix is an m × n binary matrix. In matrix form a
string y = [c1 c2 c3 c4 c5 c6 ] is a valid codeword for the code with parity-check
matrix H if and only if it satisfies the matrix equation

HyT = 0. (1.4)

1.2.1 Encoding
To distinguish between the message bits and parity bits in the codeword in Ex-
ample 1.3 we re-write the code parity-check constraints so that each one solves
for a different codeword bit.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 5 version 1.1
Example 1.4.
The code constraints from Example 1.3 can be re-written as
c4 = c 1 ⊕ c 2
c5 = c 2 ⊕ c 3 (1.5)
c6 = c 1 ⊕ c 2 ⊕ c 3

The codeword bits c1 , c2 , and c3 contain the three bit message, c1 , c2 , and
c3 , while the codeword bits c4 , c5 and c6 contain the three parity-check bits.
Written this way the codeword constraints show how to encode the message.
Example 1.5.
Using the constraints in (1.5) the message 110 produces the parity-check bits
c4 = 1 ⊕ 1 = 0,
c5 = 1 ⊕ 0 = 1,
c6 = 1 ⊕ 1 ⊕ 0 = 0,
and so the codeword for this message is c = [1 1 0 0 1 0].

Again these constraints can be written in matrix form as follows:

 
    1 0 0 1 0 1
c1 c2 c3 c4 c5 c6 = c1 c2 c3  0 1 0 1 1 1 , (1.6)
0 0 1 0 1 1
| {z }
G

where the matrix G is called the generator matrix of the code. The message bits
are conventionally labeled by u = [u1 , u2 , · · · uk ], where the vector u holds the
k message bits. Thus the codeword c corresponding to the binary message
u = [u1 u2 u3 ] can be found using the matrix equation
c = uG. (1.7)
For a binary code with k message bits and length n codewords the generator
matrix, G, is a k × n binary matrix. The ratio k/n is called the rate of the code.
A code with k message bits contains 2k codewords. These codewords are a
subset of the total possible 2n binary vectors of length n.
Example 1.6.
Substituting each of the 23 = 8 distinct messages c1 c2 c3 = 000, 001, . . . , 111
into equation (1.7) yields the following set of codewords for the code from
Example 1.3:
[0 0 0 0 0 0] [0 0 1 0 1 1] [0 1 0 1 1 1] [0 1 1 1 0 0]
[1 0 0 1 0 1] [1 0 1 1 1 0] [1 1 0 0 1 0] [1 1 1 0 0 1] (1.8)
This code is called systematic because the first k codeword bits contain the
message bits. For systematic codes the generator matrix contains the k × k
identity, Ik , matrix as its first k columns. (The identity matrix, Ik , is a k × k
square binary matrix with ‘1’ entries on the diagonal from the top left corner to
the bottom right corner and ‘0’ entries everywhere else.)

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 6 version 1.1
 A generator matrix for a code with parity-check matrix H can be found by
performing Gauss-Jordan elimination on H to obtain it in the form
H = [A, In−k ], (1.9)
where A is an (n − k) × k binary matrix and In−k is the identity matrix of order
n − k. The generator matrix is then
G = [Ik , AT ]. (1.10)
The row space of G is orthogonal to H. Thus if G is the generator matrix for a
code with parity-check matrix H then
GH T = 0.
Before concluding this section we note that a block code can be described
by more than one set of parity-check constraints. A set of constraints is valid
for a code provided that equation (1.4) holds for all of the codewords in the
code. For low-density parity-check codes the choice of parity-check matrix is
particularly important.

Example 1.7.
The code C in Example 1.3 can also be described by four parity-check equa-
tions:
c1 ⊕ c 2 ⊕ c 4 = 0
c2 ⊕ c 3 ⊕ c 5 = 0
(1.11)
c1 ⊕ c 2 ⊕ c 3 ⊕ c 6 = 0
c3 ⊕ c 4 ⊕ c 6 = 0

The extra constraint in Example 1.7 is the linear combination of the 1-st
and 3-rd parity-check equations in and so the new equation is said to be linearly
dependent on the existing parity-check equations. In general, a code can have
any number of parity-check constraints but only n − k of them will be linearly
independent, where k is the number of message bits in each codeword. In matrix
notation n − k is the rank of H
n − k = rank2 (H), (1.12)
where rank2 (H) is the number of rows in H which are linearly dependent over
GF(2).

1.2.2 Error detection and correction

Suppose a codeword has been sent down a binary symmetric channel and one
or more of the codeword bits may have been flipped. The task, outline in this
section and the following, is to detect any flipped bits and, if possible, to correct
them.
Firstly, we know that every codeword in the code must satisfy (1.4), and so
errors can be detected in any received word which does not satisfy this equation.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 7 version 1.1
Example 1.8.
The codeword c = [1 0 1 1 1 0] from the code in Example 1.3 was sent through
a binary symmetric channel and the the string y = [1 0 1 0 1 0] received.
Substitution into equation (1.4) gives
 
1
  0   
1 1 0 1 0 0   1 
 1
T
Hy = 0 1 1 0 1 0  
   =  0 . (1.13)
0 
1 1 1 0 0 1   1 
 0
0

The result is nonzero and so the string y is not a codeword of this code. We
therefore conclude that bit flipping errors must have occurred during transmis-
sion.

The vector
s = HyT ,
is called the syndrome of y. The syndrome indicates which parity-check con-
straints are not satisfied by y.

Example 1.9.
The result of Equation 1.13, in Example 1.8, (i.e. the syndrome) indicates that
the first parity-check equation in H is not satisfied by y. Since this parity-check
equation involves the 1-st, 2-nd and 4-th codeword bits we can conclude that at
least one of these three bits has been inverted by the channel.

Example 1.8 demonstrates the use of a block code to detect transmission

errors, but suppose that the channel was even noisier and three bits were flipped
to produce the string y = [0 0 1 0 1 1]. Substitution into (1.4) tells us that y
is a valid codeword and so we cannot detect the transmission errors that have
occurred. In general, a block code can only detect a set of bit errors if the errors
don’t change one codeword into another.
The Hamming distance between two codewords is defined as the number of
bit positions in which they differ. For example the codewords [1 0 1 0 0 1 1 0]
and [1 0 0 0 0 1 1 1] differ in two positions, the third and eight codeword
bits, so the Hamming distance between them is two. The measure of the ability
of a code to detect errors is the minimum Hamming distance or just minimum
distance of the code. The minimum distance of a code, dmin , is defined as the
smallest Hamming distance between any pair of codewords in the code. For the
code in Example 1.3, dmin = 3, so the corruption of three or more bits in a
codeword can result in another valid codeword. A code with minimum distance
dmin , can always detect t errors whenever

t < dmin . (1.14)

To go further and correct the bit flipping errors requires that the decoder
determine which codeword was most likely to have been sent. Based only on

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 8 version 1.1
knowing the binary received string, y, the best decoder will choose the code-
word closest in Hamming distance to y. When there is more than one codeword
at the minimum distance from y the decoder will randomly choose one of them.
This decoder is called the maximum likelihood (ML) decoder as it will always
chose the codeword which is most likely to have produced y.
Example 1.10.
In Example 1.8 we detected that the received string y = [1 0 1 0 1 0] was
not a codeword of the code in Example 1.3. By comparing y with each of the
codewords in this code, (1.8), the ML decoder will choose c = [1 0 1 1 1 0], as
the closest codeword as it is the only codeword Hamming distance 1 from y.

The minimum distance of the code in Example 1.8 is 3, so a single bit

flipped always results in a string y closer to the codeword which was sent than
any other codeword and thus can always be corrected by the ML decoder. How-
ever, if two bits are flipped in y there may be a different codeword which is
closer to y than the one which was sent, in which case the decoder will choose
an incorrect codeword.
Example 1.11.
The codeword c = [1 0 1 1 1 0] from the code in Example 1.3 was transmitted
through a channel which introduced two flipped bits producing the string y =
[0 0 1 0 1 0]. By comparison of y with each of the codewords of this code,
(1.8), the ML decoder will choose c = [0 0 1 0 1 1] as the closest decoder as
it is Hamming distance one from y. In this case the ML decoder has actually
added errors rather than corrected them.

In general, for a code with minimum distance dmin , e bit flips can always
be corrected by choosing the closest codeword whenever
e ≤ ⌊(dmin − 1)/2⌋, (1.15)
where ⌊x⌋ is the largest integer that is at most x.
The smaller the code rate the smaller the subset of 2n binary vectors which
are codewords and so the better the minimum distance that can be achieved
by a code with length n. The importance of the code minimum distance in
determining its performance is reflected in the description of block codes by the
three parameters (n, k, dmin ).
Error correction by directly comparing the received string to every other
codeword in the code, and choosing the closest, is called maximum likelihood
decoding because it is guaranteed to return the most likely codeword. How-
ever, such an exhaustive search is feasible only when k is small. For codes
with thousands of message bits in a codeword it becomes far too computation-
ally expensive to directly compare the received string with every one of the 2k
codewords in the code. Numerous ingenious solutions have been proposed to
make this task less complex, including choosing algebraic codes and exploiting
their structure to speed up the decoding or, as for LDPC codes, devising decod-
ing methods which are not ML but which can perform very well with a much
reduced complexity.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 9 version 1.1
1.3 Low-density parity-check (LDPC) codes
As their name suggests, LDPC codes are block codes with parity-check matrices
that contain only a very small number of non-zero entries. It is the sparseness of
H which guarantees both a decoding complexity which increases only linearly
with the code length and a minimum distance which also increases linearly with
the code length.
Aside from the requirement that H be sparse, an LDPC code itself is no dif-
ferent to any other block code. Indeed existing block codes can be successfully
used with the LDPC iterative decoding algorithms if they can be represented by
a sparse parity-check matrix. Generally, however, finding a sparse parity-check
matrix for an existing code is not practical. Instead LDPC codes are designed by
constructing a sparse parity-check matrix first and then determining a generator
matrix for the code afterwards.
The biggest difference between LDPC codes and classical block codes is
how they are decoded. Classical block codes are generally decoded with ML
like decoding algorithms and so are usually short and designed algebraically
to make this task less complex. LDPC codes however are decoded iteratively
using a graphical representation of their parity-check matrix and so are designed
with the properties of H as a focus.
An LDPC code parity-check matrix is called (wc ,wr )-regular if each code
bit is contained in a fixed number, wc , of parity checks and each parity-check
equation contains a fixed number, wr , of code bits.

Example 1.12.
A regular parity-check matrix for the code in Example 1.3 with wc = 2, wr = 3
and rank2 (H) = 3, which satisfies (1.4) is
 
1 1 0 1 0 0
 0 1 1 0 1 0 
H=  1 0 0 0 1 1 .
 (1.16)
0 0 1 1 0 1

For an irregular parity-check matrix we designate the fraction of columns

of weight i by vi and the fraction of rows of weight i by hi . Collectively the set
v and h is called the degree distribution of the code.

Example 1.13.
The parity-check matrix in Equation 1.3 is irregular with degree distribution
v1 = 1/2, v2 = 1/3, v3 = 1/6, h3 = 2/3 and h4 = 1/3.

A regular LDPC code will have,

m · wr = n · wc , (1.17)
ones in its parity-check matrix. Similarly, for an irregular code
X X
m( hi · i) = n( vi · i). (1.18)
i i

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 10 version 1.1
1.3.1 LDPC constructions
The construction of binary LDPC codes involves assigning a small number of
the values in an all-zero matrix to be 1 so that the rows and columns have the
required degree distribution.
The original LDPC codes presented by Gallager are regular and defined
by a banded structure in H. The rows of Gallager’s parity-check matrices are
divided into wc sets with M/wc rows in each set. The first set of rows contains
wr consecutive ones ordered from left to right across the columns. (i.e. for
i ≤ M/wc , the i-th row has non zero entries in the ((i − 1)K + 1)-th to i-th
columns). Every other set of rows is a randomly chosen column permutation of
this first set. Consequently every column of H has a ‘1’ entry once in every one
of the wc sets.

Example 1.14.
A length 12 (3,4)-regular Gallager parity-check matrix is
 
1 1 1 1 0 0 0 0 0 0 0 0
 0 0 0 0 1 1 1 1 0 0 0 0 
 

 0 0 0 0 0 0 0 0 1 1 1 1 


 1 0 1 0 0 1 0 0 0 1 0 0 

H=
 0 1 0 0 0 0 1 1 0 0 0 1 .


 0 0 0 1 1 0 0 0 1 0 1 0 


 1 0 0 1 0 0 1 0 0 1 0 0 

 0 1 0 0 0 1 0 1 0 0 1 0 
0 0 1 0 1 0 0 0 1 0 0 1

Another common construction for LDPC codes is a method proposed by

MacKay and Neal. In this method columns of H are added one column at a
time from left to right. The weight of each column is chosen to obtain the
correct bit degree distribution and the location of the non-zero entries in each
column chosen randomly from those rows which are not yet full. If at any point
there are rows with more positions unfilled then there are columns remaining to
be added, the row degree distributions for H will not be exact. The process can
be started again or back tracked by a few columns, until the correct row degrees
are obtained.

Example 1.15.
A length 12 (3,4)-regular MacKay Neal parity-check matrix is
 
1 0 0 0 0 1 0 1 0 1 0 0

 1 0 0 1 1 0 0 0 0 0 1 0 


 0 1 0 0 1 0 1 0 1 0 0 0 


 0 0 1 0 0 1 0 0 0 0 1 1 

H=
 0 0 1 0 0 0 1 1 0 0 0 1 .


 0 1 0 0 1 0 0 0 1 0 1 0 


 1 0 0 1 0 0 1 0 0 1 0 0 

 0 1 0 0 0 1 0 1 0 1 0 0 
0 0 1 1 0 0 0 0 1 0 0 1

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 11 version 1.1
When adding the 11-th column, shown in bold, the unfilled rows were the 2-nd
4-th, 5-th, 6-th and 9-th from which the 2-nd, 4-th and 6-th were chosen.

Another type of LDPC codes called repeat-accumulate codes have weight-

2 columns in a step pattern for the last m columns of H. This structure makes
the repeat-accumulate codes systematic and allows them to be easily encoded.

Example 1.16.
A length 12 rate-1/4 repeat-accumulate code is
 
1 0 0 1 0 0 0 0 0 0 0 0
 1 0 0 1 1 0 0 0 0 0 0 0 
 
 0 1 0 0 1 1 0 0 0 0 0 0 
 
 0 0 1 0 0 1 1 0 0 0 0 0 
 
H=  0 0 1 0 0 0 1 1 0 0 0 0 .

 0 1 0 0 0 0 0 1 1 0 0 0 
 
 1 0 0 0 0 0 0 0 1 1 0 0 
 
 0 1 0 0 0 0 0 0 0 1 1 0 
0 0 1 0 0 0 0 0 0 0 1 1
The first three columns of H correspond to the message bits. The first parity-bit
(the fourth column of H) can be encoded as c4 = c1 , the second as c5 = c4 ⊕ c1
and the next as c6 = c5 ⊕ c2 and so on. In this way each parity-bit can be
computed one at a time using only the message bits and the one previously
calculated parity-bit.

Since LDPC codes are often constructed pseudo-randomly we often talk

about the set (or ensemble) of all possible codes with certain parameters (for
example a certain degree distribution) rather than about a particular choice of
parity-check matrix with those parameters.
LDPC codes are often represented in graphical form by a Tanner graph.
The Tanner graph consists of two sets of vertices: n vertices for the codeword
bits (called bit nodes), and m vertices for the parity-check equations (called
check nodes). An edge joins a bit node to a check node if that bit is included
in the corresponding parity-check equation and so the number of edges in the
Tanner graph is equal to the number of ones in the parity-check matrix.

Example 1.17.
The Tanner graph of the parity-check matrix Example 1.12 is shown in Fig. 1.1.
The bit vertices are represented by circular nodes and the check vertices by
square nodes.

The Tanner graph is sometimes drawn vertically with the bit nodes on the
left and check nodes on the right with bit nodes sometimes referred to as left
nodes or variable nodes and the check nodes as right nodes or constraint nodes.
For a systematic code the message bit nodes can be distinguished from the parity
bit nodes by placing them on separate sides of the graph.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 12 version 1.1
 check nodes

bit nodes

Figure 1.1: The Tanner graph representation of the parity-check matrix in

(1.16). A 6-cycle is shown in bold.

bit nodes (message-bits)

bit nodes (parity-bits)

Figure 1.2: The Tanner graph representation of the parity-check matrix in Ex-
ample 1.16

Example 1.18.
The Tanner graph of the parity-check matrix in Example 1.16 is shown in
Fig. 1.2. The message bit nodes are shown at the top of the graph and the
parity bit nodes at the bottom.

A cycle in a Tanner graph is a sequence of connected vertices which start

and end at the same vertex in the graph, and which contain other vertices no
more than once. The length of a cycle is the number of edges it contains, and
the girth of a graph is the size of its smallest cycle.

Example 1.19.
A cycle of size 6 is shown in bold in Fig. 1.1.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 13 version 1.1
 The Mackay Neal construction method for LDPC codes can be adapted to
avoid cycles of length 4, called 4-cycles, by checking each pair of columns in
H to see if they overlap in two places. The construction of 4-cycle free codes
using this method is given in Algorithm 1. Input is the code length n, rate r, and
column and row degree distributions v and h. The vector α is a length n vector
which contains an entry i for each column in H of weight i and the vector β is
a length m vector which contains an entry i for each row in H of weight i.

Algorithm 1 MacKay Neal LDPC Codes

1: procedure MN C ONSTRUCTION(n,r,v,h) ⊲ Required length, rate and
degree distributions
2: H = all zero n(1 − r) × n matrix ⊲ Initialization
3: α = [];
4: for i = 1 : max(v) do
5: for j = 1 : vi × n do
6: α = [α, i]
7: end for
8: end for
9: β = []
10: for i = 1 : max(h) do
11: for j = 1 : hi × m do
12: β = [β, i]
13: end for
14: end for
15:
16: for i = 1 : n do ⊲ Construction
17: c = random subset of β, of size αi
18: for j = 1 : αi do
19: H(cj , i) = 1
20: end for
21: α=α−c
22: end for
23:
24: repeat
25: for i = 1 : n − 1 do ⊲ Remove 4-cycles
26: for j = i + 1 S: n do
27: if |H(:, i) H(:, j)| > 1 then
28: permute the entries in the j-th column
29: end if
30: end for
31: end for
32: until cycles removed
33: end procedure

Removing the 4-cycles does have the effect of disturbing the row degree dis-
tribution. For long codes H will be very sparse and so 4-cycles very uncommon
and the effect on the row degrees will be negligible. However, for short codes
4-cycle free parity-check matrices can be constructed much more effectively by

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 14 version 1.1
using algebraic methods, as we will see later.
Alternatively, the Mackay Neal construction method for LDPC codes can
be adapted to avoid 4-cycles, without disturbing the row degree distribution, by
checking each column before it is added to see if it will cause a cycle with any
of the already chosen columns and rejecting it if it does.

Example 1.20.
If a 4-cycle free code was required in Example 1.15 the fourth column would
have been discarded, and a new one chosen, because it causes a 4-cycle with
the first column in H.

1.3.2 Encoding
Earlier we noted that a generator matrix for a code with parity-check matrix H
can be found by performing Gauss-Jordan elimination on H to obtain it in the
form
H = [A, In−k ],
where A is a (n − k) × k binary matrix and In−k is the size n − k identity
matrix. The generator matrix is then

G = [Ik , AT ].

Here we will go into this process in more detail using an example.

Example 1.21.
We wish to encode the length 10 rate-1/2 LDPC code
 
1 1 0 1 1 0 0 1 0 0
 0 1 1 0 1 1 1 0 0 0 
 
H=  0 0 0 1 0 0 0 1 1 1 .

 1 1 0 0 0 1 1 0 1 0 
0 0 1 0 0 1 0 1 0 1

First, we put H into row-echelon form (i.e. so that in any two successive rows
that do not consist entirely of zeros, the leading 1 in the lower row occurs further
to the right than the leading 1 in the higher row).
The matrix H is put into this form by applying elementary row operations
in GF (2), which are; interchanging two rows or adding one row to another
modulo 2. From linear algebra we know that by using only elementary row
operations the modified parity-check matrix will have the same codeword set
as the original, (as the new system of linear equations will have an unchanged
solution set).
The 1-st and 2-nd columns of H already have ones on the diagonal and
entries in these columns below the diagonal are removed by replacing the 4-th
row with the modulo-2 sum of the 1-st and 4-th rows. The 3-rd column of H
does not have a one on the diagonal but this can be obtained by swapping the

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 15 version 1.1
3-rd and 5-th rows. Finally, replacing the 5-th row with the modulo two sum of
the 5-th and 4-th rows gives Hr in row-echelon form:
 
1 1 0 1 1 0 0 1 0 0
 0 1 1 0 1 1 1 0 0 0 
 
Hr =  0 0 1 0 0 1 0 1 0 1 .

 0 0 0 1 1 1 1 1 1 0 
0 0 0 0 1 1 1 0 0 1
Next the parity-check matrix is put into reduced row-echelon form (i.e. so that
any column that contains a leading one has zeros everywhere else). The 1-st
column is already correct and the entry in the 2-nd column above the diagonal
is removed by replacing the 1-st row with the modulo-2 sum of the 1-st and 2-
nd rows. Similarly the entry in the 3-nd column above the diagonal is removed
by replacing the 2-nd row with the modulo-2 sum of the 2-nd and 3-rd rows. To
clear the 4-th column the 1-st row is replace with the modulo-2 sum of the 1-st
and 4-th rows. Finally, to clear the 5-th column involves adding the 5-th row to
the 1-st, 2-nd and 4-th rows gives Hrr in reduced row-echelon form:
 
1 0 0 0 0 0 1 1 1 0
 0 1 0 0 0 1 0 1 0 0 
 
Hrr =   0 0 1 0 0 1 0 1 0 1 .

 0 0 0 1 0 0 0 1 1 1 
0 0 0 0 1 1 1 0 0 1
Lastly, using column permutations we put the parity-check matrix into stan-
dard form (where the last m columns of Hstd are the m columns of Hrr which
contain the leading ones):
 
0 1 1 1 0 1 0 0 0 0
 1 0 1 0 0 0 1 0 0 0 
 
 1 0 1 0 1 0 0 1 0 0 .
Hstd =  
 0 0 1 1 1 0 0 0 1 0 
1 1 0 0 1 0 0 0 0 1
In this final step column permutations have been used and so the codewords
of Hstd will be permuted versions of the codewords corresponding to H. A
solution is to keep track of the column permutation used to create Hstd , which
in this case is
 
Π = 6 7 8 9 10 1 2 3 4 5 ,
and apply the inverse permutation to each Hstd codeword before it is transmit-
ted.
Alternatively, if the channel is memoryless, and so the order of codeword
bits is unimportant, a far easier option is to apply Π to the original H to give a
parity-check matrix
 
1 1 0 1 1 0 0 1 0 0
 0 1 1 0 1 1 1 0 0 0 
′
 
H =  0 0 0 1 0 0 0 1 1 1 

 1 1 0 0 0 1 1 0 1 0 
0 0 1 0 0 1 0 1 0 1

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 16 version 1.1
with the same properties as H but which shares the same codeword bit ordering
as Hstd .
Finally, a generator G for the code with parity-check matrices Hstd and H ′
is given by  
1 0 0 0 0 0 1 1 0 1
 0 1 0 0 0 1 0 0 0 1 
 
G=  0 0 1 0 0 1 1 1 1 0 .

 0 0 0 1 0 1 0 0 1 0 
0 0 0 0 1 0 0 1 1 1

All of this processing can be done off-line and just the matrices G and H ′
provided to the encoder and decoder respectively. However, the drawback of
this approach is that, unlike H, the matrix G will most likely not be sparse and
so the matrix multiplication
c = uG,
at the encoder will have complexity in the order of n2 operations. As n is
large for LDPC codes, from thousands to hundreds of thousands of bits, the
encoder can become prohibitively complex. Later we will see that structured
parity-check matrices can be used to significantly lower this implementation
complexity, however for arbitrary parity-check matrices a good approach is to
avoid constructing G at all and instead to encode using back substitution with
H as is demonstrated in the following.

(Almost) linear-time encoding for LDPC codes

Rather than finding a generator matrix for H, an LDPC code can be encoded
using the parity-check matrix directly by transforming it into upper triangular
form and using back substitution. The idea is to do as much of the transforma-
tion as possible using only row and column permutations so as to keep as much
of H as possible sparse.
Firstly, using only row and column permutations, the parity-check matrix is
put into approximate lower triangular form:
 
A B T
Ht = ,
C D E

where the matrix T is a lower triangular matrix (that is T has ones on the
diagonal from left to right and all entries above the diagonal zero) of size
(m − g) × (m − g). If Ht is full rank the matrix B is size m − g × g and
A is size m − g × k. The g rows of H left in C, D, and E are called the
gap of the approximate representation and the smaller g the lower the encoding
complexity for the LDPC code.

Example 1.22.
We wish to encode the message u = [1 1 0 0 1] with the same length 10

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 17 version 1.1
rate-1/2 LDPC code from Example 1.21:
 
1 1 0 1 1 0 0 1 0 0
 0 1 1 0 1 1 1 0 0 0 
 
H=  0 0 0 1 0 0 0 1 1 1 .

 1 1 0 0 0 1 1 0 1 0 
0 0 1 0 0 1 0 1 0 1

Instead of putting H into reduced row-echelon form we put it into approximate

lower triangular form using only row and column swaps. For this H we swap
the 2-nd and 3-rd rows and 6-th and 10-th columns to obtain:
 
1 1 0 1 1 0 0 1 0 0
 0 0 0 1 0 1 0 1 1 0 
 
Ht =  0 1 1 0 1 0 1 0 0 1 .

 1 1 0 0 0 0 1 0 1 1 
0 0 1 0 0 1 0 1 0 1

with a gap of two.

Once in upper triangular format, Gauss-Jordan elimination is applied to clear E

which is equivalent to multiplying Ht by
 
Im−g 0
,
−ET −1 Ig

to give    
Im−g 0 A B T
H̃ = −1 Ht =
−ET Ig C̃ D̃ 0
where
C̃ = −ET −1 A + C,
and
D̃ = −ET −1 B + D.

Example 1.23.
Continuing from Example 1.22 we have
 
1 0 0
T −1 =  1 1 0  ,
0 0 1

and  
1 0 0 0 0
   0 1 0 0 0 
Im−g 0  
= 0 0 1 0 0 ,
−ET −1 Ig  
 1 1 1 1 0 
1 0 1 0 1

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 18 version 1.1
to give  
1 1 0 1 1 0 0 1 0 0

 0 0 0 1 0 1 0 1 1 0 

H̃ = 
 0 1 1 0 1 0 1 0 0 1 .

 0 1 1 0 0 1 0 0 0 0 
1 0 0 1 0 1 1 0 0 0

When applying Gauss-Jordan elimination to clear E only C̃ and D̃ are effected,

the rest of the parity-check matrix remains sparse.
Finally, to encode using H̃ the codeword c = [c1 c2 , . . . , cn ] is divided into
three parts, c = [u, p1 , p2 ], where u = [u1 , u2 , . . . , uk ] is the k-bit message,
p1 = [p11 , p12 , . . . , p1g ], holds the first g parity bits and p2 = [p21 , p22 , . . . , p2m−g ]
holds the remaining parity bits.
The codeword c = [u, p1 , p2 ] must satisfy the parity-check equation cH̃ T =
0 and so
Au + Bp1 + T p2 = 0, (1.19)
and
C̃u + D̃p1 + 0p2 = 0. (1.20)
Since E has been cleared, the parity bits in p1 depend only on the message
bits, and so can be calculated independently of the parity bits in p2 . If D̃ is
invertible, p1 can be found from (1.20):

p1 = D̃−1 C̃u. (1.21)

If D̃ is not invertible the columns of H̃ can be permuted until it is. By keeping

g as small as possible the added complexity burden of the matrix multiplication
in Equation 1.21, which is (g 2 ), is kept low.
Once p1 is known p2 can be found from (1.19):

p2 = −T −1 (Au + Bp1 ), (1.22)

where the sparseness of A, B and T can be employed to keep the complexity

of this operation low and, as T is upper triangular, p2 can be found using back
substitution.

Example 1.24.
Continuing from Example 1.23 we partition the length 10 codeword c = [c1 , c2 , . . . , c10 ]
as c = [u, p1 , p2 ] where p1 = [c6 , c7 ] and p2 = [c8 , c9 , c10 ]. The parity bits
in p1 are calculated from the message using Equation 1.21:
 
1
   1 
1 0 0 1 1 0 0    
p1 = D̃−1 C̃u =  0 = 1 0
1 1 1 0 0 1 0   0 


Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 19 version 1.1
As T is upper-triangular the bits in p2 can then be calculated using back sub-
stitution.

p21 = u1 ⊕ u2 ⊕ u4 ⊕ u5 = 1 ⊕ 1 ⊕ 0 ⊕ 1 = 1
p22 = u4 ⊕ p11 ⊕ p21 = 0 ⊕ 1 ⊕ 1 = 0
p23 = u2 ⊕ u3 ⊕ u5 ⊕ p12 = 1 ⊕ 0 ⊕ 1 ⊕ 0 = 0

and the codeword is c = [1 1 0 0 1 1 0 1 0 0].

Again column permutations were used to obtain Ht from H and so either

Ht , or H with the same column permutation applied, will be used at the decoder.
Note that since the parity-check matrix used to compute G in Example 1.21
is a column permuted version of Ht , the set of codewords generated by both
encoders will not be the same.

1.4 Bibliographic notes

LDPC codes were first introduced by Gallager in his 1962 thesis [1]. In his
work, Gallager used a graphical representation of the bit and parity-check sets
of regular LDPC codes, to describe the application of iterative decoding. The
systematic study of codes on graphs however is largely due to Tanner who, in
1981, formalized the use of bipartite graphs for describing families of codes [2].
Irregular LDPC codes were first proposed by a group of researchers in the
late 90’s [3, 4] and it is these codes which can produce performances within a
fraction of a decibel from capacity [5].
The encoding algorithm presented here is from [6] and the two pseudo-
random constructions we have considered can be found in [1] and [7]. For more
detail on classical block codes we like the error correction texts [8], and [9] or,
for those interested in a more mathematical treatment, [10] and [11].

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 20 version 1.1
 Topic 2: Message-Passing
Decoding

The class of decoding algorithms used to decode LDPC codes are collectively
termed message-passing algorithms since their operation can be explained by
the passing of messages along the edges of a Tanner graph. Each Tanner graph
node works in isolation, only having access to the information contained in the
messages on the edges connected to it. The message-passing algorithms are also
known as iterative decoding algorithms as the messages pass back and forward
between the bit and check nodes iteratively until a result is achieved (or the
process halted). Different message-passing algorithms are named for the type
of messages passed or for the type of operation performed at the nodes.
In some algorithms, such as bit-flipping decoding, the messages are binary
and in others, such as belief propagation decoding, the messages are probabil-
ities which represent a level of belief about the value of the codeword bits. It
is often convenient to represent probability values as log likelihood ratios, and
when this is done belief propagation decoding is often called sum-product de-
coding since the use of log likelihood ratios allows the calculations at the bit
and check nodes to be computed using sum and product operations.

2.1 Message-passing on the binary erasure channel

On the binary erasure channel (BEC) a transmitted bit is either received cor-
rectly or completely erased with some probability ε. Since the bits which are
received are always completely correct the task of the decoder is to determine
the value of the unknown bits.
If there exists a parity-check equation which includes only one erased bit
the correct value for the erased bit can be determined by choosing the value
which satisfies even parity.

Example 2.1.
The code in example 1.3 includes the parity-check equation

c1 ⊕ c2 ⊕ c4 = 0.

If the value of bit c1 is known to be ‘0’ and the value of bit c2 is known to be ‘1’,
then the value of bit c4 must be ‘1’ if c1 , c2 and c4 are part of a valid codeword
for this code.

In the message-passing decoder each check node determines the value of an

erased bit if it is the only erased bit in its parity-check equation.

21
 The messages passed along the Tanner graph edges are straightforward: a
bit node sends the same outgoing message M to each of its connected check
nodes. This message, labeled Mi for the i-th bit node, declares the value of the
bit ‘1’, ‘0’ if it is known or ‘x’ if it is erased. If a check node receives only
one ‘x’ message, it can calculate the value of the unknown bit by choosing the
value which satisfies parity. The check nodes send back different messages to
each of their connected bit nodes. This message, labeled Ej,i for the message
from the j-th check node to the i-th bit node, declares the value of the i-bit ‘1’,
‘0’ or ‘x’ as determined by the j-th check node. If the bit node of an erased bit
receives an incoming message which is ‘1’ or ‘0’ the bit node changes its value
to the value of the incoming message. This process is repeated until all of the
bit values are known, or until some maximum number of decoder iterations has
passed and the decoder gives up.
We use the notation Bj to represent the set of bits in the j-th parity-check
equation of the code. So for the code in Example 1.12 we have

B1 = {1, 2, 4}, B2 = {2, 3, 5}, B3 = {1, 5, 6}, B4 = {3, 4, 6}.

Similarly, we use the notation Ai to represent the parity-check equations which

check on the i-th bit of the code. So for the code in Example 1.12 we have

A1 = {1, 3}, A2 = {1, 2}, A3 = {2, 4}, A5 = {1, 4}, A5 = {2, 3}, A6 = {3, 4}.

Algorithm 2 outlines message-passing decoding on the BEC. Input is the

received values from the detector, y = [y1 , . . . , yn ] which can be ‘1’, ‘0’ or ‘x’,
and output is M = [M1 , . . . , Mn ] which can also take the values ‘1’, ‘0’ or ‘x’.

Example 2.2.
The LDPC code from Example 1.12 is used to encode the codeword

c = [0 0 1 0 1 1].

c is sent though an erasure channel and the vector

y = [0 0 1 x x x]

is received. Message-passing decoding is used to recover the erased bits.

Initialization is Mi = ri so

M = [0 0 1 x x x].

For Step 1 the check node messages are calculated. The 1-st check node is
joined to the 1-st, 2-nd and 4-th bit nodes, and so has incoming messages ‘1’,
‘0’ and ‘x. Since the check node has one incoming ‘x’ message, from the 4-th
bit node, its outgoing message on this edge, E1,4 , will be the value of the 4-th
codeword bit:
E1,4 = M1 ⊕ M2
= 0⊕0
= 0.
The 2-nd check includes the 2-nd, 3-rd and 5-th bits, and so has incoming mes-
sages ‘0’, ‘1’ and ‘x. Since the check node has one incoming ‘x’ message, from

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 22 version 1.1
Algorithm 2 Erasure Decoding
1: procedure D ECODE(y)
2:
3: I=0 ⊲ Initialization
4: for i = 1 : n do
5: M i = yi
6: end for
7: repeat
8:
9: for j = 1 : m do ⊲ Step 1: Check messages
10: for all i ∈ Bj do
11:
P into check j other than Mi are known then
if all messages
12: Ej,i = i′ ∈Bj ,i′ 6=i (Mi′ mod 2)
13: else
14: Ej,i = ‘x’
15: end if
16: end for
17: end for
18:
19: for i = 1 : n do ⊲ Step 2: Bit messages
20: if Mi = ‘unknown’ then
21: if there exists a j ∈ Ai s.t. Ej,i 6= ‘x’ then
22: Mi = Ej,i
23: end if
24: end if
25: end for
26:
27: if all Mi known or I = Imax then ⊲ Test
28: Finished
29: else
30: I =I +1
31: end if
32: until Finished
33: end procedure

the 5-th bit node, its outgoing message on this edge, E2,5 , will be the value of
the 5-th codeword bit:
E2,5 = M2 ⊕ M3
= 0⊕1
= 1.
The 3-rd check includes the 1-st, 5-th and 6-th bits, and so has incoming mes-
sages ‘0’, ‘x’ and ‘x’. Since this check node receives two ‘x’ messages, it can-
not be used to determine the value of any of the bits. In this case the outgoing
messages from the check node are all ‘x’. Similarly, the 4-th check includes the
3-rd, 4-th and 6-th bits and so receives two ‘x’ messages and thus also cannot
used to determine the value of any of the bits.
In Step 2 each bit node that has an unknown value uses its incoming mes-

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 23 version 1.1
sages to update its value if possible. The 4-th bit is unknown and has incoming
message, of ‘0’ (E1,4 ) and ‘x’ (E4,4 ) and so it changes its value to ‘0’. The
5-th bit is also unknown and has an incoming messages of ‘1’ (E2,5 ) and ‘x’
(E3,5 ) and so it changes its value to ‘1’. The 6-th bit is also unknown but it has
incoming messages of ‘x’ (E3,6 ) and ‘x’ (E4,6 ) so it cannot change its value.
At the end of Step 2 we thus have

M = [0 0 1 0 1 x].

For the test, there is a remaining unknown bit (the 6-th bit) and so the algo-
rithm continues.
Repeating Step 1 the 3-rd check node is joined to the 1-st, 5-th and 6-th
bit nodes, and so this check node has one incoming ‘x’ message, M6 . The
outgoing message from this check to the 6-th bit node, E3,6 , is the value of the
6-th codeword bit.
E3,6 = M1 ⊕ M5
= 1⊕0
= 1.
The 4-th check node is joined to the 3-rd, 4-th and 6-th bit nodes, and so the this
check node has one incoming ‘x’ message, M6 . The outgoing message from
this check to the 6-th bit node, E4,6 , is the value of the 6-th codeword bit.

E3,6 = M3 ⊕ M4
= 0⊕1
= 1.

In Step 2 the 6-th bit is unknown and has incoming messages, E3,6 and E4,6
with value ‘1’ and so it changes its value to ‘1’. Since the received bits from
the channel are always correct the messages from the check nodes will always
agree. (In the bit-flipping algorithm we will see a strategy for when this is not
the case.)
This time at the test there are no unknown codeword bits and so the algorithm
halts and returns
M = [0 0 1 0 1 1]
as the decoded codeword. The received string has therefore been correctly de-
termined despite half of the codeword bits having been erased. Fig 2.1 shows
graphically the messages passed in the message-passing decoder.

Since the received bits in an erasure channel are either correct or unknown
(no errors are introduced by the channel) the messages passed between nodes
are always the correct bit values or ‘x’. When the channel introduces errors into
the received word, as in the binary symmetric or AWGN channels, the messages
in message-passing decoding are instead the best guesses of the codeword bit
values based on the current information available to each node.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 24 version 1.1
 Initialization

0 0 1 x x x

check messages bit messages

0 0 1 0 1 x
check messages bit messages

0 0 1 0 1 1

Figure 2.1: Message-passing decoding of the received string y = [0 0 1 x x x]. Each sub-
figure indicates the decision made at each step of the decoding algorithm based on the messages
from the previous step. For the messages, a dotted arrow corresponds to the messages “bit = 0”
while a solid arrow corresponds to “bit = 1”, and a light dashed arrow corresponds to “bit x”.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 25 version 1.1
2.2 Bit-flipping decoding
The bit-flipping algorithm is a hard-decision message-passing algorithm for
LDPC codes. A binary (hard) decision about each received bit is made by
the detector and this is passed to the decoder. For the bit-flipping algorithm
the messages passed along the Tanner graph edges are also binary: a bit node
sends a message declaring if it is a one or a zero, and each check node sends
a message to each connected bit node, declaring what value the bit is based on
the information available to the check node. The check node determines that
its parity-check equation is satisfied if the modulo-2 sum of the incoming bit
values is zero. If the majority of the messages received by a bit node are differ-
ent from its received value the bit node changes (flips) its current value. This
process is repeated until all of the parity-check equations are satisfied, or until
some maximum number of decoder iterations has passed and the decoder gives
up.
The bit-flipping decoder can be immediately terminated whenever a valid
codeword has been found by checking if all of the parity-check equations are
satisfied. This is true of all message-passing decoding of LDPC codes and has
two important benefits; firstly additional iterations are avoided once a solution
has been found, and secondly a failure to converge to a codeword is always
detected.
The bit-flipping algorithm is based on the principal that a codeword bit in-
volved in a large number of incorrect check equations is likely to be incor-
rect itself. The sparseness of H helps spread out the bits into checks so that
parity-check equations are unlikely to contain the same set of codeword bits. In
Example 2.4 we will show the detrimental effect of overlapping parity-check
equations.
The bit-flipping algorithm is presented in Algorithm 3. Input is the hard de-
cision on the received vector, y = [y1 , . . . , yn ], and output is M = [M1 , . . . , Mn ].
Example 2.3.
The LDPC code from Example 1.12 is used to encode the codeword
c = [0 0 1 0 1 1].
c is sent though a BSC channel with crossover probability p = 0.2 and the
received signal is
y = [1 0 1 0 1 1].
Initialization is Mi = ri so
M = [1 0 1 0 1 1].
For Step 1 the check node messages are calculated. The 1-st check node is
joined to the 1-st, 2-nd and 4-th bit nodes, B1 = [1, 2, 4], and so the message
for the 1-st check is
E1,1 = M2 ⊕ M4
= 0⊕0
= 0,
E1,2 = M1 ⊕ M4
= 1⊕0
= 1,

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 26 version 1.1
Algorithm 3 Bit-flipping Decoding
1: procedure D ECODE(y)
2:
3: I=0 ⊲ Initialization
4: for i = 1 : n do
5: M i = yi
6: end for
7:
8: repeat
9: for j = 1 : m do ⊲ Step 1: Check messages
10: for i = 1 : P
n do
11: Ej,i = i′ ∈Bj ,i′ 6=i (Mi′ mod 2)
12: end for
13: end for
14:
15: for i = 1 : n do ⊲ Step 2: Bit messages
16: if the messages Ej,i disagree with yi then
17: Mi = (ri + 1 mod 2)
18: end if
19: end for
20:
21: for j = 1 P: m do ⊲ Test: are the parity-check
22: Lj = i′ ∈Bj (Mi′ mod 2) ⊲ equations satisfied
23: end for
24: if all Lj = 0 or I = Imax then
25: Finished
26: else
27: I =I +1
28: end if
29: until Finished
30: end procedure

E1,4 = M1 ⊕ M2
= 1⊕0
= 1.
The 2-nd check includes the 2-nd, 3-rd and 5-th bits, B2 = [2, 3, 5], and so the
message for the 2-nd check is
E2,2 = M3 ⊕ M5
= 1⊕1
= 0,

E2,3 = M2 ⊕ M5
= 0⊕1
= 1,
E2,5 = M2 ⊕ M3
= 0⊕1
= 1.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 27 version 1.1
Repeating for the remaining check nodes gives:

E3,1 = 0, E3,5 = 0, E3,6 = 0,

E4,3 = 1, E4,4 = 0, E4,6 = 1.

In Step 2 the 1-st bit has messages from the 1-st and 3-rd checks, A1 = [1, 3]
both zero. Thus the majority of the messages into the 1-st bit node indicate a
value different from the received value and so the 1-st bit node flips its value.
The 2-nd bit has messages from the 1-st and 2-nd checks, A2 = [1, 2] which
are one and so agree with the received value. Thus the 2-nd bit does not flip
its value. Similarly, none of the remaining bit nodes have enough check to bit
messages differing from their received value and so they all also retain their
current values. The new bit to check messages are thus

M = [0 0 1 0 1 1].

For the test the parity-checks are calculated. For the first check node

L1 = M1 ⊕ M2 ⊕ M4
= 0⊕0⊕0
= 0.

For the second check node

L2 = M2 ⊕ M3 ⊕ M5
= 0⊕1⊕1
= 0,

and similarly for the 3-rd and 4-th check nodes:

L3 = 0,
L4 = 0.

There are thus no unsatisfied checks and so the algorithm halts and returns

M = [0 0 1 0 1 1]

as the decoded codeword. The received string has therefore been correctly de-
coded without requiring an explicit search over all possible codewords. The
decoding steps are shown graphically in Fig. 2.2.

The existence of cycles in the Tanner graph of a code reduces the effective-
ness of the iterative decoding process. To illustrate the detrimental effect of a
4-cycle we use a new LDPC code with Tanner graph shown in Fig. 2.3. For this
Tanner graph there is a 4-cycle between the first two bit nodes and the first two
check nodes.

Example 2.4.
A valid codeword for the code with Tanner graph in Fig. 2.3 is

c = [0 0 1 0 0 1].

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 28 version 1.1
 Initialization
Check messages

1 0 1 0 1 1 1 0 1 0 1 1

Bit update Test

0 0 1 0 1 1 0 0 1 0 1 1

Figure 2.2: Bit-flipping decoding of the received string y = [1 0 1 0 1 1]. Each sub-figure
indicates the decision made at each step of the decoding algorithm based on the messages from
the previous step. A cross (×) represents that the parity check is not satisfied while a tick (X)
indicates that it is satisfied. For the messages, a dashed arrow corresponds to the messages “bit
= 0” while a solid arrow corresponds to “bit = 1”.

This codeword is sent through a binary input additive white Gaussian noise
channel with binary phase shift keying (BPSK) signaling and

[−1.1 1.5 − 0.5 1 + 1.8 − 2]

is received. The detector makes a hard decision on each codeword bit and re-
turns
y = [1 0 1 0 0 1]
As in Example 2.4 the effect of the channel has been that the first bit is incorrect.
The steps of the bit-flipping algorithm for this received string are shown in
Fig. 2.3. The initial bit values are 1, 0, 1, 0, 0, and 1, respectively, and mes-
sages are sent to the check nodes indicating these values. Step 1 reveals that
the 1-st and 2-nd parity-check equations are not satisfied and so at the test the
algorithm continues. In Step 2 both the 1-st and 2-nd bits have the majority of
their messages indicating that the received value is incorrect and so both flip
their bit values. When Step 1 is repeated we see that the 1-st and 2-nd parity-
check equations are again not satisfied. In further iterations the first two bits
continue to flip their values together such that one of them is always incorrect
and the algorithm fails to converge. As a result of the 4-cycle, each of the first
two codeword bits are involved in the same two parity-check equations, and
so when both of the parity-check equations are unsatisfied, it is not possible to
determine which bit is in error.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 29 version 1.1
 Initialization Check messages

1 0 1 0 0 1 1 0 1 0 0 1

Bit update Test

0 1 1 0 0 1 0 1 1 0 0 1

Bit update Test

1 0 1 0 0 1 1 0 1 0 0 1

Figure 2.3: Bit-flipping decoding of y = [1 0 1 0 0 1]. Each sub-figure indicates the decision
made at each step of the decoding algorithm based on the messages from the previous step. A
cross (×) represents that the parity check is not satisfied while a tick (X) indicates that it is
satisfied. For the messages, a dashed arrow corresponds to the messages “bit = 0” while a solid
arrow corresponds to “bit = 1”.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 30 version 1.1
2.3 Sum-product decoding
The sum-product algorithm is a soft decision message-passing algorithm. It is
similar to the bit-flipping algorithm described in the previous section, but with
the messages representing each decision (check met, or bit value equal to 1) now
probabilities. Whereas bit-flipping decoding accepts an initial hard decision on
the received bits as input, the sum-product algorithm is a soft decision algorithm
which accepts the probability of each received bit as input.
The input bit probabilities are called the a priori probabilities for the re-
ceived bits because they were known in advance before running the LDPC de-
coder. The bit probabilities returned by the decoder are called the a posteriori
probabilities. In the case of sum-product decoding these probabilities are ex-
pressed as log-likelihood ratios.
For a binary variable x it is easy to find p(x = 1) given p(x = 0), since
p(x = 1) = 1−p(x = 0) and so we only need to store one probability value for
x. Log likelihood ratios are used to represent the metrics for a binary variable
by a single value:  
p(x = 0)
L(x) = log , (2.1)
p(x = 1)
where we use log to mean loge . If p(x = 0) > p(x = 1) then L(x) is positive
and the greater the difference between p(x = 0) and p(x = 1), i.e. the more
sure we are that p(x) = 0, the larger the positive value for L(x). Conversely,
if p(x = 1) > p(x = 0) then L(x) is negative and the greater the difference
between p(x = 0) and p(x = 1) the larger the negative value for L(x). Thus
the sign of L(x) provides the hard decision on x and the magnitude |L(x)| is
the reliability of this decision. To translate from log likelihood ratios back to
probabilities we note that

p(x = 1)/p(x = 0) e−L(x)

p(x = 1) = = (2.2)
1 + p(x = 1)/p(x = 0) 1 + e−L(x)
and
p(x = 0)/p(x = 1) eL(x)
p(x = 0) = = . (2.3)
1 + p(x = 0)/p(x = 1) 1 + eL(x)
The benefit of the logarithmic representation of probabilities is that when proba-
bilities need to be multiplied log-likelihood ratios need only be added, reducing
implementation complexity.
The aim of sum-product decoding is to compute the maximum a posteriori
probability (MAP) for each codeword bit, Pi = P {ci = 1|N }, which is the
probability that the i-th codeword bit is a 1 conditional on the event N that all
parity-check constraints are satisfied. The extra information about bit i received
from the parity-checks is called extrinsic information for bit i.
The sum-product algorithm iteratively computes an approximation of the
MAP value for each code bit. However, the a posteriori probabilities returned
by the sum-product decoder are only exact MAP probabilities if the Tanner
graph is cycle free. Briefly, the extrinsic information obtained from a parity-
check constraint in the first iteration is independent of the a priori probability
information for that bit (it does of course depend on the a priori probabilities of

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 31 version 1.1
the other codeword bits). The extrinsic information provided to bit i in subse-
quent iterations remains independent of the original a priori probability for bit
i until the original a priori probability is returned back to bit i via a cycle in the
Tanner graph. The correlation of the extrinsic information with the original a
priori bit probability is what prevents the resulting posteriori probabilities from
being exact.
In sum-product decoding the extrinsic message from check node j to bit
node i, Ej,i , is the LLR of the probability that bit i causes parity-check j to be
satisfied. The probability that the parity-check equation is satisfied if bit i is a 1
is
ext 1 1 Y
Pj,i = − (1 − 2Piint
′ ), (2.4)
2 2 ′ ′
i ∈Bj ,i 6=i

where Pj,iint is the current estimate, available to check j, of the probability that
′
′
bit i is a one. The probability that the parity-check equation is satisfied if bit i
ext . Expressed as a log-likelihood ratio,
is a zero is thus 1 − Pj,i
 1−P ext 
ext ) = log
Ej,i = LLR(Pj,i j,i
, (2.5)
ext
Pj,i

and substituting (2.4) gives:

1
+ 21
Q 
Q
int
2 i′ ∈Bj ,i′ 6=i (1−2Pi′ )
Ej,i = log 1
− 21 int . (2.6)
2 i′ ∈Bj ,i′ 6=i (1−2Pi′ )

Using the relationship

  
1 1−p
tanh log = 1 − 2p,
2 p
gives  Q 
Ej,i = log
1+
1−
Q i′ ∈Bj ,i′ 6=i tanh(Mj,i′ /2)
tanh(Mj,i′ /2) (2.7)
i′ ∈Bj , i′ =
6 i

where !
int
1 − Pj,i′
int
Mj,i′ = LLR(Pj,i′) = log int
.
Pj,i′

Alternatively, using the relationship

 
−1 1+p
2 tanh (p) = log ,
1−p
(2.7) can be equivalently written as:

Q  (2.8)
Ej,i = 2 tanh−1 i′ ∈B j ,i′ 6=i tanh(Mj,i′ /2) .

Each bit has access to the input a priori LLR, ri , and the LLRs from every
connected check node. The total LLR of the i-th bit is the sum of these LLRs:
X
Li = LLR(Piint ) = ri + Ej,i . (2.9)
j∈Ai

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 32 version 1.1
However, the messages sent from the bit nodes to the check nodes, Mj,i , are
not the full LLR value for each bit. To avoid sending back to each check node
information which it already has, the message from the i-th bit node to the j-
th check node is the sum in (2.9) without the component Ej,i which was just
received from the j-th check node:
X
Mj,i = Ej ′ ,i + ri . (2.10)
j ′ ∈Ai , j ′ 6=j

The sum-product algorithm is shown in Algorithm 4. Input is the log likeli-

hood ratios for the a priori message probabilities
p(ct = 0)
ri = log ,
p(ct = 1)
the parity-check matrix H and the maximum number of allowed iterations,
Imax . The algorithm outputs the estimated a posteriori bit probabilities of the
received bits as log likelihood ratios.

Example 2.5.
Here we repeat Example 2.3 using sum-product instead of bit-flipping decoding.
The codeword
c = [0 0 1 0 1 1],
is sent through a BSC with crossover probability p = 0.2 and

y = [1 0 1 0 1 1]

is received. Since the channel is binary symmetric the probability that 0 was
sent if 1 is received is the probability, p, that a crossover occurred while the
probability that 1 was sent if 1 is received is the probability, 1 − p, that no
crossover occurred. Similarly, the probability that 1 was sent if 0 is received is
the probability that a crossover occurred while the probability that 0 was sent
if 0 is received is the probability that no crossover occurred. Thus the a priori
probabilities for the BSC are
( p
log 1−p , if yi = 1,
ri = 1−p
log p , if yi = 0.

For this channel we have

p 0.2
log = log = −1.3863,
1−p 0.8
1−p 0.8
log = log = 1.3863,
p 0.2
and so the a priori log likelihood ratios are

r = [−1.3863, 1.3863, −1.3863, 1.3863, −1.3863, −1.3863].

To begin decoding we set the maximum number of iterations to three and pass
in H and r. Initialization is
Mj,i = ri .

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 33 version 1.1
Algorithm 4 Sum-Product Decoding
1: procedure D ECODE(r)
2:
3: I=0 ⊲ Initialization
4: for i = 1 : n do
5: for j = 1 : m do
6: Mj,i = ri
7: end for
8: end for
9:
10: repeat
11: for j = 1 : m do ⊲ Step 1: Check messages
12: for i ∈ Bj do  Q 
13: Q
1+ i′ ∈B ,i′ 6=i tanh(Mj,i′ /2)
Ej,i = log 1− ′ j
′ tanh(M ′ /2)
i ∈Bj , i 6=i j,i

14: end for

15: end for
16:
17: for i = 1 P: n do ⊲ Test
18: Li = j∈Ai Ej,i + ri

1, Li ≤ 0
19: zi =
0, Li > 0.
20: end for
21: if I = Imax or HzT = 0 then
22: Finished
23: else
24: for i = 1 : n do ⊲ Step 2: Bit messages
25: for j ∈ Ai do
P
26: Mj,i = j ′ ∈Ai , j ′ 6=j Ej ′ ,i + ri
27: end for
28: end for
29: I =I +1
30: end if
31: until Finished
32: end procedure

The 1-st bit is included in the 1-st and 3-rd checks and so M1,1 and M3,1 are
initialized to r1 :

M1,1 = r1 = −1.3863 and M3,1 = r1 = −1.3863.

Repeating for the remaining bits gives:

i=2: M1,2 = r2 = 1.3863 M2,2 = r2 = 1.3863

i=3: M2,3 = r3 = −1.3863 M4,3 = r3 = −1.3863
i=4: M1,4 = r4 = 1.3863 M4,4 = r4 = 1.3863
i=5: M2,5 = r5 = −1.3863 M3,5 = r5 = −1.3863
i=6: M3,6 = r6 = −1.3863 M4,6 = r6 = −1.3863

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 34 version 1.1
For Step 1 the extrinsic probabilities are calculated. Check one includes the
1-st, 2-nd and 4-th bits and so the extrinsic probability from the 1-st check to
the 1-st bit depends on the probabilities of the 2-nd and 4-th bits.
 
1+tanh(M /2) tanh(M1,4 /2)
E1,1 = log 1−tanh(M1,2 1,2 /2) tanh(M1,4 /2)
 
1+tanh(1.3863/2) tanh(1.3863/2)
= log 1−tanh(1.3863/2) tanh(1.3863/2)
 
= log 1+0.6∗0.6
1−0.6∗0.6 = 0.7538.

Similarly, the extrinsic probability from the 1-st check to the 2-nd bit depends
on the probabilities of the 1-st and 4-th bits
 
1+tanh(M1,1 /2) tanh(M1,4 /2)
E1,2 = log 1−tanh(M1,1 /2) tanh(M1,4 /2)
 
1+tanh(−1.3863/2) tanh(1.3863/2)
= log 1−tanh(−1.3863/2) tanh(1.3863/2)
 
= log 1+−0.6∗0.6
1−−0.6∗0.6 = −0.7538,

and the extrinsic probability from the 1-st check to the 4-th bit depends on the
LLRs sent from the 1-st and 2-nd bits to the 1-st check.
 
1+tanh(M /2) tanh(M1,2 /2)
E1,4 = log 1−tanh(M1,1 1,1 /2) tanh(M1,2 /2)
 
1+tanh(−1.3863/2) tanh(1.3863/2)
= log 1−tanh(−1.3863/2) tanh(1.3863/2)
 
= log 1+−0.6∗0.6
1−−0.6∗0.6 = −0.7538.

Next, the 2-nd check includes the 2-nd, 3-rd and 5-th bits and so the extrinsic
LLRs are:
 
1+tanh(M /2) tanh(M2,5 /2)
E2,2 = log 1−tanh(M2,3 2,3 /2) tanh(M2,5 /2)
 
1+tanh(−1.3863/2) tanh(−1.3863/2)
= log 1−tanh(−1.3863/2) tanh(−1.3863/2)
 
1+−0.6∗−0.6
= log 1−−0.6∗−0.6 = 0.7538,
 
1+tanh(M2,2 /2) tanh(M2,5 /2)
E2,3 = log 1−tanh(M2,2 /2) tanh(M2,5 /2)
 
1+tanh(+1.3863/2) tanh(−1.3863/2)
= log 1−tanh(+1.3863/2) tanh(−1.3863/2)
 
1+0.6∗−0.6
= log 1−0.6∗−0.6 = −0.7538,
 
1+tanh(M /2) tanh(M2,3 /2)
E2,5 = log 1−tanh(M2,2 2,2 /2) tanh(M2,3 /2)
 
1+tanh(+1.3863/2) tanh(−1.3863/2)
= log 1−tanh(+1.3863/2) tanh(−1.3863/2)
 
1+0.6∗−0.6
= log 1−0.6∗−0.6 = −0.7538.

Repeating for all checks gives the extrinsic LLRs:

 
0.7538 −0.7538 . −0.7538 . .
 . 0.7538 −0.7538 . −0.7538 . 
E=  0.7538
.
. . . 0.7538 0.7538 
. . −0.7538 0.7538 . −0.7538

To save space the extrinsic LLRs are given in matrix form where the (j, i)-th
entry of E holds Ej,i . A ‘.’ entry in E indicates that an LLR does not exist for
that i and j.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 35 version 1.1
 To test the intrinsic and extrinsic probabilities for each bit are combined.
The 1-st bit has extrinsic LLRs from the 1-st and 3-rd checks and an intrinsic
LLR from the channel. The total LLR for bit one is their sum:

L1 = r1 + E1,1 + E3,1 = −1.3863 + 0.7538 + 0.7538 = 0.1213.

Thus even though the LLR from the channel is negative, indicating that the bit
is a one, both of the extrinsic LLRs are positive indicating that the bit is zero.
The extrinsic LLRs are strong enough that the total LLR is positive and so the
decision on bit one has effectively been changed. Repeating for bits two to six
gives:
L2 = r2 + E1,2 + E2,2 = 1.3863
L3 = r3 + E2,3 + E4,3 = −2.8938
L4 = r4 + E1,4 + E4,4 = 1.3863
L5 = r5 + E2,5 + E3,5 = −1.3863
L6 = r6 + E3,6 + E4,6 = −1.3863
The hard decision on the received bits is given by the sign of the LLRs,
 
z= 0 0 1 0 1 1 .

To check if z is a valid codeword

 
1 0 1 0

 1 1 0 0 

  0 1 0 1   
s = zH ′ = 0 0 1 0 1 1  = 0 0 0 0 .

 1 0 0 1 

 0 1 1 0 
0 0 1 1

Since s is zero z is a valid codeword, and the decoding stops, returning z as the
decoded word.

Example 2.6.
Using the LDPC code from Example 1.12, the codeword

c = [0 0 1 0 1 1]

is sent though a BPSK AWGN channel with ES /N0 = 1.25 (or 0.9691dB) and
the received signal is

y = [−0.1 0.5 − 0.8 1.0 − 0.7 0.5].

(If a hard decision is made without decoding, there are two bits in error in this
received vector, the 1-st and 6-th bits.) For an AWGN channel the a priori LLRs
are given by
ES
ri = 4yi
N0

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 36 version 1.1
and so we have

r = [−0.5 2.5 − 4.0 5.0 − 3.5 2.5]

as input to the sum-product decoder.

Iteration 1  
r =  −0.5 2.5 −4.0 5.0 −3.5 2.5 
2.4217 −0.4930 . −0.4217 . .
 · 3.0265 −2.1892 . −2.3001 · 
E = 
 −2.1892

. . . −0.4217 0.4696 
· . 2.4217 −2.3001 . −3.6869
 
L = −0.2676 5.0334 −3.7676 2.2783 −6.2217 −0.7173

z = [ 1 0 1 0 1 1 ]

HzT = [ 1 0 1 0 ]T ⇒ Continue
 
−2.6892 5.5265 · 2.6999 · ·
 · 2.0070 −1.5783 . −3.9217 · 
M = 
 1.9217

. · · −5.8001 −1.1869 
· . −6.1892 4.5783 . 2.9696
Iteration 2  
2.6426 −2.0060 . −2.6326 . .
 · 1.4907 −1.8721 . −1.1041 . 
E =  
 1.1779 · · . −0.8388 −1.9016 
· . 2.7877 −2.9305 · −4.3963
 
L = 3.3206 1.9848 −3.0845 −0.5630 −5.4429 −3.7979

z = [ 0 0 1 1 1 1 ]

HzT = [ 1 0 0 1 ]T ⇒ Continue
 
0.6779 3.9907 · 2.0695 . ·
 · 0.4940 −1.2123 . −4.3388 · 
M =  
 2.1426 · · · −4.6041 −1.8963 
· · −5.8721 2.3674 · 0.5984

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 37 version 1.1
 Iteration 3  
1.9352 0.5180 . 0.6515 . ·
 · 1.1733 −0.4808 . −0.2637 · 
E =  
 1.8332 · · · −1.3362 −2.0620 
· · 0.4912 −0.5948 · −2.3381
 
L = 3.2684 4.1912 −3.9896 5.0567 −5.0999 −1.9001

z = [ 0 0 1 0 1 1 ]

HzT = [ 0 0 0 0 ]T ⇒ Terminate

The sum-product decoder converges to the correct codeword after three itera-
tions.

The sum-product algorithm can be modified to reduce the implementation

complexity of the decoder. This can be done by altering equation 2.8
 
−1 Q
Ej,i = 2 tanh i′ ∈Bj ,i′ 6=i tanh(Mj,i /2) ,
′

so as to replace the product term by a sum. For simplicity we will write

Y Y
≡
i′ i′ ∈Bj ,i′ 6=i

in the remainder of this section.

Firstly Mj,i′ can be factored as

Mj,i′ = αj,i′ βj,i′

where
αj,i′ = sign(Mj,i′ ),
(2.11)
βj,i′ = |Mj,i′ |.
Using this notation we have that
Y Y Y
tanh(Mj,i′ /2) = αj,i′ tanh(βj,i′ /2).
i′ i′ i′

Then equation 2.8 becomes

Q Q

tanh−1
i′ αj,i′ Q
Ej,i = 2Q i′ tanh(βj,i′ /2)

−1 (2.12)
= i′ αj,i′ 2 tanh i′ tanh(βj,i′ /2)

Equation 2.12 can now be re-arranged to replace the product by a sum:

Q
Q

Ej,i = Qi′ αj,i′
2 tanh−1 log−1 log i′ tanh(βj,i′ /2)

−1 P (2.13)
= i′ αj,i′ 2 tanh log−1 i′ log tanh(βj,i′ /2) .

Next, we define
x ex + 1
φ(x) = − log tanh( ) = log x
2 e −1

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 38 version 1.1
and note that since
eφ(x) + 1
φ(φ(x)) = log = x.
eφ(x) − 1
we have φ−1 = φ. Finally equation 2.13 becomes
! !
Y X
Ej,i = αj,i′ φ φ(βj,i′ ) . (2.14)
i′ i′

The product of the signs can be calculated by using modulo 2 addition of the
hard decisions on each Mj,i′ while the function φ can be easily implemented
using a lookup table.
Alternatively, the min-sum algorithm, simplifies the calculation of (2.7) by
recognizing that the term corresponding to the smallest Mj,i′ dominates the
product term and so the product can be approximated by a minimum:
!
Y
Ej,i ≈ sign(Mj,i′ ) |{z}
Min Mj,i′ .
i′ i′

Again, the product of the signs can be calculated by using modulo 2 addition of
the hard decisions on each Mj,i′ and so the resulting min-sum algorithm thus
requires calculation of only minimums and additions.

2.4 Bibliographic notes

Message-passing decoding algorithms for LDPC codes were first introduced by
Gallager in his 1962 thesis [1]. In the early 1960s, however, limited computing
resources prevented Gallager from demonstrating the capabilities of message-
passing decoders for blocklengths longer than around 500 bits, and for over 30
years his work was ignored by all but a handful of researchers. It was only
re-discovered by several researchers [7] in the wake of turbo decoding [12],
which itself has subsequently been recognized as an instance of the sum-product
algorithm.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 39 version 1.1
 Topic 3: Density Evolution

The subject of this topic is to analyze the performance of message-passing de-

coders and understand how the choice of LDPC code will impact on this per-
formance. Ideally, for a given Tanner graph T we would like to know for which
channel noise levels the message-passing decoder will be able to correct the
errors and for which it won’t. Unfortunately, this is still an open problem, but
what is possible to determine is how an ensemble of Tanner graphs is likely to
behave, if the channel is memoryless and under the assumption that the Tan-
ner graphs are all cycle free. To do this the evolution of probability density
functions are tracked through the message-passing algorithm, a process called
density-evolution.
Density evolution can be used to find the maximum level of channel noise
which is likely to be corrected by a particular ensemble using the message-
passing algorithm, called the threshold for that ensemble. This then enables the
code designer to search for the ensemble with the best threshold from which to
choose a specific LDPC code.

3.1 Density evolution on the BEC

Recall from Algorithm 2 that for message passing decoding on the BEC a
parity-check equation can correct an erased bit if that bit was the only erased bit
in the parity-check equation. Here we make the assumption that the decoding
algorithm is passing messages down through the layers of a Tanner graph which
is a tree. In this case the bit-to-check message to check node in a lower level
of the graph is determined by the check-to-bit messages from all the incoming
edges in the level above.

3.1.1 Regular LDPC codes

Given an ensemble T (wc , wr ), which consists of all regular LDPC Tanner
graphs with bit nodes of degree wc and check nodes of degree wr , we want
to know how the message-passing decoder will perform on the binary erasure
channel using codes from this ensemble.
For message-passing decoding on the BEC, the messages hold either the
current value of the bit, which can be ‘1’or ‘0’ if known or ‘x’ if the bit value
is not known. We define ql to be the probability that at iteration l a check to bit
message is an ‘x’ and pl to be the probability that at iteration l a bit to check
message is an ‘x’ (i.e. pl is the probability that a codeword bit is still erased at
iteration l).
The check to bit message on an edge is ‘x’ if one or more of the incom-
ing messages on the other (wr − 1) edges into that check node is an ‘x’. To

41
calculate the probability, ql , that a check to bit message is ‘x’ at iteration l we
make the assumption that all of the incoming messages are independent of one
another. That is, we are assuming firstly that the channel is memoryless, so that
none of the original bit probabilities were correlated, and secondly that there
are no cycles in the Tanner graphs of length 2l or less, as a cycle will cause the
messages to become correlated. With this assumption, the probability that none
of the other wr − 1 incoming message to the check node is ‘x’ is simply the
product of the probabilities, (1 − pl ), that each individual message is not ‘x’. So
the probability that one or more of the other incoming messages are ‘x’ is one
minus this:
ql = 1 − (1 − pl )(wr −1) (3.1)
At iteration l the bit to check message will be ‘x’ if the original message
from the channel was an erasure, which occurs with probability ε, and all of the
incoming messages at iteration l − 1 are erasures, which each have probability
ql . Again we make the assumption that all of the incoming messages are inde-
pendent of one another, and so the probability that the bit to check message is an
‘x’ is the product of the probabilities that the other wc − 1 incoming messages
to the bit node, and the original message from the channel, were erased.

pl = ε (ql−1 )(wc −1) . (3.2)

Substituting for ql−1 from (3.1) gives

 (wc −1)
pl = ε 1 − (1 − pl−1 )(wr −1) . (3.3)

Prior to decoding the value of p0 is the probability that the channel erased a
codeword bit:
p0 = ε.
Thus for a (wc , wr )-regular ensemble
 (wc −1)
p0 = ε, pl = ε 1 − (1 − pl−1 )(wr −1) (3.4)

The recursion in (3.4) describes how the erasure probability of message-

passing decoding evolves as a function of the iteration number l for (wc , wr )-
regular LDPC codes. Applying this recursion we can determine for which era-
sure probabilities the message-passing decoder is likely to correct the erasures.

Example 3.1.
A code from the (3,6)-regular ensemble is to be transmitted on a binary erasure
channel with erasure probability ε = 0.3 and decoded with the message-passing
algorithm. The probability that a codeword bit will remain erased after l iter-
ations of message-passing decoding (if the code Tanner graph is cycle free) is
given by the recursion:
 2
p0 = 0.3, pl = p0 1 − (1 − pl−1 )5 .

Applying this recursion for 7 iterations gives the sequence of bit erasure proba-
bilities,

p0 = 0.3000, p1 = 0.2076, p2 = 0.1419, p3 = 0.0858,

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 42 version 1.1
 0.5

0.45

0.4

0.35

Erasure probability
0.3

0.25

p = 0.5
0
0.2
p0 = 0.43

0.15 p = 0.42
0

p0 = 0.3
0.1

0.05

0
0 5 10 15 20 25 30 35 40
Iteration number

Figure 3.1: The erasure probabilities calculated in Example 3.2.

p4 = 0.0392, p5 = 0.0098, p6 = 0.0007, p7 = 0.0000.

Thus the erasure probability in a codeword from a 4-cycle free (3,6)-regular
LDPC code transmitted on a BEC with erasure probability 0.3 will approach
zero after seven iterations of message-passing decoding.

Example 3.2.
Extending Example 3.1 we would like to know which erasure probabilities the
codes from a (3,6)-regular ensemble are likely to be able to correct. Apply-
ing the recursion (3.3) to a range of channel erasure probabilities we see, in
Fig. 3.1, that for values of ε ≥ 0.43 the probability of remaining erasures does
not decrease to zero even as l gets very large, whereas, for values of ε ≤ 0.42
the probability of error does approach zero as l → ∞. The transition value of
ε, between these two outcomes is the called the threshold of the (3,6)-regular
ensemble, a term we make more precise in the following. Again applying the
recursion (3.3), Fig. 3.2 demonstrates that the threshold for a (3,6)-regular en-
semble on the binary erasure channel is between 0.4293 and 0.4294.

3.1.2 Irregular LDPC codes

Recall that an irregular parity-check matrix has columns and rows with varying
weights (respectively bit nodes and check nodes with varying degrees). We
designated the fraction of columns of weight i by vi and the fraction of rows of
weight i by hi .

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 43 version 1.1
 0.5
p = 0.4295
0
0.45 p = 0.4293
0

0.4

0.35

Erasure probability
0.3

0.25

0.2

0.15

0.1

0.05

0
0 50 100 150 200 250 300
Iteration number

Figure 3.2: The erasure probabilities calculated in Example 3.2.

To derive density evolution for irregular LDPC codes an alternative char-

acterization of the degree distribution, from the perspective of Tanner graph
edges, is used. The fraction of edges which are connected to degree-i bit nodes
is denoted λi , and the fraction of edges which are connected to degree-i check
nodes, is denoted ρi . By definition:
X
λi = 1 (3.5)
i

and X
ρi = 1. (3.6)
i

The functions

λ(x) = λ2 x + λ3 x2 + · · · + λi xi−1 + · · · (3.7)

ρ(x) = ρ2 x + ρ3 x2 + · · · + ρi xi−1 + · · · (3.8)

are defined to describe the degree distributions. Translating between node de-
grees and edge degrees:
λi /i
vi = P ,
j λj /j

ρi /i
hi = P .
j ρj /j

From (3.1) we know that, at the l-th iteration of message-passing decoding,

the probability that a check to bit message is ‘x’, if all the incoming messages
are independent, is
ql = 1 − (1 − pl )(wr −1) ,

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 44 version 1.1
for an edge connected to a degree wr check node. For an irregular Tanner graph
the probability that an edge is connected to a degree wr check node is ρwr .
Thus averaging over all the edges in an irregular Tanner graph gives the average
probability that a check to bit message is in error:
X   X
ql = ρi 1 − (1 − pl )(i−1) = 1 − ρi (1 − pl )(i−1) .
i i

Using the definition of ρ(x) in (3.8), this becomes

ql = 1 − ρ (1 − pl ) .

From (3.2) we know that the probability that a bit to check message is ‘x’,
at the l-th iteration of message-passing decoding if all incoming messages are
independent, is
pl = ε (ql−1 )(wc −1)
for an edge is connected to a degree wc bit node. For an irregular Tanner graph
the probability that an edge is connected to a degree wc bit node is λwc . Thus
averaging over all the edges in the Tanner graph gives the average probability
that a bit to check message is in error:
X
pl = ε λi (ql−1 )(i−1) .
i

Using the definition of λ(x) in (3.7), this is equivalent to

pl = ελ (ql−1 ) .

Finally, substituting for ql−1 we have

pl = ελ (1 − ρ (1 − pl−1 )) .

Prior to decoding the value of p0 is the probability that the channel erased a
codeword bit:
p0 = ε,
and so for irregular LDPC codes we have the recursion:

p0 = ε, pl = p0 λ (1 − ρ (1 − pl−1 )) . (3.9)

3.1.3 Threshold
The aim of density evolution is to determine for which channel erasure prob-
abilities, ε, the message-passing decoder is likely to correct all of the erased
bits. Using (3.9) we have a means of approximating this as an average over all
LDPC Tanner graphs with a given degree distribution λ, ρ, by assuming that the
graphs are cycle free.
To examine the influence of ε on pl we define the function

f (p, ε) = ελ (1 − ρ (1 − p)) .

The erasure probability at iteration l is then

pl (ε) = f (pl−1 , ε)

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 45 version 1.1
 0.6

0.5

Erasure probability
0.4

0.3 p0 = 0.6

p = 0.5
0

0.2 p0 = 0.4

p = 0.3
0

0.1

0
0 5 10 15 20 25
Iteration number

Figure 3.3: The erasure probabilities calculated in Example 3.3.

where p and ε are probabilities, and so can take values between 0 and 1. Here,
f (p, ε) is a strictly increasing function in p for ε > 0. Thus if pl > pl−1 then

pl+1 = f (pl , ε) ≥ f (pl−1 , ε) = pl ,

for ε ∈ [0, 1], so pl (ε) is a monotone sequence which is lower bounded at p = 0

by
f (0, ε) = ελ (1 − ρ (1)) = ελ (1 − 1) = 0
and upper bounded at p = 1 by

f (1, ε) = ελ (1 − ρ (1 − 1)) = ελ (1 − 0) = ε.

Since f (p, ε) is a strictly increasing function in p

0 ≤ f (p, ε) ≤ ε,

for all p ∈ [0, 1] and ε ∈ [0, 1]. Thus pl converges to an element p∞ ∈ [0, ε].
Further, for a degree distribution pair (λ, ρ), and an ε ∈ [0, 1], it can be proven
that if pl (ε) → 0 then pl (ε′ ) → 0 for all ε < ε′ . Indeed, there is a value ε∗
called the threshold such that for values of ε below ε∗ , pl approaches zero as
the number of iterations goes to infinity while for values of of ε above ε∗ it does
not. The threshold, ε∗ , for (λ, ρ) is defined as the supremum of ε for which
pl (ε) → 0:
ε∗ (λ, ρ) = sup{ε ∈ [0, 1] : pl (ε)l→∞ → 0}.

Example 3.3.
We wish to find the threshold of an irregular LDPC ensemble with degree dis-
tributions
λ(x) = 0.1x + 0.4x2 + 0.5x19

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 46 version 1.1
 0.5

0.4

Erasure probability 0.3 p0 = 0.5

p = 0.475
0

p0 = 0.45
0.2
p0 = 0.425

p = 0.4
0
0.1

0
0 5 10 15 20 25 30 35 40 45 50
Iteration number

Figure 3.4: The erasure probabilities calculated in Example 3.3.

and
ρ(x) = 0.5x7 + 0.5x8 .
This code has rate P
λi /i
1 − Pi ≈ 0.5.
i ρi /i
To find the threshold we apply the recursion from (3.9) over a wide range of
different channel erasure probabilities. We see in Fig. 3.3, that for values of ε
0.5 and above the probability of remaining erasures does not decrease to zero
even as l gets very large, whereas, for values of ε of 0.4 and below the probabil-
ity of error does go to zero. To close in on the threshold further we thus apply
the recursions to channel erasure probabilities between these values. Fig. 3.4,
shows that for values of ε ≥ 0.475 the probability of remaining erasures does
not decrease to zero even as l gets very large, whereas, for values of ε ≤ 0.45
the probability of error does go to zero. To close in on the threshold even fur-
ther we now apply the recursions to channel erasure probabilities between these
values. Fig. 3.5, shows that for values of ε ≥ 0.475 the probability of remain-
ing erasures does not decrease to zero even as l gets very large, whereas, for
values of ε ≤ 0.465 the probability of error does go to zero. For ε = 0.47 we
would need to consider a larger number of decoder iterations to determine if the
decoder would converge to zero. We can conclude, however, that the threshold
for this ensemble is an erasure probability between 0.465 and 0.475.

3.1.4 Stability
The recursion in (3.9) quickly results in very high order polynomials as the
iteration number is increased. However, to understand its behavior when pl is

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 47 version 1.1
 0.5

0.45
p = 0.475
0

0.4 p = 0.47
0

p0 = 0.465
0.35
p = 0.46
0

Erasure probability
0.3 p = 0.455
0

0.25

0.2

0.15

0.1

0.05

0
0 10 20 30 40 50 60 70 80 90 100
Iteration number

Figure 3.5: The erasure probabilities calculated in Example 3.3.

small we can approximate it by a Taylor series expansion of the right hand side
around 0. i.e.
pl = f (pl−1 , ε) ≈ f ′ (p, ε)pl−1 . (3.10)
A function f (x) = g(h(x)) has a derivative with respect to x given by
df dg dh
= .
dx dh dx
Thus for

f (p, ε) = ελ(h(p)) where h(p) = 1 − ρ(1 − p)

the derivative with respect to p is

df (p, ε) dλ dh
= .
dp dh dp
Evaluating this derivative at p = 0 we have that

h(p = 0) = 1 − ρ(1) = 0

and so
dλ dλ
= = λ2 + 2λ3 h + · · · + (i − 1)λi h(i−2) + · · · = λ2 ,
dh p=0 dh h=0 h=0

and
dh d(1 − ρ(1 − p))
= = ρ′ (1).
dp p=0 dp (1−p)=1

Substituting back into (3.10),

pl ≈ ελ2 ρ′ (1)pl−1 , (3.11)

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 48 version 1.1
as pl → 0.
For pl to converge to zero as l → ∞, requires pl < pl−1 , and so, from
(3.11), requires:
ελ2 ρ′ (1) < 1. (3.12)
Thus for a degree distribution pair (λ,ρ) to converge to zero on a binary erasure
channel with erasure probability ε, λ2 is upper bounded by
1
λ2 < . (3.13)
ερ′ (1)
Equation 3.13 is often called the stability constraint of density evolution.

3.2 Density evolution on general memoryless channels

For message-passing decoding on general memoryless channels, the bit to check
messages are the log likelihood ratios (LLRs) of the probabilities that a given
bit is ‘1’ or ‘0’. As these LLR values are continuous, the probability that a
message is a particular LLR value is described by a probability density function
(pdf).
Recall that the LLR of a random variable x is
 
p(x = 0)
L(x) = log ,
p(x = 1)
and so L(x) will be positive if p(x = 0) > p(x = 1) and negative otherwise.
Consequently the probability that the corresponding codeword bit is a ’1’ is the
probability that the LLR is negative.

Example 3.4.
Fig. 3.6 shows a gaussian pdf for p(r). The probability that the bit is a ‘1’ is
given by the shaded area under the curve.

To analyze the evolution of these pdfs in the message-passing decoder we

define p(Ml ) to be the probability density function for a bit to check message
at iteration l and p(El ) to be the probability density function for a check to bit
messages at iteration l and p(r) to be the probability density function for the
LLR of the received signal.
Again we make the assumption that all of the incoming messages are in-
dependent of one another. That is, we are assuming firstly that the channel is
memoryless, so that none of the original bit probabilities were correlated, and
secondly that there are no cycles in the Tanner graphs of length 2l or less, as a
cycle will cause the messages to become correlated.
The outgoing message at a bit node is the sum of the incoming LLRs on the
other edges into that node (2.10):
X
Mj,i = Ej ′ ,i + ri .
j ′ ∈Ai , j ′ 6=j

Since the incoming messages are independent, the pdf of the random variable
formed from this summation can be obtained by the convolution [13, eqn 6.39]

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 49 version 1.1
 0.04

0.035

0.03 Initial message

0.025 Eb/N0 = 1.12 dB

Density 0.02

0.015

0.01

0.005

0
−50 −40 −30 −20 −10 0 10 20 30 40 50
LLR

Figure 3.6: The probability density function for additive white Gaussian noise.
See Example 3.4.

of the pdfs of the wc − 1 incoming messages from the check nodes and the pdf
of the incoming message from the channel:

pM = p(r) ⊗ p(El )⊗(wc −1) .

Averaging over the bit degree distribution, λ(x):

X
p(Ml ) = p(r) ⊗ λi p(El )⊗(i−1) = p(r) ⊗ λ⊗ (p(El )).
i

The convolution operation can be evaluated numerically using FFTs.

The function to be evaluated at each check node is (2.7):
Q !
1 + i′ ∈Bj ,i′ 6=i tanh(Mj,i′ /2)
Ej,i = log Q
1 − i′ ∈Bj , i′ 6=i tanh(Mj,i′ /2)

where
ex − 1
tanh(x/2) = log
.
ex + 1
Thus to sum over two messages x and y requires the calculation of the proba-
bility density function of
1+tanh(x/2) tanh(y/2) x
(e +1)(e +1)+(e −1)(e −1) y x y
f (x, y) = log 1−tanh(x/2) tanh(y/2) = log (ex +1)(ey +1)−(ex −1)(ey −1)
e +e x y
= − log 1+e x+y .
(3.14)
A method to find the pdf of a function of two random variables is given in
[13, eqn 6.36]. Briefly, given two random variables x and y and the function

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 50 version 1.1
 0.04

0.035

0.03 iteration 0

0.025

iteration 50
Density 0.02

iteration 100
0.015

iteration 107
0.01

0.005

0
−10 0 10 20 30 40 50
LLR

Figure 3.7: The evolution of probability density functions with iteration num-
ber in density evolution. See Example 3.5.

z = f (x, y) the density of z can be found as follows:

Z Z
f (z)dz = f (x, y)dxdy
∆Dz

where Dz is the region of the xy plane such that z < g(x, y) < z + dz.
To apply density evolution on general channels it is assumed that the origi-
nal codeword was all zeros. Consequently the probability that the bit is in error
is the probability that the LLR is negative.

Example 3.5.
Fig. 3.7 shows the evolution of q(El ) for a (3,6)-regular ensemble on an AWGN
channel with signal-to-noise ratio (Eb /N0 ) of 1.12. On an AWGN channel the
pdf of the original received signal will be Gaussian with variance σ, reflecting
the pdf of the noise. As the iteration number is increased the area under the
curve for negative LLRs decreases and so the probability of error is decreasing.

Although the pdfs start as gaussian, the result of the convolution of gaussian
pdfs is not gaussian except in the limit. However an approximation for den-
sity evolution on the AWGN channel assumes that the pdfs do in fact remain
gaussian. Since a Gaussian pdf is completely described by its mean and vari-
ance this approximation greatly simplifies the application of density evolution
as only the mean and variance are tracked through the message-passing decod-
ing and not the entire pdf.
It can be shown (we don’t do it here see reference [14]) that the sum-product
decoding algorithm preserves the order implied by degradation of the channel.
i.e. as the channel improves the performance of the sum-product decoder will

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 51 version 1.1
 (3,6)−regular code
0
10

−1
10

−2
10

Average bit−error rate

−3
10

−4
10

−5
10
E /N = 1.12 dB
b 0

E /N = 1.04 dB
−6 b 0
10

−7
10
0 100 200 300 400 500 600 700 800 900 1000
Iterations

Figure 3.8: Calculating the threshold of a (3,6)-regular ensemble on an AWGN

channel. Example 3.6.

also improve. For example, on a AWGN channel with variance σ for all σ ′ <
σ the expected bit error probability of sum-product decoding, PSP , satisfies
PSP (σ ′ ) < PSP (σ).
The threshold of a given degree distribution for sum-product decoding is
again the supremum of the channel noise values for which the probability of
decoding error goes to zero as the iteration number is allowed to go to infinity.
For an AWGN channel with variance σ the threshold is denoted σ ∗ :

σ ∗ = sup{σ : PSP (σ)l→∞ → 0}

Example 3.6.
We would like to know at which AWGN signal-to-noise ratios the codes from
a (3,6)-regular ensemble are likely to be able to correct the noise. Applying
density evolution for different channel erasure probabilities we see, in Fig. 3.8,
that the threshold is an Eb /N0 between 1.04 and 1.12.

3.3 Choosing the degree distribution

We have seen that the threshold of an ensemble of codes with a given degree dis-
tribution can be found using density evolution. The question for code designers
is then which degree distributions will produce the best threshold.
Generally, the more irregular the bit degree distribution the better. The ca-
pacity approaching LDPC codes are both very long and very irregular. The
famous LDPC ensemble with threshold 0.0045 dB from the Shannon limit has

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 52 version 1.1
a codeword length of 107 bits with node degrees varying from 2 to 8000. The
subset of the bits nodes with very high degree will very quickly converge to
their solution, and once correct will pass high LLR values to their many con-
nected nodes. Since the overall density of H needs to be low, a large proportion
of degree-2 bit nodes are also required to reduce the average node degree. Thus
a degree distribution with a good threshold will contain a few very high degree
bit nodes, many degree two nodes, but no more than allowed for by stability,
and some nodes with degrees in between these. Irregularity in the check node
degrees is not as essential and generally one or two check degrees, chosen to
achieve the required average row weight is sufficient.
Trying every possible distribution that fits this general pattern is of course
not practical and so optimization techniques are used to find the best degree
distribution subject to the desired constraints. Optimizing over the density evo-
lution algorithm is not straightforward, in particular because a gradient for the
cost function is not defined. Nevertheless, two general optimization algorithms
have been applied to finding the degree distributions of LDPC codes, iterative
linear programming and the confusingly named (for us) differential evolution.

3.4 Bibliographic notes

The type of analysis of message-passing decoding which we now call density
evolution first appeared for regular codes in Gallager’s work [1]. For irregular
codes density evolution was first proposed in [15] when considering the binary
erasure channel, applied to hard decision message-passing decoding in [4] and
generalized to sum-product decoding on memoryless channels in [14, 16]. On-
line implementations of density evolution can be found at [17] and [18],

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 53 version 1.1
 Topic 4: LDPC Code Properties

In this topic low-density parity-check (LDPC) codes are discussed in detail with
a focus on code design, encoding, and performance. Firstly the properties of
LDPC codes are considered and the difference between classical decoders and
message-passing decoders is made apparent when considering how and why
message-passing decoding algorithms fail.
Secondly, LDPC codes with linear-time encoders, in particular quasi-cyclic
codes and repeat-accumulate codes, are considered. Finally, a number of spe-
cific methods for code design are presented. Pseudo-random constructions
are considered with many of the more recent strategies for cycle and pseudo-
codeword removal presented and structured LDPC codes are considered with a
focus on codes from combinatorial designs.

4.1 LDPC properties

While there is no one recipe for a “good” LDPC code, there are a number of
principles which inform the code designer.
Firstly, a good LDPC code is also a good classical block code. The power of
sum-product decoding is that it can decode very long codes, but it is neverthe-
less a sub-optimal decoding algorithm which can only do as well as the optimal
decoder (were it possible to implement the optimal decoder). If the LDPC code
has a poor minimum distance the sum-product decoder will produce an error
floor in exactly the same manner as the ML or MAP decoder. That LDPC codes
often do not show an error floor is because, for very long and very sparse codes,
it is relatively easy to pseudo-randomly construct a code with a good minimum
distance.
A good classical code is however not necessarily a good LDPC code. Most
critically, the sparsity of the parity-check matrix, H, is essential to keep the
decoding complexity low. A sparse H also guarantees the linear growth in
minimum distance with length proven for LDPC ensembles. A good Tanner
graph also has a large girth and good expansion. This increases the number of
correlation-free iterations and improves the convergence of the decoder.
Other desirable properties of LDPC codes depend on how they are to be
applied. For a capacity-approaching performance on very low noise channels,
long code lengths and random or pseudo-randomly constructed irregular parity-
check matrices produce the performance closest to capacity. However, capacity-
approaching performance (in the bit error rate) equate to poor word error rates
and low error floors, making capacity-approaching codes completely unsuitable
for some applications.
For long codes a randomly chosen parity-check matrix is almost always
good and structured matrices are often much worse. However, for short and

55
medium-length LDPC codes irregular constructions are generally not better
than regular ones and graph-based or algebraic constructions can outperform
random ones. In addition, using structured parity-check matrices can lead to
much simpler implementations, particularly for encoding, and can guarantee
girth and minimum distance properties difficult to achieve randomly for shorter
codes. In particular, for very low error floors a reasonably short algebraic con-
struction with large column weight will produce the required performances,
with the trade off of a larger gap to capacity.

4.1.1 Girth and expansion

Cycles in the Tanner graph lead to correlations in the marginal probabilities
passed by the sum-product decoder; the smaller the cycles the fewer the num-
ber of iterations that are correlation free. Thus cycles in the Tanner graph af-
fect decoding convergence, and the smaller the code girth, the larger the effect.
Definite performance improvements can be obtained by avoiding 4-cycles1 and
6-cycles from LDPC Tanner graphs but the returns tend to diminish as the girth
is increased further.
It is important to keep in mind that when considering the properties of
an LDPC code we are often actually considering the properties of a particu-
lar choice of parity-check matrix for that code, and that a different choice of
parity-check matrix for the same code may behave differently.

Example 4.1.
The parity-check matrices
 
1 1 0 1 0 0
 0 1 1 0 1 0 
H1 = 
 1

0 0 0 1 1 
1 0 1 1 1 0
and  
1 1 0 1 0 0
 0 1 1 0 1 0 
H2 = 
 1

0 0 0 1 1 
0 0 1 1 0 1
both describe the same code, but have Tanner graphs with different girth. Fig-
ure 4.1 shows the performance of sum-product decoding using each of these
parity-check matrices on the same channel. Removing a single 4-cycle from
the parity-check matrix has noticeably improved the performance of the sum-
product decoder even though exactly the same code is being decoded. In Topic 5
we will outline some of the methods used to construct Tanner graphs without
short cycles.

A related concept to the graph girth is the graph expansion. In a good ex-
pander every subset of vertices has a large number of neighbors that are not
1
A small subset of LDPC codes which include 4-cycles have been shown to perform well with
sum-product decoding, however this effect is due to the large number of extra linearly dependent
rows in these parity-check matrices which helps to overcome the negative impact of the cycles.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 56 version 1.1
 −1
10
H
1
H2

Bit Error Rate −2

10

−3
10
1 1.5 2 2.5 3 3.5 4 4.5 5
Signal−to−noise ratio E /N (dB)
b 0

Figure 4.1: The bit error rate performance of sum-product decoding on an AWGN channel
using the parity-check matrices from Example 4.1.

in the subset. More precisely, any subset S of bit vertices of size m or less is
connected to at least ǫ|S| constraint vertices, for some defined m and ǫ.
If a Tanner graph is a good expander then the bit nodes of a small set of
erroneous codeword bits will be connected to a large number of check nodes,
all of which will be receiving correct information from an even larger number of
the correct codeword bits. Sipser and Spielman [19] showed that the expansion
of the graph is a significant factor in the application of iterative decoding. Using
only a simple hard decision decoding algorithm they proved that a fixed fraction
of errors can be corrected in linear time provided that the Tanner graph is a good
enough expander.

4.1.2 Stopping sets and pseudo-codewords

As we saw in Topic 1, the message-passing decoding of LDPC codes on erasure
channels is particularly straightforward since a transmitted bit is either received
correctly or completely erased. Decoding is a process of finding parity-check
equations which check on only one erased bit. In a decode iteration all such
parity-check equations are found and the erased bits corrected. After these
bits have been corrected any new parity-check equations checking on only one
erased bit are then corrected in the subsequent iteration. The process is repeated
until all the erasures are corrected or all the remaining uncorrected parity-check
equations check on two or more erased bits. The question for coding theorists
is when will this occur and why.
For the binary erasure channel at least, the answer is known. The message-
passing decoder will fail to converge if the erased bits include a set of code bits,
S, which are a stopping set. A stopping set, S, is a set of code bits with the
property that every parity-check equation which checks on a bit in S checks on

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 57 version 1.1
Figure 4.2: The Tanner graph of a length 5 code with a stopping set of size three shown in
bold.

at least two bits in S. The size of a stopping set is the number of bits it includes,
and the minimum stopping set size of a parity-check matrix is denoted Smin .

Example 4.2.
Fig. 4.2 shows the Tanner graph of a length 5 parity-check matrix with 3 parity-
check equations and filled bit nodes representing a stopping set of size three.

The message-passing decoder cannot correct a set of erased bits S which

are a stopping set. Since every parity-check node connected to S includes at
least two erased bits there will never be a parity-check equation available to
correct a bit in S, regardless of the number of iterations employed. In a sense
we can say that the decoder has converged to the stopping set. The stopping set
distribution of an LDPC parity-check matrix determines the erasure patterns for
which the message-passing decoding algorithm will fail in the same way that
the codeword distribution of a code determines the error patterns for which the
ML decoder will fail. The minimum stopping set size determines the minimum
number of erased bits which can cause a decoding failure.

Example 4.3.

The same LDPC code used in Example 1.12:

 
1 1 0 1 0 0
 0 1 1 0 1 0 
H=  1 0 0 0 1
.
1 
0 0 1 1 0 1
is used to encode the codeword

c = [0 0 1 0 1 1].

c is sent though an erasure channel but this time the 3-rd, 5-th and 6-th bits are
erased and so the vector
y = [0 0 x 0 x x]
is received. Message-passing decoding is used to recover the erased bits.
Initialization is Mi = yi which gives

M = [0 0 x 0 x x].

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 58 version 1.1
 For Step 1 the check node messages are calculated. The 1-st check node is
joined to the 1-st, 2-nd and 4-th bit nodes, and so has no incoming ‘x’ messages.
The 2-nd check includes the 2-nd, 3-rd and 5-th bits, and so receives two ‘x’
messages, (M3 and M5 ) and thus cannot be used to correct any codeword bits.
The 3-rd check includes the 1-st, 5-th and 6-th bits and so also receives two x
messages, (M5 and M6 ) and thus cannot be used to correct any codeword bits.
Finally, the 4-th check includes the 3-rd, 4-th and 6-th bits and so receives two
‘x’ messages, (M3 and M6 ) and thus also cannot used to correct any codeword
bits.
In Step 2 there are no new messages coming into any of the erased bits and
no corrections can be made. Regardless of how many iterations are run there
will never be a corrected erased bit. By examination of H, it is clear why this
is the case: the set of erased codeword bits is a stopping set in H.

Knowing exactly the places where the decoding algorithm will fail allows us
to predict its performance. Indeed, if the stopping set distribution of an LDPC
parity-check matrix were known, the performance of the message-passing de-
coder on the BEC could be determined exactly by counting the stopping sets.
The probability of bit erasure for a given parity-check matrix, H, of length n
on a binary erasure channel with erasure probability ǫ is
n  
X N (v)
P (H, ǫ) = (nv )ǫv (1 n−v
− ǫ) , (4.1)
T (v)
v=0

where T (v) is the total of number bit sets of size v and N (v) is the number of
those bit sets which are stopping sets.
Finding the stopping set distribution of an individual parity-check matrix is
as prohibitively complex as finding its codeword distance distribution, however,
the average stopping set distribution of a regular LDPC ensemble can be found
combinatorially. This technique, called finite-length analysis, gives the exact
average bit and block error probabilities for any regular ensemble of LDPC
codes over the binary erasure channel (BEC) when decoded iteratively. From
the ensemble perspective T (v) is the total of number of ways a bit set of size
v can be constructed over all possible codes in the ensemble and N (v) is the
number of those ways which result in the v points being a stopping set. Thus
N (v)/T (v) can be considered the probability that a given set of v points is a
stopping set.
Every codeword is a stopping set. This is easy to see since any check on a
non-zero bit in the codeword must include an even number of non-zero code-
word bits to ensure even parity. Thus the set of stopping sets includes the set of
codewords. However, not all of the stopping sets correspond to codewords. The
stopping set in Fig. 4.2 for example is not a codeword.
Not all parity-check matrices for the same code will have the same stop-
ping set distribution or same minimum stopping set size. Fig. 4.3 for exam-
ple shows the Tanner graphs of two parity-check matrices for the same code,
one with three size-3 stopping sets and one with two size-3 stopping sets. The
two common stopping sets include bits {1, 2, 4} and {1, 3, 5}. Every possible

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 59 version 1.1
 Figure 4.3: The Tanner graph of two different parity-check matrices for the same code.

parity-check matrix for this code will also contain stopping sets in these bit
locations.
The role of stopping sets in predicting the performance of message-passing
decoding on the BEC tells us that for message-passing decoding, unlike for ML
decoding, properties other than the codeword set influence the decoder perfor-
mance. The same is true of message-passing decoding on more general chan-
nels, however defining the configurations which lead to decoder failure in the
general case, called pseudo-codewords is less straightforward.
Stepping back briefly we note that the low complexity of iterative message-
passing decoding is because the algorithm operates locally on the Tanner graph
representing the matrix H (i.e. each node in the decoding algorithm acts only
on the messages it can see, not on the other messages in the graph). This same
operation also leads to a fundamental weakness of the algorithm: because it acts
locally, each node does not know the whole structure of the Tanner graph.
An alternative graph which would produce, locally, the same LLRs as the
actual Tanner graph is called a finite lift or cover of the Tanner graph. Pseudo-
codewords can be thought of as the set of valid codewords in all finite lifts of
the Tanner graph. Since the message-passing decoder cannot locally distinguish
between the actual Tanner graph and the lifted graphs, any codeword in any of
the lifted graphs is as equally valid as a codeword in the Tanner graph. Thus
when we say that the decoder has failed to converge it has actually converged
to one of these pseudo-codewords.

4.1.3 Threshold vs. erasure floor using stopping sets

Unfortunately, the LDPC codes which are capacity approaching have poor er-
ror floor performances, while the codes with extremely low error floors have
thresholds far from capacity. The large number of weight-2 nodes returned by
optimizing the degree distribution result in a reduced minimum distance for the
ensemble. This tradeoff is made more precise on the BEC using stopping sets.
On the binary erasure channel the message-passing decoder will fail if the
erased bits contain a stopping set and so, for a given erasure rate, the expected
number of stopping sets will determine the expected error rate of the decoder.
To determine the impact of the weight two nodes only the stopping sets in the
subgraph, T2 , which includes the degree-2 bit nodes, all of the edges connected
to degree-2 bit nodes and the check nodes connected to the degree-2 bit nodes
by an edge, are considered.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 60 version 1.1
 Since the degree of all the bit nodes in T2 is 2, a stopping set of size k in T2
is also a cycle of size 2k. The expected number of cycles of size k in a length n
ensemble is:
(λ2 ρ′ (1))k
Ek−cycles (Cλ(x),ρ(x) , n) = + O(n−1/3 ), (4.2)
2k
and thus the average probability that a randomly chosen size-v subset of the
ψ2 n degree-2 bit nodes in the ensemble Cλ(x),ρ(x) is a stopping set is:

(λ2 ρ′ (1))v /2v + O(n−1/3 )

PSS (Cλ(x),ρ(x) , v) = ψ2 n

.
v

The word error rate on the BEC with erasure probability ǫ is lower bounded by
summing over the contribution of stopping sets of size s = 2, . . . , ψ2 n in the
ψ2 n degree-2 bit nodes:

ψ2 n  
X ψ2 n
EWER (Cλ(x),ρ(x) , n, ǫ) ≥ ǫs PSS (Cλ(x),ρ(x) , s)
s
s=2
ψ2 n  
X
s (λ2 ρ′ (1))s −1/3
= ǫ + O(n ) , (4.3)
2s
s=2

where ǫs is the probability of an erasure of size at least s occurring. For asymp-

totically long codes,

ψ2 n
X (λ2 ρ′ (1)ǫ)s
lim EWER (Cλ(x),ρ(x) , n, ǫ) ≥ lim
n→∞ ψ2 n→∞ 2s
s=2
!
1 (λ2 ρ′ (1)ǫ)
= ln p − . (4.4)
1 + λ2 ρ′ (1)ǫ 2

For randomly constructed LDPC codes from the ensemble with degree dis-
tribution pair (λ(x),ρ(x)) and girth g, the expected error floor performance of
the ensemble will be dominated by stopping sets of size g/2 and the word error
rate is approximated by
g
(λ2 ρ′ (1)ǫ) 2
Wg , . (4.5)
g
To bound the ensemble degree distribution to obtain a word error rate below Wg
the degree distribution is constrained to satisfy:
E
λ2 ≤ , where E , (gWg )2/g , (4.6)
ρ′ (1)ǫ∗

and ǫ∗ is the threshold value returned by density evolution. Thus ǫ < ǫ∗ corre-
sponds to the error floor region of the WER curve, making ǫ∗ an ideal erasure
probability at which to evaluate (4.5). Note that setting E = 1 returns the sta-
bility constraint for the BEC and the traditional optimized degree distribution is
returned.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 61 version 1.1
 0
10

−1 E=1
10
E = 0.44

−2 E = 0.02
10
(3,6)−regular

−3
10
Erasure Rate

−4
10

−5
10

−6
10

−7
10

−8
10

−9
10
0.55 0.5 0.45 0.4 0.35 0.3 0.25 0.2 0.15 0.1
BEC erasure probability (ε)

Figure 4.4: Average decoding performances of LDPC ensembles with con-

strained degree distributions from Example 4.4.

Example 4.4.
Fig. 4.4 shows the simulated ensemble average performance, using message-
passing decoding, of codes with varying degree distributions. The irregular en-
semble gives the best threshold performance, but a very poor error floor, while
the regular LDPC ensemble has a better error floor and worse threshold. The
constrained degree distributions allow a tradeoff between the threshold and er-
ror floor performance to be made.

Similar arguments apply to constraining the degree distributions of LDPC

codes designed for more general memoryless channels. For these channels, the
number of low weight codewords within T2 are controlled by constraining λ2 .

4.2 Easily encodable LDPC codes

Rather than trying to convert a parity-check matrix into an encodable form after
it has been produced, encodability can be instead be incorporated into the de-
sign of the parity-check matrix. For classical codes this has been successfully
achieved using cyclic and quasi-cyclic codes and the same ideas can be applied
to LDPC codes.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 62 version 1.1
4.2.1 Quasi-cyclic codes
A code is quasi-cyclic if for any cyclic shift of a codeword by c places the
resulting word is also a codeword, and so a cyclic code is a quasi-cyclic code
with c = 1. The simplest quasi-cyclic codes are row circulant codes which are
described by a parity-check matrix

H = [A1 , A2 , . . . , Al ], (4.7)

where A1 , . . . , Al are binary v × v circulant matrices.

Provided that one of the circulant matrices is invertible (say Al ) the gener-
ator matrix for the code can be constructed in systematic form
 
(A−1
l A1 )
T

 Iv(l−1) (A−1
l A2 )
T 

G= .. , (4.8)
 . 
(A−1
l Al−1 )
T

resulting in a quasi-cyclic code of length vl and dimension v(l − 1). As one of

the circulant matrices is invertible, the construction of the generator matrix in
this way necessarily leads to a full rank H.
The algebra of (v ×v) binary circulant matrices is isomorphic to the algebra
of polynomials modulo xv − 1 over GF(2) [20]. A circulant matrix A is com-
pletely characterized by the polynomial a(x) = a0 +a1 x+· · ·+av−1 xv−1 with
coefficients from its first row, and a code C of the form (4.7) is completely char-
acterized by the polynomials a1 (x), . . . , al (x). Polynomial transpose is defined
as
n−1
X
T
a(x) = ai xn−i (xn = 1).
i=0
For a binary code, length n = vl and dimension k = v(l − 1), the k bit message
[i0 , i1 , . . . , ik−1 ] is described by the polynomial i(x) = i0 +i1 x+· · ·+ik−1 xk−1
and the codeword for this message is c(x) = [i(x), p(x)], where p(x) is given
by
Xl−1
T
p(x) = ij (x) ∗ (a−1
l (x) ∗ aj (x)) , (4.9)
j=1

ij (x) is the polynomial representation of the information bits iv(j−1) to ivj−1 ,

ij (x) = iv(j−1) + iv(j−1)+1 x + · · · + ivj−1 xv−1

and polynomial multiplication (∗) is modulo xv − 1.

Example 4.5.
A rate- 12 quasi-cyclic code with v = 5, is made up of a first circulant described
by a1 (x) = 1 + x, and a second circulant described by a2 (x) = 1 + x2 + x4 .
 
1 1 1 1 1

 1 1 1 1 1 

H=  1 1 1 1 1 
 1 1 1 1 1 
1 1 1 1 1

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 63 version 1.1
 parity checks

bits in the first circulant bits in the second circulant

Figure 4.5: A Tanner graph for the quasi-cyclic LDPC code in Example 4.5

The second circulant is invertible

2 3 4
a−1
2 (x) = x + x + x ,

and so the generator matrix contains a 5 × 5 identity matrix and the 5 × 5 matrix
described by the polynomial
T 2 T 3
(a−1
2 (x) ∗ a1 (x)) = (1 + x ) = 1 + x .

 
1 1 1

 1 1 
 1
G=
 1 1 1 

 1 1 1 
1 1 1
Fig. 4.5 shows the Tanner graph for H.

Linear-time encoding can be achieved using (l − 1) v-stage shift registers

with separate length v shift registers for each circulant in G.

Example 4.6.
A quasi-cyclic, length-108, rate-3/4 LDPC code has the parity-check matrix:

H = [A1 , A2 , A3 , A4 ].

H consists of four circulants defined by

a1 (x) = 1 + x3 + x16 ,

a2 (x) = x2 + x6 + x8 ,
a3 (x) = x + x8 + x9 ,
a4 (x) = x + x13 + x23 .
The polynomial a4 (x) is invertible with inverse given by
4 5 6 7 9 12 13 15 17 20 21 23 24 25
a−1
4 (x) = x+x +x +x +x +x +x +x +x +x +x +x +x +x +x ,

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 64 version 1.1
and so the parity-check matrix can be put into systematic form

Hs = [A−1 −1 −1
4 A1 , A4 A2 , A4 A3 , I27 ].

We thus have,
a−1 4 5 7 9 11 13
4 (x)a1 (x) = 1 + x + x + x + x + x + x + x + x + x + x
15 18 19

+x22 + x23 + x25 + x26 ,

−1
a4 (x)a2 (x) = x4 + x5 + x7 + x9 + x12 + x17 + x19 + x22 + x26 ,
a−1 4 6 7 10 13 14 15
4 (x)a3 (x) = x + x + x + x + x + x + x + x + x + x
18 19 21

+x22 + x23 + x24 + x25 + x26 ,

and the generator matrix for this code is:
 
(A−1
4 A1 )
T

G= I81 (A−1

4 A2 )
T .

(A−1
4 A3 )
T

Using G in this form the code can be encoded using shift registers. Figure 4.6
shows an encoding circuit for this code.

Note that although we use Hs to construct G we will use the original ma-
trix, H to do our decoding. Both H and Hs are valid parity-check matrices for
the code, however H has the properties required for sum-product decoding.

Block circulant quasi-cyclic codes

More general quasi-cyclic codes are the block circulant codes. The parity-
check matrix of a block circulant quasi-cyclic LDPC code is:
 
Ip Ip Ip ... Ip
 Ip Ip (p1,1 ) Ip (p1,2 ) ... Ip (p1,wr ) 
 
 .. .. .. ,
 . . . 
Ip Ip (pwc −1,1 ) Ip (pwc −1,2 ) . . . Ip (pwc −1,wr −1 )

where Ip represents the p×p identity matrix and Ip (pi,j ) represents the circulant
shift of the identity matrix by r+pi,j ( mod p) columns to the right which gives
the matrix with the r-th row having a one in the (r + pi,j mod p)-th column.
Block circulant LDPC codes can have better minimum distances and girths than
row-circulant codes.

4.2.2 Repeat-accumulate codes

Earlier we saw that an LDPC code can be put into an approximate upper trian-
gular form so as to facilitate almost linear-time encoding. A repeat-accumulate
(RA) code is an LDPC code with an upper triangular form already built into the
parity-check matrix during the code design.
An m × n RA code parity-check matrix H has two parts:

H = [H1 , H2 ], (4.10)

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 65 version 1.1
 u1 u28 u55

: : :
+
+

+
: : :

C82... C108
+

u27 u54 u81

Figure 4.6: Encoding circuit for the n = 108, k = 81 LDPC code from Exam-
ple 4.6.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 66 version 1.1
where H2 is an m × m matrix with the form:
 
1 0 0 0 0 0
 1 1 0 ··· 0 0 0 
 
 0 1 1 0 0 0 
 

H2 =  .. .. .. 
. . . . (4.11)
 
 0 0 0 1 0 0 
 
 0 0 0 ··· 1 1 0 
0 0 0 0 1 1

The parity-check matrix of an RA code is called (q, a)-regular if the weight

of all the rows of H1 are the same, a, and the weight of all the columns of
H1 are the same, q. Note that a regular RA parity-check matrix has columns of
weight 2, and one column of weight 1, in H2 and so is not regular in the sense of
(j, r)-regular LDPC codes. An irregular RA code will have an irregular column
weight distribution in H1 , with H2 the same as for a regular code.

Example 4.7.
A (3,2)-regular RA parity-check matrix for a length-10 rate-2/5 code is:
 
1 . 1 . 1 . . . . .
 . 1 . 1 1 1 . . . . 
 
 1 1 . . . 1 1 . . . 
H=   (4.12)
 . . 1 1 . . 1 1 . . 

 1 . 1 . . . . 1 1 . 
. 1 . 1 . . . . 1 1

As for LDPC codes, the Tanner graph of an RA code is defined by H, where

there is a parity-check equation vertex for every parity-check equation in H and
a bit vertex for every codeword bit. The Tanner graph of an RA code consists
of m = kq/a check vertices and k + m = k(q + a)/a bit vertices.
Unlike for a general LDPC code, the message bits in the codeword of an
RA code are easily distinguished from the parity bits. Fig. 4.7 shows the Tanner
graph for the RA code from Example 4.7. We distinguish between message bit
vertices corresponding to the K message bits in the codeword, shown at the top
of the graph, and parity bit vertices corresponding to the M parity-check bits in
the codeword, which are shown at the bottom of the graph.

Encoding RA codes

The encoding of an RA code is split into four main operations. Firstly, since
H is systematic we know that the columns of H1 correspond to the message
bits. From the column regularity of H1 we see that each message bit is repeated
q times, which can be implemented with a rate 1/q repetition code. Next, the
row regularity of H1 shows that for every parity-bit a of these repeated message
bits are summed modulo 2, a process that we implement using a combiner. The
final step is to define the mapping of the repeated message bits to the combiner
inputs. This is done by defining a permutation pattern Π called an interleaver.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 67 version 1.1
 message bits

parity bits

Figure 4.7: The Tanner graph for the RA parity-check matrix in Example (4.7).

Example 4.8.
The code in Example 4.7 is a length-10 RA code with q = 3 repetition code,
a = 2 combiner and the interleaver Π = [1, 7, 4, 10, 2, 5, 8, 11, 3, 9, 6, 12].

The encoding process is as follows: The qK bits at the output of the rep-
etition code are q copies of the K message bits m = [m1 , . . . , mK ], in the
form

b = [b1 , b2 , . . . , bqK ]
= [m1 , m1 , . . . , m1 , m2 , m2 , . . . , m2 , . . . , mK , mK , . . . , mK ],
| {z } | {z } | {z }
q q q

and so we have
bi = mf (i) , f (i) = ⌈i/q⌉, (4.13)
where ⌈x⌉ denotes the smallest integer greater than or equal to x.
The interleaver pattern, Π = [π1 , π1 , . . . , πn ], defines a permutation of the
input bits, b = [b1 , b2 , . . . , bn ], to the output bits

d = [d1 , d2 , . . . , dn ] = [bπ1 , bπ2 , . . . , bπn ]. (4.14)

Thus two different interleaver patterns will describe the same RA code if the
difference in the permutation pattern results in a difference in which copy of the
same message bit is used.
The bits at the output of the interleaver are combined, modulo-2, in sets
of a bits, before being passed to the accumulator. Thus the M = Kq/a bits,
r = [r1 , r2 , . . . , rM ], at the output of the combiner, are given by

ri = d(i−1)a+1 ⊕ d(i−1)a+2 ⊕ · · · ⊕ dia , i = 1, 2, . . . , M, (4.15)

where ⊕ denotes modulo-2 addition.

Finally, the M parity bits, p = [p1 , p2 , . . . , pM ], at the output of the accu-
mulator are defined by

pi = pi−1 ⊕ ri , i = 1, 2, . . . , M. (4.16)

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 68 version 1.1
 m

Interleaver
m repetition b d combiner r accumulator p
K
code
Kq Kq M M

Figure 4.8: The encoding circuit for RA codes.

k message bit vertices

q edges ..... repetition

code
.... .... .... ....
interleaver
.... .... .... ....
a edges combiner
.....
accumulator
.....
m parity bit vertices

Figure 4.9: An RA code Tanner graph.

We consider systematic RA codes, that is codes for which both the original
message bits and the parity bits are explicitly sent to the receiver, and so the
final codeword is c = [m1 , m2 , . . . , mK , p1 , p2 , . . . , pM ], and thus we have a
a
code with length, N = K(1 + q/a), and rate R = a+q .
The rows of H1 describe the equations in (4.13)-(4.15), e.g. if we have
ri = mc1 + mc2 then the i-th row of H1 is ‘1’ in the columns c1 and c2 and ‘0’
elsewhere. In equation (4.10), H2 is an M × M matrix which describes (4.16):
Fig. 4.8 shows the encoding circuit for RA codes.
Those familiar with turbo codes will note that the encoder of an RA code
looks a lot like that of a serially concatenated turbo code. Indeed RA codes
were first presented as a simple class of turbo codes for which coding theories
could be developed. The two component codes are the repetition code and
1
1+D
convolutional code which is the accumulator. Fig. 4.9 shows the relationship
between the LDPC and turbo code representations of an RA code.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 69 version 1.1
4.3 Bibliographic notes
The effect of cycles on the practical performance of LDPC codes was demon-
strated by simulation experiments when LDPC codes were rediscovered by
MacKay and Neal [21] in the mid-1990s, and the beneficial effects of using
graphs free of short cycles were shown [7]. By proving the convergence of the
sum-product algorithm for codes whose graphs are free of cycles, Tanner was
the first to formally recognize the importance of cycle-free graphs in the context
of iterative decoding [2].
Stopping sets were introduced in [22] and used to develop analysis tools for
finite length LDPC ensembles. For more on stopping sets and finite-length
analysis see [23–25] while a good source for more information on pseudo-
codewords is [26].
Quasi-cyclic codes, were first presented in [27] and [20], for a good in-
troduction to quasi-cyclic codes see [28] or [8]. Block circulant quasi-cyclic
LDPC codes are well presented in [29].

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 70 version 1.1
Topic 5: LDPC Code Construction

In the previous topic a number of the properties that make a good LDPC code
have been discussed. In this section some of the methods used to construct
LDPC codes which achieve these properties are outlined.

5.1 Graph based constructions

For long codes, randomly choosing a parity-check matrix almost always pro-
duces a good code. In fact for very long codes this is guaranteed by the con-
centration theorem which says that behavior of randomly chosen codes from an
ensemble concentrates around the ensemble average. Nevertheless, for practi-
cal applications the codes may not be long enough and a user is not going to
accept a code that “will probably” work. Most codes are constructed at least
pseudo-randomly, where the construction is random but certain bad configura-
tions such as 4-cycles, are either avoided during construction or removed after-
wards. Some of these techniques are considered in the following:

Column or row splitting

In this technique cycles, or indeed any unwanted configurations, in the

parity-check matrix are removed by splitting a column or row in half. In col-
umn splitting a single column in H is replaced by two columns which share the
entries of the original column between them. Since an extra column has been
added, a new code is produced with length one greater than the previous code,
and with a parity-check matrix made slightly more sparse.

Example 5.1.
Figure 5.1 shows column splitting applied to remove a 4-cycle.

Figure 5.1: Column splitting to remove a 4-cycle.

71
 Figure 5.2: Row splitting to remove a 4-cycle.

1
2 2 3
3 1

1
2
1
2 3

Figure 5.3: Bit filling to avoid cycles of size 4.

Alternatively, a single row in H can be replaced by two rows which share

the entries of the original row between them. Since an extra row has been
added, a new code is produced with 1 more parity-check equation in H than the
previous H and with a parity-check matrix which is slightly more sparse.

Example 5.2.
Figure 5.2 shows row splitting applied to remove a 4-cycle.

Bit filling or progressive edge growth (PEG) Tanner graphs

In bit filling bit nodes are added to the Tanner graph one at a time and edges
connecting the new bit nodes to the graph are chosen to avoid cycles of size
g. For each new bit node bi , wc check nodes are selected to join by an edge to
bi . The set of feasible check nodes are the nodes that are distance g/2 or more
edges away from all of the check nodes already connected to b + i. From each
set of feasible check nodes the check node chosen is the one which least used
so far (i.e. with the lowest degree). Fig 5.3 shows this process.
In progressive edge growth Tanner graphs edges are similarly added to the
graph one at a time but instead of meeting some fixed girth requirement g the
edge is added so as to maximize the local girth at the current bit node.
These techniques can also be applied to semi-structured codes, i.e. an RA
code can be constructed by fixing the accumulator portion of the Tanner graph
and applying bit filling to the remaining bit nodes.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 72 version 1.1
5.2 Codes from designs
A combinatorial design is an assignment of a set of objects into subsets subject
to some defined condition on the size, structure or incidence of the subsets.

Example 5.3.
A simple combinatorial problem is to arrange a set of seven academics into
seven committees with three academics in each committee, every academic
serving on the same number of committees, and each pair of academics serving
together in exactly one committee. The set of academics (points)

P = {1, 2, 3, 4, 5, 6, 7}

can be formed into a design with committees (blocks),

B = {[1, 3, 5], [2, 3, 7], [4, 5, 7], [1, 6, 7], [1, 2, 4], [3, 4, 6], [2, 5, 6]}. (5.1)

Formally, an incidence structure (P, B, I) consists of a finite non-empty set

P of points (academics) and a finite non-empty set B of subsets of those points
called blocks (committees), together with an incidence relation I ⊆ P × B. A
point P and block B are incident, denoted P ∈ B, if and only if (P, B) ∈
I. A design D is an incidence structure with a constant number of points per
block and no repeated blocks. A design is regular if the number of points in
each block, and the number of blocks which contain each point, designated γ
and r respectively, are the same for every point and block in the design. In the
field of combinatorial designs the block size is usually denoted by the symbol
k, however we use γ in this thesis to avoid confusion with the use of k for the
number of message symbols in the code.
Every design can be represented by a v × b binary matrix N , v = |P|,
b = |B| called an incidence matrix, where each column in N represents a block
Bj of the design and each row a point Pi . The (i, j)th entry of N is a one if the
i-th point is contained in the j-th block, otherwise it is 0:

1 if Pi ∈ Bj ,
Ni,j = (5.2)
0 otherwise.
S
The incidence graph of D has vertex set P B, with two vertices x and y
connected if and only if x ∈ P, y ∈ B and Px ∈ By , or x ∈ B, y ∈ P and
Py ∈ Bx , and is thus a bipartite graph.

Example 5.4.
The design in Example 5.3 can easily be seen to satisfy the regularity constraint
with γ = 3 points in every block (3 academics in every committee) and each
point in exactly r = 3 blocks (each academic on exactly three committees). An
incidence matrix and incidence graph for this design are shown in Fig 5.4 using

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 73 version 1.1
 4
2 6
block nodes
point nodes
1 7
2 3 4 5
6

1
3 5

Figure 5.4: An incidence graph of the 2-(7, 3, 1) design in Example 5.3.

an ordering of blocks 1–7 respectively from left to right.

 
1 0 0 1 1 0 0
 0 1 0 0 1 0 1 
 
 1 1 0 0 0 1 0 
 
N =  0 0 1 0 1 1 0 

 1 0 1 0 0 0 1 
 
 0 0 0 1 0 1 1 
0 1 1 1 0 0 0

The design in Example 5.3 is from a class of designs called 2-designs. These
designs have the property that every pair of points appear together in a fixed
number λ of blocks together and are denoted 2-(v, b, r, γ, λ). For the design in
Example 5.3, each pair of points (academics) occurs in one block (committee)
together thus the blocks in B form a 2-design with v = b = 7, γ = r = 3,
and λ = 1. The 2-designs with λ = 2, called Steiner 2-designs, are particularly
useful for LDPC codes. An LDPC code is defined by setting the incidence
matrix of the design as the parity-check matrix of the code. Designs which
are regular give regular LDPC codes and sparse codes are defined by choosing
designs with γ and r small relative to v and b. In particular 4-cycle free LDPC
codes are guaranteed by choosing Steiner 2-designs since each pair of points
(rows of H) cannot occur in more than one block (column of H) together and
so a 4-cycle cannot be formed.
Combinatorial designs and error correction codes have a long history to-
gether. The blocks of a design can be associated with the codewords of a code,
as for the geometric codes, which have minimum weight codewords the inci-
dence vectors of the blocks of a projective or Euclidean geometry designs. The
minimum weight codewords of Reed-Muller and punctured Reed Muller codes
are the blocks of the PG(m, 2) designs while the generalized Reed-Muller codes
have as minimum weight codewords the blocks of the geometries PG(m, q).
Designs have also played a role in defining new codes such as in the case
of difference set cyclic codes. In this case the codes were defined using the
transpose of the incidence matrix of the projective geometry design, PG(2, q),
as the code parity-check matrix. The properties of these projective geometry
designs are well suited to the majority logic decoding algorithm. More recently
these codes have had an important impact on the field of iterative decoding

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 74 version 1.1
when it was shown that the properties that make them majority logic decodable
also make them excellent LDPC codes.
From a combinatorial perspective, a design is generally associated with a
code of length v defined as the column space of the design incidence matrix
N , called its block code or a code defined as the column space of the design
incidence matrix transpose N T , called its point code . The block code of a
design can be thought of as the code with generator matrix given by N T . Most
of the general results about designs in codes including the celebrated Assmus–
Mattson theorem [30] consider these block codes.
For LDPC codes the dual codes of the block and point codes are of interest.
The dual of the block (respectively point) codes have as their dual space the
column space of N (respectively N T ). Thus the incidence matrix of the design,
or its transpose, is the parity-check matrix of the code. The dual of the point
code, using the incidence matrix of a design as the parity-check matrix of the
code, in particular, are used to define LDPC codes.

Finite geometries
An area closely related to designs is that of finite geometries. The finite
projective geometry of a vector space V of dimension m + 1, PG(V ), has
as elements the subspaces of V . The points of PG(V ) are the 1-dimensional
subspaces of V , the lines are 2-dimensional subspaces of V , the planes are
3-dimensional subspaces of V and so on to hyperplanes the m-dimensional
subspaces of V . The incidence between elements of PG(V ) corresponds to
containment between subspaces of V . Thus a point P is incident with a line L
in PG(V ) if the 1-dimensional subspace corresponding to P is contained in the
2-dimensional subspace corresponding to L. For V a vector space of dimen-
sion m + 1 over the field F = GF(q), the projective geometry is often written
PG(m, q). A Euclidean geometry EG(V ) has as elements the cosets x + U of
the subspaces U of V where x is any vector in V and incidence is again given
by containment.
Designs can be formed by taking as points of the design the points of the
geometries and as blocks the lines, planes or hyperplanes of the geometry with
the incidence of the geometry carried into the design. The designs consisting
of the points and lines of PG(2, q) are finite projective planes of order q. The
PG designs, which give us PG-LDPC codes, are the set of q 2 + q + 1 lines and
q 2 + q + 1 points such that every line passes through exactly q + 1 points and
every point is incident on exactly q + 1 lines. Since, any pair of points in the
plane must be incident together in exactly one line. The points and lines of a
projective plane are the points and blocks of a 2-(q 2 + q + 1, q + 1, 1) design
with the incidence of the design given by the incidence of the plane. Fig. 5.5
shows the typical representation of the finite projective plane of order 3. The
designs of points and lines of PG(m, 2) are the classical Steiner triple systems
or 2-(v, 3, 1) designs which lead to STS-LDPC codes.

Example 5.5.
Figure 5.5 shows the finite projective plane of order 3 which consists of 13
points on 13 lines.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 75 version 1.1
Figure 5.5: The finite projective plane of order 3 consists of 13 points on 13
lines

An important outcome of the work with algebraic codes was the demonstra-
tion that highly redundant parity-check matrices can lead to very good iterative
decoding performances without the need for very long block lengths. While the
probability of a random graph having a highly redundant parity-check matrix
is vanishingly small, the field of combinatorial designs offers a rich source of
algebraic constructions for matrices which are both sparse and redundant.

Example 5.6.
Starting with the Euclidean geometry EG(2, 24 ) the EG design is the 22s − 1
points of the geometry not including the origin and blocks of the design are
the 22s − 1 lines of the geometry which do not pass through the origin. The
incidence matrix of this EG design is thus a square 255 × 255 matrix with
column and row weights both 16. Although this incidence matrix is square it
has a large number of linearly dependent rows, and rank 80.
The dual of the block code of this EG design, i.e. the code with parity-check
matrix N , produces a length 255 rate-175/255 LDPC code with a 16, 16-regular
parity-check matrix.
Figure 5.6 shows the bit error rate performance on an AWGN channel of a
short EG LDPC code from a Euclidean geometry compared to an LDPC con-
structed pseudo-randomly using Neal’s construction. Although both codes have
the same length and rate the EG code has significantly more rows in its parity-
check matrix, and a much greater minimum distance, of 17, which gives it its
improved performance.

Partial geometries
LDPC codes have also been defined from a more general class of designs
called partial geometries. A partial geometry is a set of points, and subsets
of those points, called blocks or lines, completely specified by three parame-
ters, s, t, and α. A partial geometry, denoted pg(s, t, α), satisfies the following
properties:
P1. Each point P is incident with t + 1 blocks and each block B is incident
with s + 1 points.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 76 version 1.1
 −1
10

−2
10

−3
10

Bit error rate −4

10

−5
10

Uncoded BPSK
Random LDPC [256,214,≥ 4]
−6 TD LDPC [256,214,6]
10
Random LDPC [255,175,≥ 4]
EG LDPC [255,175,≥ 17]

−7
10
1 2 3 4 5 6 7
Signal−to−noise ratio E /N (dB)
b 0

Figure 5.6: The decoding performance of length-256 LDPC codes on an AWGN

channel using sum-product decoding with a maximum of 200 iterations.

P2. Any two blocks have at most one point in common.

P3. For any non-incident point-block pair (P, B) the number of blocks inci-
dent with P and intersecting B equals some constant α.

Example 5.7.
The incidence matrix of the partial geometry pg(1, 2, 1) is:
 
1 1 1 0 0 0 0 0 0
 1 0 0 1 0 0 1 0 0 
 
 0 0 0 1 1 1 0 0 0 
N =  0 1 0 0 1 0 0 1 0 .

 
 0 0 1 0 0 1 0 0 1 
0 0 0 0 0 0 1 1 1

Fig 5.7 gives its incidence graph.

The subset of the partial geometries with α = s + 1 are exactly Steiner

2-designs since if a point P is not incident in a block B, every block incident
with P must intersect B and thus every pair of points must appear in a block
together. The four main classes of partial geometries are:

• a partial geometry with α = s + 1 is a Steiner 2-design or 2-(v, s + 1, 1)

design,

• a partial geometry with α = t is called a net or, dually with α = s, a

transversal design (TD),

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 77 version 1.1
 2 8
4

9
1 6

3 5 7

5 1 2

4
6 3

Figure 5.7: The incidence graph for the partial geometry pg(1,2,1) in Exam-
ple 5.7.

• a partial geometry with α = 1 is called a generalized quadrangle (GQ),

• if 1 < α < min{s, t} the partial geometry is proper,

The transversal designs, generalized quadrangles, and partial geometries also

make good LDPC codes. The generalized quadrangles in particular can define
LDPC codes with girth 8.

Example 5.8.
The incidence matrix of the transversal design, with α = s = 2 and t = 15,
produces the parity-check matrix of a length-256 rate-214/256, (3, 16)-regular
LDPC code. Figure 5.6 also shows the bit error rate performance on an AWGN
channel of a short LDPC code from a transversal design compared to an LDPC
constructed pseudo-randomly using Neal’s Algorithm.

In addition to a deterministic construction and guaranteed lower bounds

on girth and minimum distance the LDPC codes from combinatorial designs
can also produce codes which offer straightforward encoders. Many of the
STS, Euclidean and projective geometry designs produce cyclic and quasi-
cyclic codes. For example the quasi-cyclic code in Example 4.6 was derived
from a cyclicly resolvable STS design. However, even for designs which are
not cyclic, straightforward encoding can be achieved using the structure of the
design.
Further quasi-cyclic LDPC codes can be constructed explicitly using com-
binatorial structures called difference families.

Difference families
Row-circulant quasi-cyclic LDPC codes can be constructed using combi-
natorial deigns called difference families. A difference family is an arrange-
ment of a group of v elements into not necessarily disjoint subsets of equal
size which meet certain difference requirements. More precisely: The t γ-
element subsets, called base blocks, of an Abelian group G, D1 , . . . , Dt with
Di = {di,1 , di,2 , . . . , di,γ } form a (v, γ, λ) difference family if the differences
di,x − di,y , (i = 1, . . . t; x, y = 1, . . . , γ, x 6= y) give each non-zero element

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 78 version 1.1
of G exactly λ times. If the Abelian group is Zv each translate is a cyclic shift
and the difference family is a cyclic difference family.
Example 5.9. The subsets D1 = {1, 2, 5}, D2 = {1, 3, 9} of Z13 form a
(13, 3, 1) difference family with differences:

From D1 : 2 − 1 = 1, 1 − 2 = 12, 5 − 1 = 4,
1 − 5 = 9, 5 − 2 = 3, 2 − 5 = 10,
From D2 : 3 − 1 = 2, 1 − 3 = 11, 9 − 1 = 8,
1 − 9 = 5, 9 − 3 = 6, 3 − 9 = 7.

Difference families with λ = 1 allow the design of quasi-cyclic codes free

of 4-cycles. To construct a length vl rate l−1 l regular quasi-cyclic code H =
[a1 (x), a2 (x), . . . , al (x)] with column weight γ, take l of the base blocks of a
(v, γ, 1) difference family, and define the jth circulant of H as the transpose of
the circulant formed from the jth base block in the difference family as follows:

aj (x) = xdj,1 + xdj,2 + · · · + xdj,γ .

5.3 Bibliographic notes

Tanner founded the topic of algebraic methods for constructing graphs suit-
able for sum-product decoding in [2]. The length 73 finite geometry code was
first implemented on an integrated circuit using iterative decoding by Karplus
and Krit [31] and many subsequent authors have considered the construction
of LDPC codes using designs [32–36], partial geometries [37] and general-
ized quadrangles [38]. Graph-based constructions for codes with good girth
have been presented by Margulis [39], and extended by Rosenthal and Vonto-
bel [40] and Lafferty and Rockmore [41]. While other constructions for LDPC
codes have been presented which have a mixture of algebraic and randomly
constructed portions [42]. The monograph by Assmus and Key [43] gives an
excellent treatment of the connection between codes and designs. For more on
designs see [44] and a good source of constructions is [45].

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 79 version 1.1
 B IBLIOGRAPHY

[1] R. G. Gallager, Low-Density Parity-Check Codes. Cambridge, MA: MIT

Press, 1963.

[2] R. M. Tanner, “A recursive approach to low complexity codes,” IEEE

Trans. Inform. Theory, vol. IT-27, no. 5, pp. 533–547, September 1981.

[3] M. G. Luby, M. Mitzenmacher, M. A. Shokrollahi, D. A. Spielman, and

V. Stemann, “Practical loss-resilient codes,” in Proc. 30th ACM Symp. on
the Theory of Computing, 1998, pp. 249–258.

[4] M. G. Luby, M. Mitzenmacher, M. A. Shokrollahi, and D. A. Spielman,

“Improved low-density parity-check codes using irregular graphs,” IEEE
Trans. Inform. Theory, vol. 47, no. 2, pp. 585–598, February 2001.

[5] S.-Y. Chung, G. D. Forney, Jr., T. J. Richardson, and R. L. Urbanke, “On

the design of low-density parity-check codes within 0.0045 dB of the
Shannon limit,” IEEE Commun. Letters, vol. 5, no. 2, pp. 58–60, February
2001.

[6] T. J. Richardson and R. L. Urbanke, “Efficient encoding of low-density

parity-check codes,” IEEE Trans. Inform. Theory, vol. 47, no. 2, pp. 638–
656, February 2001.

[7] D. J. C. MacKay, “Good error-correcting codes based on very sparse ma-

trices,” IEEE Trans. Inform. Theory, vol. 45, no. 2, pp. 399–431, March
1999.

[8] S. B. Wicker, Error Control Systems for Digital Communication and Stor-
age. Upper Saddle River, NJ 07458: Prentice Hall, 1995.

[9] S. Lin and D. J. Costello Jr., Error Control Coding, 2nd ed. New Jersey:
Prentice Hall, 2004.

[10] F. J. MacWilliams and N. J. A. Sloane, The Theory of Error-Correcting

Codes. Amsterdam: North-Holland, 1977.

[11] W. C. Huffman and V. Pless, Fundamentals of Error Correcting Codes.

Cambridge University Press, Cambridge UK, 2003.

[12] C. Berrou and A. Glavieux, “Near optimum error correcting coding and
decoding: Turbo codes,” IEEE Trans. Commun., vol. 44, no. 10, pp. 1261–
1271, October 1996.

[13] A. Papoulis, Probability, random variables and stochastic processes. 2nd

Ed. Singapore: McGraw-Hill, 1984.

80
[14] T. J. Richardson and R. L. Urbanke, “The capacity of low-density parity-
check codes under message-passing decoding,” IEEE Trans. Inform. The-
ory, vol. 47, no. 2, pp. 599–618, February 2001.

[15] M. G. Luby, M. Mitzenmacher, and Shokrollahi, “Analysis of random

processes via and-or tree evaluation,” Proceedings of the 9th Annual ACM-
SIAM Symposium on Discrete Algorithms, pp. 364–373, 1998.

[16] T. J. Richardson, M. A. Shokrollahi, and R. L. Urbanke, “Design of

capacity-approaching irregular low-density parity-check codes,” IEEE
Trans. Inform. Theory, vol. 47, no. 2, pp. 619–637, February 2001.

[17] A. Amraoui and R. L. Urbanke, LdpcOpt:

hhttp://lthcwww.epfl.ch/research/ldpcopt/i.

[18] D. Hayes, S. Weller, and S. Johnson, LODE:

hhttp://sigpromu.org/ldpc/DE/i.

[19] M. Sipser and D. A. Spielman, “Expander codes,” IEEE Trans. Inform.

Theory, vol. 42, no. 6, pp. 1710–1722, November 1996.

[20] M. Karlin, “New binary coding results by circulants,” IEEE Trans. Inform.
Theory, vol. IT-15, no. 1, pp. 81–92, 1969.

[21] D. J. C. MacKay and R. M. Neal, “Near Shannon limit performance

of low density parity check codes,” Electron. Lett., vol. 32, no. 18, pp.
1645–1646, March 1996, reprinted Electron. Lett, vol. 33(6), pp. 457–
458, March 1997.

[22] C. Di, D. Proietti, I. E. Telatar, T. J. Richardson, and R. L. Urbanke,

“Finite-length analysis of low-density parity-check codes on the binary
erasure channel,” IEEE Trans. Inform. Theory, vol. 48, no. 6, pp. 1570–
1579, June 2002.

[23] T. J. Richardson and R. L. Urbanke, “Finite-length density evo-

lution and the distribution of the number of iterations on the
binary erasure channel,” unpublished manuscript, available at
hhttp://lthcwww.epfl.ch/papers/RiU02.psi.

[24] T. J. Richardson, M. A. Shokrollahi, and R. L. Urbanke, “Finite-length

analysis of various low-density parity-check ensembles for the binary era-
sure channel,” in Proc. International Symposium on Information Theory
(ISIT’2002), Lausanne, Switzerland, June 30 – July 5 2002, p. 1.

[25] S. J. Johnson and S. R. Weller, “Constraining LDPC degree distributions

for improved error floor performance,” IEEE Commun. Letters, 2006.

[26] P. Votobel, hhttp://www.hpl.hp.com/personal/Pascal

Vontobel/pseudocodewords/i.

[27] R. L. Townsend and E. J. Weldon, “Self-orthogonal quasi-cyclic codes,”

IEEE Trans. Inform. Theory, vol. IT-13, no. 2, pp. 183–195, April 1967.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 81 version 1.1
[28] S. Lin and D. Costello, Jr., Error Control Coding: Fundamentals and Ap-
plications, ser. Prentice-Hall Series in Computer Applications in Electrical
Engineering. Englewood Cliffs, N. J. 07632f: Prentice-Hall, Inc., 1983.

[29] M. P. C. Fossorier, “Quasi-cyclic low-density parity-check codes from cir-

culant permutation matrices,” IEEE Trans. Inform. Theory, vol. 50, no. 8,
pp. 1788–1793, Aug 2004.

[30] E. F. Assmus, Jr. and H. F. Mattson, Jr., “New 5-designs,” J. Combin.

Theory, vol. 6, pp. 122–151, 1969.

[31] K. Karplus and H. Krit, “A semi-systolic decoder for the PDSC-73 error-
correcting code,” Discrete Applied Math, vol. 33, no. 1–3, pp. 109–128,
November 1991.

[32] J. L. Fan, Constrained Coding and Soft Iterative Decoding, ser. The
Kluwer International Series in Engineering and Computer Science.
Kluwer Academic Publishers, 2001.

[33] R. Lucas, M. P. C. Fossorier, Y. Kou, and S. Lin, “Iterative decoding

of one-step majority logic decodable codes based on belief propagation,”
IEEE Trans. Commun., vol. 48, no. 6, pp. 931–937, June 2000.

[34] Y. Kou, S. Lin, and M. P. C. Fossorier, “Low-density parity-check codes

based on finite geometries: A rediscovery and new results,” IEEE Trans.
Inform. Theory, vol. 47, no. 7, pp. 2711–2736, November 2001.

[35] S. J. Johnson and S. R. Weller, “Resolvable 2-designs for regular low-

density parity-check codes,” IEEE Trans. Commun., vol. 51, no. 9, pp.
1413–1419, September 2003.

[36] B. Vasic, “Structured iteratively decodable codes based on Steiner systems

and their application in magnetic recording,” in Proc. IEEE Globecom
Conf., San Antonio, TX, November 2001, pp. 2954–2960.

[37] S. J. Johnson and S. R. Weller, “Codes for iterative decoding from partial
geometries,” IEEE Trans. Commun., vol. 52, no. 2, pp. 236–243, February
2004.

[38] P. O. Vontobel and R. M. Tanner, “Construction of codes based on fi-

nite generalized quadrangles for iterative decoding,” in Proc. International
Symposium on Information Theory (ISIT’2001), Washington, DC, June
24–29 2001, p. 223.

[39] G. A. Margulis, “Explicit constructions for graphs without short cycles

and low density codes,” Combinatorica, vol. 2, no. 1, pp. 71–78, 1982.

[40] P. Vontobel, “Algebraic Coding for Iterative Decoding,” Ph.D. disserta-

tion, Swiss Federal Institute of Technology, Zurich, 2003.

[41] J. Lafferty and D. Rockmore, “Codes and iterative decoding on algebraic

expander graphs,” in Proc. International Symposium on Information The-
ory and its applications (ISITA2000), Hawaii, USA, November 5–8 2000.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 82 version 1.1
 [42] J. W. Bond, S. Hui, and H. Schmidt, “Constructing low-density parity-
check codes with circulant matrices,” in Proc. IEEE Information Theory
Workshop (ITW1999), Metsovo, Greece, June 27 – July 1 1999, p. 52.

[43] E. F. Assmus, Jr. and J. D. Key, Designs and their Codes, ser. Cambridge
Tracts in Mathematics. Cambridge, U.K.: Cambridge University Press,
1993, vol. 103.

[44] P. J. Cameron and J. H. van Lint, Graphs, Codes and Designs, ser. London
Mathematical Society Lecture Note Series, No. 43. Cambridge: Cam-
bridge University Press, 1980.

[45] I. Anderson, Combinatorial Designs: Construction Methods, ser. Mathe-

matics and its Applications. Chichester: Ellis Horwood, 1990.

Introducing Low-Density Parity-Check Codes, ACoRN Spring School

Sarah Johnson 83 version 1.1

View publication stats