AWGN Channel Analysis of Terminated LDPC Convolutional Codes

Abstract

It has previously been shown that ensembles of terminated protograph-based
low-density parity-check (LDPC) convolutional codes have a typical minimum
distance that grows linearly with block length and that they are capable of
achieving capacity approaching iterative decoding thresholds on the binary
erasure channel (BEC). In this paper, we review a recent result that the
dramatic threshold improvement obtained by terminating LDPC convolutional codes
extends to the additive white Gaussian noise (AWGN) channel. Also, using a
(3,6)-regular protograph-based LDPC convolutional code ensemble as an example,
we perform an asymptotic trapping set analysis of terminated LDPC convolutional
code ensembles. In addition to capacity approaching iterative decoding
thresholds and linearly growing minimum distance, we find that the smallest
non-empty trapping set of a terminated ensemble grows linearly with block
length.

Full text

Page 1

arXiv:1102.3936v1 [cs.IT] 18 Feb 2011
AWGN channel analysis of terminated LDPC
convolutional codes
David G. M. Mitchell∗, Michael Lentmaier†, and Daniel J. Costello, Jr.∗
∗Dept. of Electrical Engineering, University of Notre Dame, Notre Dame, Indiana, USA,
{dcostel1, david.mitchell}@nd.edu
†Vodafone Chair Mobile Communications Systems, Dresden University of Technology, Dresden, Germany,
michael.lentmaier@ifn.et.tu-dresden.de
Abstract—It has previously been shown that ensembles of
terminated protograph-based low-density parity-check (LDPC)
convolutional codes have a typical minimum distance that grows
linearly with block length and that they are capable of achieving
capacity approaching iterative decoding thresholds on the binary
erasure channel (BEC). In this paper, we review a recent
result that the dramatic threshold improvement obtained by
terminating LDPC convolutional codes extends to the additive
white Gaussian noise (AWGN) channel. Also, using a (3,6)-
regular protograph-based LDPC convolutional code ensemble as
an example, we perform an asymptotic trapping set analysis of
terminated LDPC convolutional code ensembles. In addition to
capacity approaching iterative decoding thresholds and linearly
growing minimum distance, we find that the smallest non-empty
trapping set of a terminated ensemble grows linearly with block
length.
I. INTRODUCTION
Ensembles of low-density parity-check (LDPC) block codes
can be obtained by terminating LDPC convolutional code
ensembles [1], [2]. The slight irregularity resulting from the
termination of the convolutional codes has been shown to
lead to substantially better belief propagation (BP) decoding
thresholds compared to corresponding block code ensembles.
More recently, it has been proven analytically for the binary
erasure channel (BEC) that the BP decoding thresholds of
some slightly modified regular LDPC convolutional code
ensembles approach the maximum a posteriori probability
(MAP) decoding thresholds of the corresponding LDPC block
code ensembles [3]. Figure 1 displays the simulated perfor-
mance of terminated (3,6)-regular and (4,8)-regular LDPC
convolutional codes over the additive white Gaussian noise
(AWGN) channel and serves as a demonstration of the capabil-
ities of these codes and as motivation for the results presented
in this paper. Here, the termination length has been chosen
such that the code rate is R = 0.49. We note in particular
that as J increases, the thresholds and corresponding waterfall
performance of the simulated codes improves.
In addition to this excellent threshold performance, it can
also be shown that the minimum distance typical of most
members of these terminated LDPC convolutional code en-
sembles grows linearly with the block length as the block
length tends to infinity, i.e., they are asymptotically good [4]. A
large minimum distance growth rate indicates that codes drawn
from the ensemble should have a low error floor under max-
imum likelihood (ML) decoding. However, when sub-optimal
0 0.51 1.5
10
−5
10
−4
10
−3
10
−2
10
−1
10
0
Eb/N0
Bit Error Rate


