Efficient Encoding Algorithm of Binary and
Non-Binary LDPC Codes Using Block
Triangulation
Yuta Iketo and Takayuki Nozaki
Dept. of Informatics, Yamaguchi University, JAPAN
Email: {b001vb,tnozaki}@yamaguchi-u.ac.jp
Abstract—We propose an efficient encoding algorithm for
the binary and non-binary low-density parity-check codes. This
arXiv:2103.01560v1 [cs.IT] 2 Mar 2021
algorithm transforms the parity part of the parity-check matrix
into a block triangular matrix with low weight diagonal sub-
matrices by row and column permutations in the preprocessing
stage. This algorithm determines the parity part of a codeword
by block back-substitution to reduce the encoding complexity
in the encoding stage. Numerical experiments show that this
algorithm has a lower encoding complexity than existing encoding
algorithms. Moreover, we show that this algorithm encodes the
non-binary cycle codes in linear time.
I. I NTRODUCTION
Low-density parity-check (LDPC) codes [1] are defined by
sparse parity-check matrices H ∈ Fm×nq , where Fq stands for
Galois field of order q. The LDPC codes are decoded by the
sum-product decoding algorithm in linear time and come close
to the Shannon capacity on many channels [2]. It is known
that irregular LDPC codes have lower block-error rates than
regular LDPC codes [3], [4].
Let G ∈ Fq
(n−m)×n
be a generator matrix corresponding
to the parity-check matrix H. In general, encoding for linear
codes maps a message u ∈ Fn−m into a codeword x ∈ Fnq
q
by xT = uT G. Even if H is a sparse matrix, G is not
always a sparse matrix. Hence, the complexity of an encoding
algorithm (EA) by a generator matrix is quadratic in the code
length. In other words, an EA by a generator matrix has a
larger complexity than the sum-product decoding algorithm
for long code length. The encoding can be a bottleneck in a
communication system with an LDPC code. Therefore, it is
important to develop a low complexity EA for LDPC codes.
In this paper, we assume that the parity-check matrix H has
full rank, i.e., rank(H) = m. By performing suitable column
permutations into H, we get (HP HI ), where HP is non-
singular. Then the codeword x ∈ Fnq is split into two parts,
namely the parity part p ∈ Fm
q and the message part u ∈
Fqn−m
, as x = (p u). Since HxT = 0T , we get HP pT =
−HI uT .
In general, the encoding for LDPC codes is accomplished in
two stages: the preprocessing stage and the encoding stage. In
the preprocessing stage, we split H into HI corresponding
to u, and HP corresponding to p. In the encoding stage,
we determine p by solving HP pT = −HI uT . Since the
computation of bT := −HI uT is the product of a sparse
matrix and a known vector, the computation complexity is
linear in the code length. Hence, in encoding for LDPC codes,
we should consider (i) an algorithm to construct suitable
HP and (ii) an algorithm to solve HP pT = bT efficiently.
We transform H only by row and column permutations to
keep the sum-product decoding performance. Hence, by using
two permutation matrices P ∈ Fqm×m and Q ∈ Fn×n q , we
transform H into PHQ = (HP HI ).
The existing works of the EA are itemized as follows and
summarized in Table I.
1) Richardson and Urbanke [5] proposed an efficient EA by
transforming HP into an approximate triangular matrix
(ATM). The complexity of this EA is O(n + δ 2 ), where
n is a code length and δ is a gap that satisfies δ  n and
is proportional to n. Hence, the complexity of this EA
is O(n2 ) but is lower than that of the EA by a generator
matrix.
2) Kaji [6] proposed an EA by the LU-factorization. This
EA has lower complexity for codes with small gaps than
Richardson and Urbanke’s EA (RU-EA).
3) Shibuya and Kobayashi [7] proposed an EA by block-
triangulation. This EA is more efficient than the RU-
EA. However, this EA has a possibility of abend [8],
More precisely, there is a possibility that some diagonal
submatrices become vertical, i.e., singular.
4) Nozaki [9] proposed a parallel EA by block-
diagonalization. This EA has a lower encoding time than
the RU-EA by parallel computation. However, this EA
has a slightly larger total computation complexity than
the RU-EA.
5) Huang and Zhu [10] proposed a linear time EA for
non-binary cycle codes, i.e., codes defined by parity-
check matrices of which all the column weights are two.
This EA transforms HP into an upper block-bidiagonal
matrix whose diagonal submatrices are cycle or diagonal
matrices.
The goal of this work is to reduce the encoding complexity
for binary and non-binary irregular LDPC codes. The main
idea of this work is the block triangularization of a given parity
check matrix. In detail, our proposed EA transforms each of
the diagonal submatrices into a cycle or a diagonal matrix as
much as possible. For the non-binary cycle codes, the resulting
 TABLE I
C OMPARISON WITH EXISTING WORKS

Field of code
Work Type of code Technique Note
binary non-binary
Richardson and Urbanke [5] yes yes Irregular Approximate triangulation
Kaji [6] yes yes Irregular LU factorization
Shibuya and Kobayashi [7] yes yes Irregular Block triangulation Possibility of abend
Nozaki [9] yes yes Irregular Block diagonalization Encodable at parallel
Huang and Zhu [10] no yes Cycle Block bidiagonalization Encodable in linear
This work yes yes Irregular Block triangulation