(3,6) BC, N=6000
(3,6) BC,
N=200 000
(4,8) CC, L=150,
N=6000
(3,6) CC, L=100, N=6000
Fig. 1: AWGN channel performance of terminated (3,6)-
regular and (4,8)-regular LDPC convolutional codes with lift-
ing factor N = 6000 and rate R = 0.49. For comparion, (3,6)-
regular LDPC block codes with N = 6000 and N = 200000
are also shown.
decoding methods are employed, there are other factors that
affect the performance of a code. For example, it has been
shown that so-called ‘trapping sets’ are a significant factor
affecting decoding failures of LDPC codes over the AWGN
channel with iterative message-passing decoding. Trapping
sets, graphical sub-structures existing in the Tanner graph of
LDPC codes, were first studied in [5]. Known initially as
near-codewords, they were used to analyse the performance
of LDPC codes in the error floor, or high signal-to-noise
ratio (SNR) region, of the bit error rate (BER) curve. In
[6], Richardson developed these concepts and proposed a
two-stage technique to predict the error floor performance of
LDPC codes based on trapping sets, and asymptotic results on
average trapping set distributions for both regular and irregular
LDPC block code ensembles appeared in [7].
In this paper, we perform an AWGN channel analysis of
terminated LDPC convolutional codes. We begin in Section III
by briefly reviewing a recent result that the dramatic threshold
improvement obtained by terminating LDPC convolutional
codes on the BEC also extends to the AWGN channel. This

Page 2

result is demonstrated for a variety of asymptotically good, rate
R = 1/2 (J,2J)-regular LDPC convolutional code ensembles
and for a rate R = 1/2 irregular LDPC convolutional code
ensemble based on the accumulate-repeat-jagged-accumulate
(ARJA) block protograph [8]. In Section IV, using a (3,6)-
regular protograph-based LDPC convolutional code ensemble
as an example, we perform an asymptotic trapping set analysis
of terminated LDPC convolutional code ensembles. Here,
using techniques developed by Abu-Surra, Ryan, and Divsalar
[9], asymptotic methods are used to calculate a lower bound
on the trapping set numbers of terminated (3,6)-regular LDPC
convolutional code ensembles. These trapping set numbers
define the size of the smallest, non-empty trapping sets in
an ensemble. Concluding remarks are given in Section V.
II. CONSTRUCTING PROTOGRAPH-BASED LDPC
CONVOLUTIONAL CODES
A protograph [10] is a small bipartite graph B = (V,C,E)
that connects a set of nvvariable nodes V = {v0,...,vnv−1}
to a set of nccheck nodes C = {c0,...,cnc−1} by a set of
edges E. The protograph can be represented by a parity-check
or base biadjacency matrix B, where Bx,yis taken to be the
number of edges connecting variable node vy to check node
cx. The parity-check matrix H of a protograph-based LDPC
block code can be created by replacing each non-zero entry in
B by a sum of Bx,ypermutation matrices of size N and a zero
entry by the N×N all-zero matrix. In graphical terms, this can
be viewed as taking an N-fold graph cover [11] or “lifting” of
the protograph. It is an important feature of this construction
that each lifted code inherits the degree distribution and graph
neigbourhood structure of the protograph. The ensemble of
protograph-based LDPC codes with block length n = Nnv
is defined by the set of matrices H that can be derived from
a given protograph by all possible combinations of N × N
permutation matrices.
A. Convolutional protographs
An ensemble of unterminated LDPC convolutional codes
can be described by means of a convolutional protograph [1]
with base matrix
...
Bms
···
...
B[−∞,∞]=



...
B0
...
···
...
Bms
B0
...



,
(1)
where ms denotes the syndrome former memory of the
convolutional codes and the bc×bvcomponent base matrices
Bi, i = 0,...,ms, represent the edge connections from
the bv variable nodes at time t to the bc check nodes at
time t + i. Starting from the base matrix B of a block
code ensemble, one can construct LDPC convolutional code
ensembles that maintain the same degree distribution and
structure as the original ensemble. This is achieved by an
edge spreading procedure (see [1] for details) that divides the
edges from each variable node in the base matrix B among
ms+ 1 component base matrices Bi, i = 0,...,ms, such
that the condition B0+ B1+ ··· + Bms= B is satisfied.
This ensures that the computation trees of the convolutional
code ensemble are equal to those of the original block code
ensemble defined by B. An ensemble of (in general) time-
varying LDPC convolutional codes can then be formed from
B[−∞,∞]using the protograph construction method based on
N × N permutation matrices described above.
For example, a (3,6)-regular LDPC convolutional ensemble
with ms= 2 can be formed from the block base matrix B =
[ 3 3 ] by defining the component base matrices
B0=?11?= B1= B2,
(2)
with corresponding convolutional base matrix
B[−∞,∞]=



...
1
...
1
1
...
1
1
1
11
1
1
1
1
...
1
1
1
1
...
11
...



.
B. Terminated LDPC convolutional code ensembles
Suppose that we start the convolutional code with parity-
check matrix defined in (1) at time t = 0 and terminate it
after L time instants. The resulting finite-length base matrix
is then given by
B[0,L−1]=