matrix by the proposed EA coincides with one by Huang This preprocessing stage is regarded as an algorithm
and Zhu’s EA (HZ-EA). In other words, the proposed EA whose input is a
matrix H and output is a tuple of matri-
is a generalization of the HZ-EA. Therefore, the complexity ces HRU , P, Q . Therefore,
we denote this algorithm by
of the proposed EA is O(n) for the non-binary cycle codes. ATM(H) → HRU , P, Q [9]. This notation will be used
Numerical experiments show that the proposed EA has lower in Sect. III-B.
complexity than the RU-EA and Kaji’s EA (K-EA). We split the parity part p into (p1 , p2 ), where p1 ∈ Fqm−δ
We organize the rest of the paper as follows. Section II and p2 ∈ Fδq . Then, the encoding stage executes the following
introduces LDPC codes and existing EAs. Section III presents procedure;
the proposed EA. Numerical examples in Sect. IV compare 1) Compute bT1 = HRU T T RU T
I,1 u and b2 = HI,2 u
the complexity of the proposed EA and existing EAs. −1 −1 T
2) Derive p2 from p2 = Φ (VT b1 − bT2 )
T

3) Solve TpT1 = −SpT2 − bT1 by backward-substitution

II. P RELIMINARIES
Consider the matrix Z over Fq . Denote the number of non-
This section introduces LDPC codes and existing EAs. zero elements in the matrix Z by wt(Z). Let Z(Z) be the
number of rows that include at least one non-zero element in
A. LDPC Codes
Z. Define S(Z) := wt(Z) − Z(Z). Then, wt(Z) (resp. S(Z))
LDPC codes are defined by sparse parity-check
matrices gives the number of multiplication (resp. addition) over Fq to
H ∈ Fm×n q as C q = x ∈ Fn
q | Hx T
= 0 T
. In particular, C2 calculate the product of the matrix Z and a vector. By using
is a binary LDPC code. When q > 2, we call Cq non-binary this, the total number of multiplications µRU and additions
LDPC code. αRU in the encoding stage of the RU-EA are
Each parity-check matrix H is represented as the Tanner
µRU = wt HRU + fm (A), αRU = S HRU



graph [11], [12]. The rows (resp. columns) of H correspond I I + fa (A),
to the check (resp. variable) nodes. In the Tanner graphs of −1


fm (A) := 2wt(T) + wt(V) + wt(S) + wt Φ , (1)
(dc , dr )-regular LDPC codes, all the variable (resp. check) −1


fa (A) := 2S(T) + S(V) + S(S) + S Φ + m. (2)
nodes are of degree dc (resp. dr ). On the other hand, an
irregular LDPC code is chosen the degrees of nodes accord- Note that fm (A) and fa (A) represent the number of multi-
ing to two-degree distributions: the check degree distribu- plication and addition to solve Ap = b, respectively.
i−1
P
tion ρ(x) = ρ
i i x and the variable degree distribution
i−1
P
λ(x) = i λi x , where ρi (resp. λi ) is the fraction of edges
C. Kaji’s Encoding Algorithm [6]
connecting to check (resp. variable) nodes of degree i.
In particular, LDPC codes satisfying λ(x) = x are known The preprocessing stage of the K-EA transforms a given H
as cycle codes [13]. Note that there are no restrictions to the into an ATM HRU . Next, this stage factorizes A = LU, where
check degree distribution for the cycle codes. L and U are lower and upper triangular matrices, respectively.
This encoding stage is accomplished in three steps:
B. Richardson and Urbanke’s Encoding Algorithm [5] 1) Compute bT = −HRU T
I u
T T
The preprocessing stage transforms a given H into an ATM 2) Solve Lv = b by forward-substitution.
HRU , described as 3) Solve UpT = bT by backward-substitution.

T S HRU
 
HRU
 The complexity, i.e., the number of multiplications µK and
HRU = PHQ = I,1
= A I,1
, additions αK , is evaluated as
V N HRU I,2 HRU
I,2

µK = wt HRU


where T is an (m − δ) × (m − δ) triangular matrix, S, V, I + wt(L) + wt(U),
N, HRU RU
I,1 , and HI,2 are δ × (m − δ), (m − δ) × δ, δ × δ,
RU


αK = S HI + S(L) + S(U).
(m − δ) × (n − m), and δ × (n − m) matrices, respectively.
We define Φ := N − VT−1 S. We compute its inverse matrix It is known that the K-EA has lower complexity than the RU-
Φ−1 before the encoding stage. EA for the codes with small gaps [6].
D. Singly Bordered Block-Diagonalization TABLE II
A LGORITHM TO SOLVE Cω T = bT
By the singly bordered block-diagonalization [14], a given
H is transformed into HSBBD : Operation µ α
  z1 ← b1 0 0
SBBD B1 O Z1 zi ← bi + i−1 zi−1 (i = 2, ..., k) k−1 k−1
H = PHQ = , yk ← zk ι−1
O B2 Z2 1 0
ωk ← γk−1 yk 1 0
where B1 , B2 , Z1 , and Z2 are m1 × n1 , (m − m1 ) × n2 , ωi ← γi−1 (zi − yk ηi ) (i = 1, ..., k − 1) 2k − 2 k−1
m1 × (n − n1 − n2 ), and (m − m1 ) × (n − n1 − n2 ) matrices,
respectively. In the singly bordered block-diagonalization, we
can predetermine the numbers of rows m1 , m2 . However, the 2) Solving Algorithm Cω T = bT and Its Complexity: We
numbers of columns n1 , n2 depend on the input matrix H. present an algorithm to solve Cω T = bT , where b ∈ Fkq is
Hence, if m1 is small, the submatrix B1 becomes vertical, known. Note that this algorithm has a smaller complexity than
i.e., m1 > n1 . Thus, to get a square or horizontal submatrix the algorithm in [10], which requires 4k − 3 multiplications
B1 , we need to adjust the size of m1 . and 3k − 5 additions (k ≥ 3).
The singly bordered block-diagonalization is regarded as To reduce the complexity, predetermine
an algorithm whose inputs are a matrix
H and m1 and output
is a tuple of matrices HSBBD , P, Q . Therefore,
we denote i := βi γi−1 (i = 1, 2, . . . , k), ι := 1 + 1 2 · · · k ,
this algorithm by SBBD(H, m1 ) → HSBBD , P, Q [9]. This ηi := k 1 2 · · · i−1 (i = 1, 2, . . . , k − 1).
notation will be used in Sect. III-B.
We denote substituting j into i by i ← j. Table II shows
E. Huang and Zhu’s Encoding Algorithm the algorithm to solve Cω T = bT . The total number of
multiplications µc and additions αc are
This section shows the HZ-EA [10] and complexity to solve
the equation with a cycle matrix. µc = 3k − 1, αc = 2(k − 1). (3)
1) Preprocessing Stage of HZ-EA: The associated graph
[10] gives a graph representation of a matrix, each of whose III. P ROPOSED E NCODING A LGORITHM
columns of weight two. An m × n matrix is described by an In this section, we propose an EA by block triangularization.
associated graph of m vertices and n edges. The vertices vi Section III-A gives an overview of the proposed EA. Sections
and vj are connected by the edge ek iff the (i, k)-entry and III-B and III-C present the preprocessing and encoding stages
the (j, k)-entry of the matrix are non-zero. of this EA, respectively. Section III-D evaluates the encoding
The cycle matrix1 C ∈ Fk×kq has the following form: complexity. Section III-E shows that this EA is a generaliza-
  tion of the HZ-EA.
γ 1 0 0 · · · βk
 β1 γ 2 0 · · · 0  A. Overview
 
C =  0 β2 γ 3 · · · 0  , The preprocessing stage of the proposed EA transforms a
 
 .. . . . . .. .. 
 . . . . .  given parity check matrix H into a block-triangular matrix H0
0 ··· 0 βk−1 γk by row and column permutations, where
F1 K1,2 · · · K1,`−1 K1,` H0I,1
 
where βi and γi is a non-zero element over Fq .
O F2 · · · K2,`−1 K2,` H0I,2 
Remark 1. Consider a k × k cycle matrix C over F2 . Then,
 
H0 =  ... .. .. .. .. ..  . (4)

the rank of C is k − 1. In other words, all cycle matrices over  . . . . . 

0
F2 are always singular.
O O · · · F`−1 K`−1,` HI,`−1 
O O ··· O F` H0I,`
The preprocessing stage of the HZ-EA [10] transforms H
into HHZ : Here, Fi is a non-singular mi × mi matrix, Ki,j and H0I,i are
  of size mi × mj and mi × (n − m), respectively. Note that
C1 E1 P`
 .. O  i=1 mi = m. To reduce the encoding complexity, diagonal
D2 . block Fi forms a diagonal matrix as far as possible.
HHZ = 
 
HHZ ,
 .. I  Suppose that the parity part p is split into ` parts pi ∈ Fm q
i
. Er−1
O
 
(i = 1, 2, . . . , `) as p = (p1 , p2 , . . . , p` ). Then, the encoding
Dr stage decides the parity part by solving H0P p = −H0I u for
where C1 is an m1 × m1 cycle matrix, Di is an mi × mi a given u. This equation is efficiently solved by the block
diagonal matrix (i = 2, 3, . . . , r), and Ei is mi × mi+1 matrix backward-substitution (Sect. III-C).
and HHZ
(i = 1, 2, . . . , r − 1), P I is m × (n − m) matrix, In the following sections, we explain block backward-
r substitution can reduce the encoding complexity by an ex-
respectively. Note that i=1 mi = m.
ample (Sect. III-A1) and briefly explain how to construct a
1 Since its associated graph is cycle, we call it cycle matrix. block-triangular matrix (Sect. III-A2 and III-A3).
 1) Reason to Make Block Triangular Matrix : Assume HP wt(D) + wt(K) multiplications by the block backward-
is decomposed in the following block matrix substitution.
  Summarizing above, if we obtain a block-triangular matrix
D K Su
whose several diagonal-blocks are diagonal matrices, we can
HP = O T Sl  ,
reduce the encoding complexity. In the following section, we
O V N
briefly explain how to make such a matrix.
where D is an m1 × m1 diagonal matrix, T is an (m2 − δ) × 2) Extraction of Diagonal Matrices : Consider the case
(m2 −δ) triangular
 matrix, and N is a δ × δ matrix. Since that H does not contain columns of weight 1. By a method
D K explained in Sect. III-A3, we extract a non-singular matrix F1
T1 = is a triangular matrix, HP is regarded as a
O T from H and get
large ATM, i.e.,  
F1 M1
H1 = ,
 
D K Su  
O W1
 O T Sl  = T1 S ,
V1 N by performing row and column permutation to H.
O V N
  Since M1 6= O in general, there is a possibility that W1
Su

contains columns of weight 1. In such case, by rearranging
where =: S and O V =: V1 . In another interpreta-
Sl   the rows and columns of H1 , we extract diagonal matrix D2
T Sl from W1 as
tion, since A2 = is a small ATM, HP is regarded
V N  
as a block triangular matrix, i.e., F1 K1,1 M1
  H2 =  O D2 M2  .