B0
...
Bms
...
B0
...
Bms
...



(L+ms)bc×Lbv
.
(3)
The matrix B[0,L−1]can be considered as the base matrix
of a terminated protograph-based LDPC convolutional code
ensemble. Termination in this fashion results in a rate loss.
Without puncturing, the design rate RLof the terminated code
ensemble is equal to
RL= 1 −
?L + ms
L
?bc
bv
= 1 −
?L + ms
L
?
(1 − R),
where R = 1 − Nbc/Nbv = 1 − bc/bv is the rate of
the unterminated convolutional code ensemble. Note that, as
the termination factor L increases, the rate increases and
approaches the rate of the unterminated convolutional code
ensemble.
III. ITERATIVE DECODING THRESHOLDS AND MINIMUM
DISTANCE GROWTH RATES OF TERMINATED ENSEMBLES
Terminated LDPC convolutional code ensembles have been
observed to display BP thresholds that approach the MAP
decoding threshold of the corresponding block code ensembles
for the BEC as the termination factor L tends to infinity
[1], [12], and recently this has been proven analytically for
(J,K)-regularensembles [3]. In this section, we review a more

Page 3

−101
Threshold (Eb/N0)
2345
0.05
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0.45
0.5
0.55
Rate


0 0.050.1 0.15
dmin / n
0.20.25 0.3
0.05
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0.45
0.5
0.55


Term. (3,6)−reg.
Term. (4,8)−reg.
Term. (5,10)−reg.
TARJA
(J,K)−regular
ARJA
(3,6)
(5,10)
(4,8)
Increasing termination
factor L
L=2
L=3
L=4
L=5
L=4
Shannon
limit
L=6
Increasing
termination
factor L
Gilbert−Varshamov
bound
L=3
L=4
L=2
L=4
L=5
L=6
(4,8)
(5,10)
(3,6)
Fig. 2: AWGN thresholds and typical minimum distance growth rates for families of terminated (J,2J)-regular LDPC
convolutional code ensembles, terminated ARJA LDPC convolutional code ensembles, and associated LDPC block code
ensembles.
recent result that the dramatic threshold improvement obtained
by terminating LDPC convolutional codes also extends to
the AWGN channel [13], [14]. Since exact density evolution
is far more complex for the AWGN channel than for the
BEC, we make use of the reciprocal channel approximation
(RCA) technique introduced in [15], which has been succes-
fully applied to the analysis of protograph ensembles in [8].
With this approach, the calculation of approximate AWGN
channel thresholds for large protographsbecomes feasible with
reasonable accuracy. Typical minimum distance growth rates
for protograph-based terminated LDPC convolutional code
ensembles can be calculated using the techniques presented
by Divsalar [16].
Figure 2 displays the calculated AWGN thresholds and
minimum distance growth rates for the terminated LDPC
convolutional code ensembles and the corresponding LDPC
block code ensembles. The (J,2J)-regular terminated LDPC
convolutional base matrices are given by (3), where the
bc× bv = 1 × 2 component submatrices Bi = [ 1 1 ],
i = 0,...,ms, and ms= J −1. The terminated convolutional
ARJA (TARJA) component submatrices B0 and B1 of size
bc× bv= 3 × 5 are given as follows:


where we note that


the block base matrix of the ARJA ensemble, and that the
variable node associated with column 2 should be punctured.
B0=
1
0
0
2
1
0
0
1
1
0
1
0
0
0
2

and B1=


0
0
0
0
2
1
0
0
1
0
0
1
0
1
0

,
B0+ B1=
1
0
0
2
3
1
0
1
2
0
1
1
0
1
2