D K Su  
O O W2
 O T Sl  = D K2 ,
O A2 If W1 does not contain columns of weight 1, we extract a
O V N

non-singular matrix F2 from W2 by a similar way to F1 :
where K Su =: K2 .  
Now, we compare the complexity to solve HP pT = bT F1 K1,1 M1
in the two interpretations above. To simplify the discussion, H02 =  O F2 M2  .
we evaluate the complexity by the number of multiplications. O O W2
If we regard HP as a large ATM, then the number of By repeating the above process, finally we obtain the block-
multiplications µ1 to solve HP pT = bT is derived from triangular matrix.
Eq. (1) as When H contains columns of weight 1, firstly we extract
µ1 = 2(wt(D) + wt(K) + wt(T)) + wt(V) a diagonal matrix D1 and repeat the same process. Then we
get a block-triangular matrix.
+ wt(Su ) + wt(Sl ) + wt Φ−1


1 , (5)
3) Extraction of Non-Singular Diagonal Blocks : Consider
where Φ1 := N − V1 T−1 1 S.
the case that matrix W does not contain columns of weight
If we regard HP as a block-triangular matrix, then we split 1. If we choose appropriate m1 , singly bordered block-
p into p1 ∈ Fm q
1
and p2 ∈ Fm q
2
and obtain the following diagonalization (Sect. II-D) to W gives
system of linear equations: 
B1 O Z1

0
W = PWQ = ,
A2 pT2 = bT2 , (6) O B2 Z2
DpT1 = bT1 − K2 pT2 , (7) where B1 is m1 × n1 full-rank horizontal submatrix. Since
rank(B1 ) = m1 , we extract a non-singular m1 × m1 matrix
where b1 (resp. b2 ) stands the first m1 (resp. last m2 ) elements
F1 by rearranging the rows of B1 as follows:
of vector b. We solve Eq. (6) by the RU-EA’s encoding stage    
and get p2 . Substituting p2 into Eq. (7), we have p1 . This 0 0 F1 R 1 O Z 1 F1 M1
WQ = = .
calculation is called block backward-substitution. The total O O B2 Z2 O W1
number of multiplications µ2 to derive p2 and p1 is
Summarizing above, singly bordered block-diagonalization
µ2 = 2wt(T) + wt(V) + wt(Sl ) + wt Φ1−2


allows us to extract a non-singular matrix for binary and non-
+ wt(K) + wt(Su ) + wt(D), (8) binary codes.
In the case of non-binary codes, we can also extract a non-
−1
where Φ2 := N − VT Sl . singular matrix by cycle detection in the associate graph. For
By subtracting Eq. (8) from Eq. (5), we get a given matrix W, construct a submatrix C e which consists
of all the columns of weight 2 in W. We detect one of the
µ1 − µ2 = wt(D) + wt(K) + wt(Φ−1 −1
1 ) − wt(Φ2 ).
smallest cycles (e.g., see [15]) in the associated graph for C.
e
Since both Φ1 and Φ2 are δ × δ matrices, we assume Since cycles in an associated graph correspond to the cycle
wt(Φ−1 −1
1 ) ≈ wt(Φ2 ). From this, we can reduce about matrices, we get the following matrix by moving the rows and
 Step 1

Step 2
yes

no
yes
no
Fig. 1. A matrix H(3)

yes
columns corresponding to the smallest cycle in the associated no
graph:
 
C1 M1
,
O W1

where C1 is a cycle matrix. Hence, we can extract a cycle, i.e.,

yes
non-singular, matrix by cycle detection in the associate graph. no
Note that this method cannot extract a non-singular matrix for
the binary code by the reason in Remark 1.
no
B. Preprocessing Stage of Proposed EA yes

Now, we explain the details of the preprocessing stage of the

proposed EA. This stage is realized by an iterative algorithm. Step 3
Let t stand for the round of this iterative algorithm. Let H(t) be no
the parity-check matrix at the t-th round. This stage performs yes
row and column permutations to H(t) at each round. This stage
determines H0 given in Eq. (4) from front columns and rear
columns at each round. We denote the number of determined
front columns and rear columns at round t, by ft and gt ,
respectively. Fig. 2. Flowchart of preprocessing stage of proposed EA
As an example, Figure 1 depicts H(3) . The pink blocks of
Fig. 1 express determined submatrices. We refer to the blue
P1 for moving these non-zero entries to the upper-left of
block of Fig. 1, i.e., W(t) , as working space.
W(t) . As a result, this stage gets
Figure 2 shows the flowchart of the preprocessing stage.
e t+1 M(t+1)
 
This stage is divided into three steps: initialization (Step 1), (t) D t+1
P1 W Q1 = , (9)
iteration (Step 2), and end process (Step 3). In Step 2, perform O W(t+1)
row and column permutations to H(t) at round t. Roughly
speaking, Step 2 forms the diagonal block Ft+1 at round t. where all the columns of De t+1 ∈ Fqmt+1 ×dt are weight 1.
Condition (A) gives a decision whether we can make Ft+1 a Next, to extract an mt+1 × mt+1 diagonal matrix from
diagonal matrix. Condition (E) and (B) decide whether we can De t+1 , move mt+1 columns forming a diagonal matrix to the
make Ft+1 a cycle matrix. Unless Ft+1 becomes a diagonal front of W(t) and move the residual (dt − mt+1 ) columns to
or a cycle matrix, we form Ft+1 into a small ATM. To make a the rear of W(t) by Q2 , i.e.,
small ATM, we adjust mt+1 , which decides the size of Ft+1 .  (t+1)

Dt+1 Mt+1 Rt+1,t+1
If Ft+1 cannot become a small ATM, i.e., Condition (D) is P1 W(t) Q1 Q2 = , (10)
satisfied, we make a large ATM in Sub-step (d). In Step 3, O W(t+1) O
this stage outputs the result if this stage satisfies Condition where Dt+1 is an mt+1 ×mt+1 diagonal matrix and Rt+1,t+1
(F), i.e., ft = m. Otherwise, return to Step 2. The details of is an mt+1 ×(dt −mt+1 ) matrix. Then, set ft+1 ← ft +mt+1 ,
Sub-steps (a)-(e) are as follows. gt+1 ← gt + (dt − mt+1 ), P(t) = P1 , and Q(t) = Q1 Q2 .
a) Sub-step (a): This sub-step forms a diagonal matrix b) Sub-step (b): This sub-step extracts one of the small-
at the upper-left of W(t) . We write dt for the number of the est cycle matrices at the upper-left of W(t) . First, this stage
columns of weight 1 in W(t) . This stage performs the column detects one of the smallest cycle matrices in W(t) . Let ct be
permutation Q1 into W(t) for moving dt columns of weight the number of the columns of weight 2 in W(t) . Denote the
1 to the front of W(t) . This stage applies the row permutation (m − ft ) × ct submatrix which consists of all the columns of
 sample

weight 2, by Ce t+1 . This stage detects the smallest cycle (e.g.,

see [15]) in the associated graph for C e t+1 .
(i)
Next, this stage forms the cycle matrix at the upper-left of
W(t) by moving the rows and columns corresponding to the
smallest cycle in the associated graph: sample

(t+1)
 
Ct+1 Mt+1
P(t) W(t) Q(t) = , (11) (ii)
O W(t+1)
where Ct+1 is the mt+1 × mt+1 cycle matrix. Set ft+1 ←
ft + mt+1 and gt+1 ← gt .
sample

c) Sub-step (c): The purpose of this sub-step is to form a

small ATM at the upper-left of W(t) . Let nt+1 be the number (iii)
of columns of B1 . Execute ATM(B1 ) → (At+1 , P4 , Q4 ) and
f (t) as
get W sample

   
(t) P4 O (t) Q4 O
W =
f W
c
O Im−ft −mt+1 O In−ft −gt −nt+1 (iv)
 
At+1 Rt+1,t+1 O Z
e1
= , (12)
O O B2 Z2 sample

where At+1 is an mt+1 × mt+1 ATM, Ik represents the k × k

identity matrix, and Ze 1 := P4 Z1 . This stage moves Rt+1,t+1 (v)
to the rear of the matrix by a suitable column permutation Q5 :
  sample

f (t) Q5 = At+1 O Z1 Rt+1,t+1

e
W
O B2 Z2 O
 (t+1)
 (vi)
At+1 Mt+1 Rt+1,t+1
= . (13)
O W(t+1) O
sample

Set ft+1 ← ft + mt+1 , gt+1 ← gt + (nt+1 − mt+1 ) and

 
(t) P4 O (vii)
P := P3 ,
O Im−ft+1
 
(t) Q4 O
Q := Q3 Q5 .
O In−ft −gt −nt+1 Fig. 3. Demonstration of preprocessing stage


d) Sub-step
(d): Execute ATM W(t) →
At+1 , P(t) , Q(t) and get Example 1. This example demonstrates this preprocessing
P(t) W(t) Q(t) = At+1 Rt+1,t+1 ,

stage. The left figure of Fig. 3-(i) represents the input matrix.
In the left figures, the black dots stand non-zero elements and
where At+1 is the mt+1 × mt+1 ATM. Set ft+1 ← ft + mt+1 the white parts express zero elements. Sub-blocks separated
and gt+1 ← gt . by red lines in the left figures correspond to submatrices in
e) Sub-step (e): Perform the right matrices.
 

Ift O O
 We input a parity-check matrix H ∈ F50×100
8 as Fig. 3-(i).
I O This matrix contains 33 columns of weight 2, 67 columns of
H(t+1) ← ft H(t)  O Q(t) O  .
O P(t) weight 5, 49 rows of weight 8, and a row of weight 9. In Step
O O I gt
1, set t ← 0, f0 ← 0, g0 ← 0, H(0) ← H, and W(0) ← H.
(t)
By the permutation Q(t) , the
 matrix Mi for 1 ≤ i ≤ t is Note that Condition (E) of Step 2 is always unsatisfied since