= B,
We see for the terminated convolutional ensembles that, as
L increases, the ensemble design rate increases (approach-
ing R = 1/2 asymptotically) and the thresholds approach
the Shannon limit. However, for increasing L, the asymp-
totic minimum distance growth rates δ(L)
decrease. This presents the code designer with a trade-off
between distance growth rate and threshold, along with a
variety of achieveable code rates RL. We observe that the
(J,2J)-regular block code ensemble thresholds worsen as we
increase J. Figure 2 shows that this is also the case for
the terminated (J,2J)-regular convolutional code families for
small termination factors L. Thus, by increasing J (and hence
decoding complexity), we obtain a more pronounced trade-
off between distance growth rates and threshold for small
values of L. However, as the termination factor L increases,
we observe that the threshold of the terminated (J,2J)-regular
LDPC convolutional code families converge to a value close
to capacity and that this value improves as we increase J. This
indicates that, for large L, both the distance growth rates and
the thresholds improve with increasing complexity. We would
expect this trend to continue as we further increase the variable
node degree J, although the improvement will diminish with
increasing J.
Now consider choosing L such that the ensemble design
rate is R = 0.49. In this region, the threshold values of the
(J,2J)-regular ensembles improve with J. The thresholds of
the terminated (3,6)-regular and (4,8)-regular ensembles are
displayed in Fig. 1, along with the simulated performance of
randomly chosen codes from the associated ensembles with
permutation matrix size N = 6000. A standard LDPC block
decoder employing the BP decoding algorithm is used. We
observe that the waterfall performance is relatively close to
minof the ensembles

Page 4

the threshold and we expect this gap to decrease for larger
permutation matrix sizes N. By choosing L larger, the rate
increases (approaching 1/2) and the thresholds move to the
left. The corresponding waterfall performance of codes chosen
from these ensembles will also move to the left. As a final
observation, we note that for all achieveable rates the TARJA
ensembles have better thresholds than the terminated (3,6)-
regular ensembles. This is expected, since the ARJA ensemble
has been optimised to have a good iterative decoding thresh-
old. However, we also observe that, for large L, the (4,8)-
and (5,10)-regular terminated ensembles have comparable
thresholds to the TARJA ensemble, demonstrating the benefit
that derives from terminating the (J,2J)-regular convolutional
structure.
Figure 3 plots the typical minimum distance growth rates
against the threshold gap to capacity (the difference between
the calculated AWGN channel threshold (Eb/N0) of an en-
semble and capacity for the ensemble design rate) for the
terminated (J,2J)-regular convolutional ensembles with ter-
mination factors L = ms+ 1,...,16,20,50,100, the TARJA
ensembles with termination factors L = 2,...,10, the ARJA
block code ensemble, and the corresponding (J,2J)-regular
block code ensembles.
0 0.02 0.04 0.060.08
dmin / n
0.1 0.120.14 0.160.18
0
0.5
1
1.5
2
2.5
3
3.5
4
Gap to capacity (dB)


Term. (3,6)−regular
Term. (4,8)−regular
Term. (5,10)−regular
TARJA
(J,K)−regular
AR4JA e=0
L=5
L=8
L=2
(3,6)
e=0
(4,8)
(5,10)
L=3
Increasing rate
Increasing termination
factor
L=6
L=7
Fig. 3: Typical minimum distance growth rate vs. threshold
gap to capacity.
We observe that, in particular, intermediate values of L pro-
vide thresholds with a small gap to capacity while maintaining
a small typical minimum distance growth rate with only a
slight loss in code rate. We also note that, for a fixed gap to
capacity close to zero, the largest minimum distance growth
rate is obtained by choosing the terminated (J,2J) ensemble
with the largest J, and that the TARJA ensemble falls in
between the terminated (3,6)- and (4,8)-regular ensembles.
(In this region, with the gap to capacity close to zero, the
rates are approximately equal and close to 1/2.) For larger
fixed gaps to capacity, we see that this ordering changes, and
the reverse ordering holds for large gaps to capacity.
IV. TRAPPING SET ANALYSIS OF TERMINATED LDPC
CONVOLUTIONAL CODE ENSEMBLES
In [5], MacKay and Postol discovered a “weakness” in
the structure of the Margulis construction of a (3,6)-regular
Gallager code. Described as near-codewords, these small
graphical sub-structures existing in the Tanner graph of LDPC
codes cause the iterative decoding algorithm to get trapped in
error patterns. These weaknesses were shown to contribute
significantly to the performance of the code in the error floor
region of the BER curve. Richardson developed this concept
in [6], and defined these structures as trapping sets.
Definition 1: An (a,b) general trapping set τa,bof a bipar-
tite graph is a set of variable nodes of size a which induce
a subgraph with exactly b odd-degree check nodes (and an
arbitrary number of even-degree check nodes).
In order to calculate ensemble average general trapping set
enumerators for terminated LDPC convolutional codes, we use
the combinatorial arguments previously presented in [9]. The
technique involves considering a two-part ensemble average
weight enumerator for a modified protographwith the property
that any (a,b) trapping set in the original protograph is a
codeword in the modified protograph.
A. Trapping set growth rates
The two-part normalized logarithmic asymptotic trapping
set spectral shape function of a code ensemble can be writ-
ten as r(α,β) = limsupn→∞rn(α,β), where rn(α,β) =
ln(Aa,b)
n
, α = a/n, β = b/n, a and b are Hamming weights, n
is the block length, and Aa,bis the two-part ensemble average
weight distribution. Suppose now we are interested in the ratio
of b to a for a general (a,b) trapping set enumerator. Let
∆ = b/a = β/α, ∆ ∈ [0,∞). As proposed in [9], we may
classify the trapping sets as τ∆= {τa,b|b = ∆a}. For each ∆,
we define dts(∆) to be the ∆-trapping set number, which
is the size of the smallest, non-empty trapping set in τ∆.
Now consider fixing ∆ and plotting the normalized weight
α against the two-part asymptotic spectral shape function
r(α,β) = r(α,∆α). Suppose α > 0 and the first zero-
crossing of r(α,β) occurs at α = δts(∆). If r(α,β) is negative
in the range 0 < α < δts(∆), then the first zero-crossing
δts(∆) is called the ∆-trapping set growth rate of the code
ensemble. If δts(∆) exists we can say with high probability
that a randomly chosen code from the ensemble has a ∆-
trapping set number that is at least as large as nδts(∆), i.e., the
∆-trapping set number increases linearly with block length n
[9]. This implies that, for sufficiently large n, a typical member
of the ensemble has no small trapping sets.
B. Trapping set analysis of terminated (3,6)-regular LDPC
convolutional codes
As an example, we will consider the terminated (3,6)-
regular LDPC convolutional code ensemble described in Sec-
tion II-A. For each termination factor L, we analyse the two-
part asymptotic spectral shape function described in Section
IV-A with ∆ ≥ 0 to see if a positive trapping set growth rate