(t) (t)
transformed as Mi Q = Ki,t+1 Mi
(t+1)
Ri,t+1 , where q = 8.
(t+1) (t = 0) In Step 2, Condition (A) is not satisfied since
Ki,t+1 , Mi and Ri,t+1 are of size mi × mt+1 , mi × (n − W(0) = H does not contain a column of weight 1. Hence,
ft+1 − gt+1 ) and mi × (gt+1 − gt ), respectively. go to the decision of Condition (B). Condition (B) is satisfied
Remark 2. In Sub-steps (c) and (d), we can use any pre- because W(0) contains a cycle matrix. Hence, execute Sub-
processing stage of EAs for binary and non-binary irregular step (b).
LDPC codes (e.g., [6]). If we use the K-EA [6], for ATMs In the execution of Sub-step (b), search one of the smallest
with small gaps, we can reduce the complexity of proposed cycle matrices in W(0) . The smallest cycle matrix is of size
EA as shown in Sect. IV. 4 × 4. By Eq. (11), transform Fig. 3-(i) into Fig. 3-(ii). Set
f1 ← 4 and g1 ← 0. Go to Step 3. D. Complexity of Proposed EA
In Step 3, increase t ← 1. Condition (F) is not satisfied By summarizing Eqs. (1), (2), and (3), the number of
since f1 = 4 6= 50. Hence, return to Step 2. multiplications µi and additions αi to solve Fi pTi = bTi are
(t = 1) In Step 2, Conditions (A) and (B) are not satisfied 
because W(1) does not contain a column of weight 1 and a (mi , 0),
 (Fi : diag),
cycle matrix. Next, this stage increases m2 until submatrix B1 , (µi , αi ) = (3mi − 1, 2mi − 2), (Fi : cycle),


obtained by SBBD W(1) , m2 → W c (1) , becomes full rank. (fm (Fi ), fa (Fi )), (Fi : ATM).

In this example, we get
full rank submatrix B1 by executing
SBBD W(1) , m2 = 37 → W c (1) . By this execution, the This notation gives the total number of multiplications µ0 and
parity-check matrix is transformed as Fig. 3-(iii). Hence, go additions α0 for the encoding stage of the proposed EA:
to Sub-step (c). ` n
X 
o
Transform Fig. 3-(iii) into Fig. 3-(iv) by Eq. (12), where µ0 = µi + wt Ki,i+1 Ki,i+2 · · · Ki,` H0I,i ,
 
0 Q4 O i=1
Q4 = . Then, Fig. 3-(iv) is transformed into ` n
O I53 X 
o
Fig. 3-(v) by Eq. (13). Set f2 ← 41 and g2 ← 6. Go to α0 = αi + S Ki,i+1 Ki,i+2 · · · Ki,` H0I,i .
Step 3. i=1

In Step 3, increase t ← 2. Condition (F) is not satisfied E. Property of Proposed EA

since f2 = 41 6= 50. Hence, return to Step 2. In this section, we prove that the proposed EA is a
(t = 2) In Step 2, because Condition (A) is satisfied, Sub- generalization of the HZ-EA. When the associated graph is
step (a) is executed. Transforms Fig. 3-(v) into Fig. 3-(vi) by a connected graph, we say the cycle code is proper. The
Eq. (9). Moreover, transform Fig. 3-(vi) into Fig. 3-(vii) by following theorem shows that if the input of preprocessing
Eq. (10). Set f3 ← 50 and g3 ← 13. Go to Step 3. stage is proper cycle code, the output matrix satisfies the same
In Step 3, increase t ← 3. Condition (F) is satisfied since properties of the HZ-EA.
f3 = 50 = m. Output m1 = 4, m2 = 37, m3 = 9 and the Theorem 1. If the input matrix H is a non-binary parity-check
matrix given in Fig. 3-(vii). Here, the parity part H0P and matrix for a proper cycle code, the preprocessing stage of the
message part H0I of the output matrix are proposed EA outputs H0 satisfying (i) F1 = C1 , (ii) Fi = Di
  (2 ≤ i ≤ `), (iii) Ki−1,i 6= O (2 ≤ i ≤ `), and (iv) Kj,i = O
(3)
C1 K1,2 K1,3
!
M1 R1,3 K1,2 (2 ≤ i ≤ `, 1 ≤ j ≤ i − 2).
H0P = O A2 K2,3 , H0I = M(3) R2,3 K2,2  .
O O D3
2
(3) Proof. First, we will show F1 = C1 . Note that W(0) = H.
M3 R3,3 O
Hence, in Step 2, Condition (A) is not satisfied since H is
the parity check matrix of the cycle code. Since H is non-
C. Encoding Stage of Proposed EA binary, Condition (E) is not satisfied. Consider the associate
graph of W(0) . Note that the associate graph consists of m
Recall that the preprocessing stage outputs the number nodes and n edges. Since n > m, the associate graph includes
of rows of submatrices m1 , m2 , . . . , m`−1 , m` . According to at least one cycle. This leads that Condition (B) is satisfied.
these values, we split the parity part p of the codeword into Hence, Sub-step (b) is executed. Then, H(1) is transformed
` parts pi ∈ Fm q
i
(i = 1, 2, . . . , `). Then, the codeword is as follows:
expressed as (p1 p2 ... p` u). Combining Eq. (4) and H0 xT =  (1)

(1) (0) (0) (0) C1 M1
0T , we get the following system of linear equations: H =P H Q = .
O W(1)
P` This equation leads F1 = C1 .
F1 pT1 = bT1 := −H0I,1 uT −


K1,j pTj , (14)
j=2
P` Hypothesize W(1) does not contain a column of weight 1.
F2 pT2 = bT2 := −H0I,2 uT −


j=3 K2,j pTj , (15) Then, each column has weight 0 or 2. If the i-th column of
(1)
.. W(1) has weight 0 (resp. 2), the i-th column of M1 has
. weight 2 (resp. 0). This leads that the associate graph of H
F`−1 pT`−1 = bT`−1 := −H0I,`−1 uT − K`−1,` pT` , (16) is disconnected. This contradicts the input parity-check matrix
F` pT` = bT` := −H0I,` uT . (17) is for a proper cycle code. Hence, W(1) contains at least one
column of weight 1.
Since W(1) contains a column of weight 1, Sub-step (a)
Firstly, we solve Eq. (17) by efficient algorithm to solve and (e) is executed. The resulting matrix H(2) is
F` pT` = bT` . Next, substituting p` into Eq. (16), we solve  
(2)
Eq. (16), i.e., F`−1 pT`−1 = bT`−1 . Similarly, we solve Fi pTi = C1 K1,2 M1 R1,2
bTi for ` − 2, ` − 3, . . . , 1. Finally, we get the parity part H(2) =  O (2)
R2,2  .
 
D2 M2
p = (p1 , p2 , . . . p` ). O O W(2) O
From the procedure of Sub-step (a), all the columns of K1,2
(2)
have weight 1. Moreover, the columns of M1 have weight
0 or 2. Hence, K1,2 6= 0.
Similar to the above, W(2) contains at least one column of
weight 1. Hence, Sub-step (a) is executed, and the resulting
matrix H(3) is
 (3)
 Hence, we plot 100 dots for each code length.
C1 K1,2 K1,3 M1 R1,3 R1,2
(3)
O D2 K2,3 M2 R2,3 R2,2 
 
H(3) =  .
O (3)
O D3 M3 R3,3 O 
O O O W(3) O O
From the procedure of Sub-step (a), submatrix

(3)
 K-EA for every code in E8 . Figure 5(c) shows the proposed
K1,3 M1 R1,3 is obtained from a column permutation
(2) (3)
to M1 . Hence, all the columns of K1,3 , M1 , P1,3 have
weight 0 or 2. Since all the columns of D3 have weight 1,
all the columns of K1,3 have weight 0 and all the columns
of K2,3 have weight 1. Hence, K1,3 = O and K2,3 6= O.
Moreover, from the procedure of Sub-step (a), the columns
(3)
of M2 have weight 0 or 2.
In a similar matter, we can show that for i = 4, 5, . . . , `:
(ii) Fi = Di , (iii) Ki−1,i 6= O, and (iv) Kj,i = O (j =
1, 2, . . . , i − 2).
IV. N UMERICAL E XPERIMENTS
This section compares the proposed EA, the RU-EA [5], the
K-EA [6] for the number of additions α and multiplications
µ by numerical experiments.
A. Comparison with Existing EAs
As a non-binary case, we consider the irregular LDPC code
ensemble E8 over F8 with the degree distributions [3]:
λ(x) = 0.49978x+0.17434x2 +0.29967x3 +0.02622x4 ,
ρ(x) = 0.81315x4 +0.18685x5 .
For a binary case, we consider the irregular LDPC code
ensemble E2 defined by the degree distributions [4]:
λ(x) = 0.0739196x + 0.657891x2 + 0.268189x12 ,
ρ(x) = 0.390753x4 + 0.361589x5 + 0.247658x9 .
Table III evaluates the average number of additions and
multiplications by the RU-EA, the K-EA, and the proposed
EA for the ensemble E8 and E2 with code length n =
1000, 2000, . . . , 5000. For each experiment, we generate 100
parity-check matrices from ensemble E8 and E2 . Note that we
regard the number of multiplications of those algorithms is
0 for the binary case. Table III shows that the proposed EA
has the smallest complexity for the non-binary case. In this
case, we can reduce the number of multiplications especially.
Table III shows the proposed EA has the smallest complexity
for binary code with n ≥ 2000. In particular, we can reduce
the encoding complexity for the binary codes with long code
length.
To compare the number of operations for individual codes,
we plot Figs 4 and 5. In those figures, the horizontal (resp.
vertical) axis represents the number of operations for the
existing EA, i.e., RU-EA or K-EA (resp. proposed EA). For
example, Fig. 5(c) compares the number of additions by the
K-EA and the proposed EA for 100 codes in E2 . In this figure,
we plot a dot at (x, y) if the K-EA requires x additions and
the proposed EA requires y additions for a fixed code in E2 .
Figures 4(a), 4(b), and 4(c) show that the proposed EA
requires lower operations than the RU-EA for every code.
From Fig. 5(a), the proposed EA and K-EA require about
the same number of additions for the codes in E8 . Figure 5(b)
shows the proposed EA requires lower multiplications than the
EA has lower complexity than the K-EA for the long binary
codes.
B. Modification of Proposed EA for Short Code Length
As shown in the previous section, the proposed EA has
a larger complexity than the K-EA for short binary LDPC
codes. As mentioned in Remark 2, we can use another efficient
algorithm to solve Ai pTi = bT . In this section, we modify the
proposed EA by the LU-factorization to reduce the complexity
of the proposed EA for short binary LDPC codes.
We evaluate the number of additions required in the mod-
ified algorithm for 100 codes in E2 with n = 1000. Those
results are plotted in Fig. 6. The average number of additions
required in the modified EA is 3087.57. On the other hand, the
average number of additions required in the K-EA is 3195.16
from Table III. From the above, the modified EA can reduce
the complexity and have lower average complexity than the
K-EA.
V. C ONCLUSION
In this paper, we have proposed an efficient EA for the
binary and non-binary irregular LDPC codes. As a result, the
proposed EA has lower complexity than the RU-EA and the
K-EA.
ACKNOWLEDGMENT
We would like to thank Dr. Yuichi Kaji (Nagoya University)
for providing the program of Kaji’s EA. This research was
supported by JSPS KAKENHI Grant Number 16K16007 and
Yamaguchi University Fund.
R EFERENCES
[1] R. Gallager, “Low-density parity-check codes,” IRE Transactions on
information theory, vol. 8, no. 1, pp. 21–28, 1962.
[2] T. J. Richardson, M. A. Shokrollahi, and R. L. Urbanke, “Design of
capacity-approaching irregular low-density parity-check codes,” IEEE
Trans. Inf. Theory, vol. 47, no. 2, pp. 619–637, 2001.
[3] X.-Y. Hu, E. Eleftheriou, and D.-M. Arnold, “Regular and irregular
progressive edge-growth Tanner graphs,” IEEE Trans. Inf. Theory,
vol. 51, no. 1, pp. 386–398, 2005.
[4] A. Amraoui, “Asymptotic and finite-length optimization of LDPC
codes,” Ph.D. dissertation, Swiss Federal Institute of Technology in
Lausanne, 2006.
[5] T. J. Richardson and R. L. Urbanke, “Efficient encoding of low-density
parity-check codes,” IEEE Trans. Inf. Theory, vol. 47, no. 2, pp. 638–
656, 2001.
 TABLE III
AVERAGE ENCODING COMPLEXITY FOR E8 AND E2

Complexity for E8 Complexity for E2

n αRU /µRU (RU) αK /µK (Kaji) α0 /µ0 (Proposed) αRU (RU) αK (Kaji) α0 (Proposed)
1000 2614.82/3613.71 1613.17/3110.06 1576.55/2577.55 4054.16 3195.16 3254.76
2000 5234.19/7229.83 3207.56/6201.20 3151.48/5152.48 8217.58 7216.17 6670.03
3000 7853.93/10846.39 4797.21/9287.67 4726.37/7727.37 12413.73 12157.26 10190.95
4000 10472.86/14463.01 6382.11/12370.26 6301.37/10302.37 16642.75 17592.54 13795.31
5000 13095.01/18081.69 7968.67/15453.35 7876.35/12877.35 20892.28 24118.86 17473.06

Number of multiplications (Proposed)

n=1000 n=1000 n=1000
Number of additions (Proposed)

Number of additions (Proposed)

n=2000 n=2000 n=2000
15000 n=3000 15000 n=3000 n=3000
n=4000 n=4000 n=4000
n=5000 n=5000 20000 n=5000
y=x y=x y=x
10000 10000

10000
5000 5000

0 0 0
0 5000 10000 15000 0 5000 10000 15000 0 10000 20000
Number of additions (RU) Number of multiplications (RU) Number of additions (RU)
(a) Additions for E8 (b) Multiplications for E8 (c) Additions for E2

Fig. 4. Number of operations required in RU-EA and proposed EA

Number of multiplications (Proposed)

n=1000 n=1000 n=1000

Number of additions (Proposed)

Number of additions (Proposed)

n=2000 n=2000 n=2000
15000 n=3000 15000 n=3000 n=3000
n=4000 n=4000 n=4000
n=5000 n=5000 20000 n=5000
y=x y=x y=x
10000 10000

10000
5000 5000

0 0 0
0 5000 10000 15000 0 5000 10000 15000 0 10000 20000
Number of additions (Kaji) Number of multiplications (Kaji) Number of additions (Kaji)
(a) Additions for E8 (b) Multiplications for E8 (c) Additions for E2

Fig. 5. Number of operations required in K-EA and proposed EA

[6] Y. Kaji, “Encoding LDPC codes using the triangular factorization,” Likoping University, 1996.
IEICE Trans. Fundamentals, vol. 89, no. 10, pp. 2510–2518, 2006. [13] T. Richardson and R. Urbanke, Modern coding theory. Cambridge
[7] T. Shibuya and K. Kobayashi, “Efficient linear time encoding for LDPC university press, 2008.
codes,” IEICE Trans. Fundamentals, vol. 97, no. 7, pp. 1556–1567, [14] C. Aykanat, A. Pinar, and Ü. V. Çatalyürek, “Permuting sparse rectan-
2014. gular matrices into block-diagonal form,” SIAM Journal on Scientific
[8] T. Nozaki, “Encoding of LDPC codes via block-diagonalization (in Computing, vol. 25, no. 6, pp. 1860–1879, 2004.
Japanese),” IEICE technical report, vol. 114, no. 224, pp. 43–48, 2014. [15] A. Itai and M. Rodeh, “Finding a minimum circuit in a graph,” SIAM
[9] ——, “Parallel encoding algorithm for LDPC codes based on block- Journal on Computing, vol. 7, no. 4, pp. 413–423, 1978.
diagonalization,” in 2015 IEEE International Symposium on Information
Theory (ISIT). IEEE, 2015, pp. 1911–1915.
[10] J. Huang and J. Zhu, “Linear time encoding of cycle GF (2p ) codes
through graph analysis,” IEEE Commun. Lett., vol. 10, no. 5, pp. 369–
371, 2006.
[11] N. Wiberg, H.-A. Loeliger, and R. Kotter, “Codes and iterative decoding
on general graphs,” European Transactions on telecommunications,
vol. 6, no. 5, pp. 513–525, 1995.
[12] N. Wiberg, “Codes and decoding on general graphs,” Ph.D. dissertation,
 Number of additions (Proposed)

n=1000(Modified)
n=1000(Original)
y=x
3500

3000

2500
2500 3000 3500
Number of additions (Kaji)

Fig. 6. The number of additions to the K-EA and the proposed EA for codes
in E2 with n = 1000