Page 5

δ(L)
sponds to the minimum distance growth rate problem, where α
and β are the weights a and b normalised by the block length
n. Thus, δ(L)
growth rate of the terminated ensemble as reported in [4]. As
∆ ranges from 0 to ∞, the points (δ(L)
out the so-called zero-contour curve for a protograph-based
code ensemble [9]. The zero-contour curves for terminated
(3,6)-regular LDPC convolutional code ensembles are shown
in Fig. 4 for L = 3,...,12.
ts(∆) exists. Note that setting ∆ = β/α = b/a = 0 corre-
ts(0) = δ(L)
min, where δ(L)
minis the minimum distance
ts(∆),∆δ(L)
ts(∆)) trace
0 0.020.04 0.06 0.080.1 0.120.140.16
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5x 10
−3
α = δts
(L)(∆)
β = α∆
gradient = ∆
L = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
L = 3
L = 4
L = 5
Fig. 4: Zero contour curves for terminated (3,6)-regular LDPC
convolutional code ensembles.
For all ∆ ≥ 0, we observe δ(L)
for each class of (a,b) general trapping set, the size of the
smallest non-empty trapping set typical of most members of
the ensemble is growing linearly with block length. Code
ensembles with large ∆-trapping set numbers d(L)
most interesting, since small trapping sets dominate iterative
decoding performance in the error floor [6]. Thus we want
the ∆-trapping set growth rate δ(L)
as large as possible for each value of ∆. We observe in
Fig. 4 that δ(L1)
ts
(∆) ≤ δ(L2)
ts
(∆) for any L1 > L2. This is
analogous to the decrease in the minimum distance growth
rate with increasing L (and rate R) observed in [4]. These
results suggest that for larger values of L, where it becomes
problematic to calculate the trapping set growth rates nu-
merically, we will observe positive zero-contour curves with
δ(L)
the terminated ensemble. This promises, for sufficiently large
block length n, good error-floor performance for terminated
(3,6)-regular LDPC convolutional code ensembles in addition
to the capacity approaching thresholds discussed earlier.
ts(∆) > 0, indicating that,
ts(∆) are the
ts(∆) to exist and to be
ts(0) = δ(L)
min> 0, the minimum distance growth rate of
V. CONCLUSIONS
In this paper we saw that the capacity approaching thresh-
olds of terminated LDPC convolutional codes, recently es-
tablished for the BEC, also extend to the AWGN channel.
In addition, the terminated ensembles display linear mini-
mum distance growth for any finite termination factor L. An
asymptotic trapping set analysis was performed on a family of
terminated (3,6)-regular LDPC convolutional code ensembles
and it was shown that they possess the property that the
smallest non-empty trapping set grows linearly with the block
length. These properties indicate that codes chosen from these
ensembles should have excellent performance in both the
waterfall and the error-floor region of the BER curve.
ACKNOWLEDGEMENTS
The authors would like to thank Maria Mellado Prenda
for providing the simulation curves. This work was partially
supported by NSF Grant CCF08-30650 and NASA Grant
NNX09-AI66G.
REFERENCES
[1] M. Lentmaier, G. P. Fettweis, K. Sh. Zigangirov, and D. J. Costello,
Jr., “Approaching capacity with asymptotically regular LDPC codes,” in
Proc. Information Theory and Applications Workshop, San Diego, CA,
Feb. 2009.
[2] M. Lentmaier, A. Sridharan, D. J. Costello, Jr., and K. Sh. Zigangirov,
“Iterative decoding threshold analysis for LDPC convolutional codes,”
IEEE Trans. Inf. Theory, vol. 56, no. 10, pp. 5274–5289, Oct. 2010.
[3] S. Kudekar, T. Richardson, and R. Urbanke, “Threshold saturation via
spatial coupling: why convolutional LDPC ensembles perform so well
over the BEC,” in Proc. IEEE Int. Symp. on Inf. Theory, Austin, TX,
June 2010.
[4] M. Lentmaier, D. G. M. Mitchell, G. P. Fettweis, and D. J. Costello,
Jr., “Asymptotically regular LDPC codes with linear distance growth
and thresholds close to capacity,” in Proc. Information Theory and
Applications Workshop, San Diego, CA, Feb. 2010.
[5] D. J. C. MacKay and M. S. Postol, “Weaknesses of Margulis and
Ramanujan-Margulis low-density parity-check codes,” Electronic Notes
in Theoretical Computer Science, vol. 74, pp. 97–104, 2003.
[6] T. J. Richardson, “Error-floors of LDPC codes,” in Proc. Forty-first
Annual Allerton Conference, Allerton, IL, Sept. 2003.
[7] O. Milenkovic, E. Soljanin, and P. Whiting, “Asymptotic spectra of
trapping sets in regular and irregular LDPC code ensembles,” IEEE
Trans. Inf. Theory, vol. 53, no. 1, pp. 39–55, Jan. 2007.
[8] D. Divsalar, S. Dolinar, and C. Jones, “Construction of protograph LDPC
codes with linear minimum distance,” in Proc. IEEE Int. Symp. on Inf.
Theory, Seattle, WA, July 2006.
[9] S. Abu-Surra, W. E. Ryan, and D. Divsalar, “Ensemble trapping set
enumerators for protograph-based LDPC codes,” in Proc. Forty-fifth
Annual Allerton Conference, Allerton, IL, Sept. 2007.
[10] J. Thorpe, “Low-density parity-check (LDPC) codes constructed from
protographs,” Jet Propulsion Laboratory, Pasadena, CA, INP Progress
Report 42-154, Aug. 2003.
[11] W. S. Massey, Algebraic Topology: an Introduction.
Springer-Verlag, Graduate Texts in Mathematics, Vol. 56, 1977.
[12] D. G. M. Mitchell, M. Lentmaier, and D. J. Costello, Jr., “New families
of LDPC block codes formed by terminating irregular protograph-based
LDPC convolutional codes,” in Proc. IEEE Int. Symp. on Inf. Theory,
Austin, TX, June 2010.
[13] M. Lentmaier, D. G. M. Mitchell, G. P. Fettweis, and D. J. Costello, Jr.,
“Asymptotically good LDPC convolutional codes with AWGN channel
thresholds close to the Shannon limit,” in Proc. 6th International
Symposium on Turbo Codes and Iterative Information Processing, Brest,
France, Sept. 2010.
[14] S. Kudekar, C. M´ easson, T. Richardson, and R. Urbanke, “Threshold
saturation on BMS channels via spatial coupling,” in Proc. 6th Interna-
tional Symposium on Turbo Codes and Iterative Information Processing,
Brest, France, Sept. 2010.
[15] S. Chung, “On the construction of some capacity-approaching coding
schemes,” Ph.D. dissertation, Massachusetts Institute of Technology,
Cambridge, MA, Sept. 2000.
[16] D. Divsalar, “Ensemble weight enumerators for protograph LDPC
codes,” in Proc. IEEE Int. Symp. on Inf. Theory, Seattle, WA, July 2006.
New York: