Next Article in Journal
Classical Versus Bayesian Error-Controlled Sampling Under Lognormal Distributions with Type II Censoring
Previous Article in Journal
HECM-Plus: Hyper-Entropy Enhanced Cloud Models for Uncertainty-Aware Design Evaluation in Multi-Expert Decision Systems
Previous Article in Special Issue
Mutual Information Neural-Estimation-Driven Constellation Shaping Design and Performance Analysis
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

LDPC Codes on Balanced Incomplete Block Designs: Construction, Girth, and Cycle Structure Analysis

1
School of Computer, Henan University of Engineering, Zhengzhou 451191, China
2
School of Mathematical Sciences, Shanghai Jiao Tong University, Shanghai 200240, China
*
Author to whom correspondence should be addressed.
Entropy 2025, 27(5), 476; https://doi.org/10.3390/e27050476
Submission received: 20 March 2025 / Revised: 17 April 2025 / Accepted: 25 April 2025 / Published: 27 April 2025
(This article belongs to the Special Issue Advances in Modern Channel Coding)

Abstract

:
In this paper, we investigate the cycle structure inherent in the Tanner graphs of low-density parity-check (LDPC) codes constructed from balanced incomplete block designs (BIBDs). We begin by delineating the incidence structure of BIBDs and propose a methodology for constructing LDPC codes based on these designs. By analyzing the incidence relations between points and blocks within a BIBD, we prove that the resulting LDPC codes possess a girth of 6. Subsequently, we provide a detailed analysis of the cycle structure of the constructed LDPC codes and introduce a systematic approach for enumerating their short cycles. Using this method, we determine the exact numbers of cycles of lengths 6 and 8. Simulation results demonstrate that the constructed LDPC codes exhibit excellent performance.

1. Introduction

Low-density parity-check (LDPC) codes exhibit remarkable performance within the framework of iterative decoding. Several structural properties of LDPC codes significantly influence their iterative decoding performance, including their minimum distance, row redundancy, and degree distribution of their parity-check matrices, as well as the girth and cycle distribution of their Tanner graphs [1], among others. For an LDPC code, the iterative decoder, which operates based on belief propagation, functions on its Tanner graph. The presence of cycles causes the decoder to operate locally until a solution is found or the termination condition is met. In other words, the decoding solution is derived primarily around cycles, particularly short cycles, which prevents the decoder from achieving globally optimal solutions. Consequently, iterative decoders operating on Tanner graphs with short cycles are unable to identify maximum-likelihood (ML) code words [2]. As a result, cycles, especially short ones, adversely affect the decoding performance of LDPC codes when decoded using iterative algorithms. This makes the study of cycle distribution in LDPC codes a topic of significant interest [3].
Numerous effective algorithms have been developed for the counting of cycles in LDPC codes (or their Tanner graphs). In bipartite graphs, cycles of lengths g , g + 2 , and g + 4 were enumerated in [4], where g represents the girth of the graph. However, the computational complexity of these methods increases rapidly with the number of variable nodes. Several alternative approaches have been proposed based on graph properties such as eigenvalues, degree distribution, and spectrum [5,6,7,8]. Additionally, leveraging message-passing algorithms, two competitive methods were presented in [9,10]. Nevertheless, for the methods described in [5,6,7,8,9,10], the lengths of the counted cycles do not exceed 2 g , where g is the girth of the LDPC code. Furthermore, necessary and sufficient conditions for the existence of cycles in quasi-cyclic LDPC (QC-LDPC) codes have been established in [11,12,13,14], along with corresponding cycle-counting algorithms. Determining the number of cycles in the Tanner graphs of well-designed LDPC codes based on design rules or structural properties remains a topic of significant interest.
Complementary to these, random-like constructions with carefully designed cycle-avoidance rules have also been developed [15,16,17]. A unifying framework emerges through partial geometries, which provides a geometric perspective for the analysis of code structures [18]. This approach has proven particularly valuable, as partial geometry-based LDPC codes demonstrate exceptional iterative decoding performance [19,20]. Notably, balanced incomplete block designs (BIBDs) constitute an important subclass of partial geometries [21], making them particularly attractive for code construction.
The design of LDPC codes with large girth and a minimal number of short cycles has been approached through various mathematical frameworks. Algebraic constructions utilizing finite fields [22], finite geometries [23], Sidon sequences [24], protographs [25], and transversal designs [26] have shown promising results. Additionally, random-like LDPC codes designed under specific rules (e.g., avoiding or eliminating short cycles) have also been proposed [15,16,17]. Connections among algebraically constructed LDPC codes were explored in [27]. Notably, a well-known general framework called partial geometries was introduced, under which many existing LDPC code constructions can be unified [18]. By leveraging the concept of partial geometries, key structural properties of LDPC codes and their parity-check matrices can be analyzed from a geometric perspective. Research has demonstrated that LDPC codes constructed based on partial geometries exhibit excellent performance under iterative decoding [19,20]. Notably, BIBDs constitute an important subclass of partial geometries [21], making them particularly attractive for code construction. Consequently, the use of BIBDs to construct high-performance LDPC codes has become a topic of significant interest in coding theory [28,29,30,31,32,33]. It is worth noting that the construction methods for some BIBDs were detailed in [34].
In this paper, we investigate LDPC codes constructed based on balanced incomplete block designs (BIBDs). By analyzing the cycle structure, we aim to understand how the design parameters of BIBDs, such as block size and the number of points, affect the presence and distribution of short cycles, which are critical factors in determining the performance of LDPC codes under belief propagation decoding. Unlike previous works reported in [28,29,30,31,32,33], we utilize the complete structure of a BIBD to design LDPC codes. Specifically, given a BIBD, the constructed LDPC code exhibits well-defined parameters, such as code length, row weight, and column weight the parity-check matrix. Moreover, we establish the incidence relationship between points and blocks in a BIBD and analyze the cycle structure within the Tanner graphs of the resulting LDPC codes. Based on this analysis, we propose a systematic method for counting cycles and determine the exact number of cycles of lengths 6 and 8 in the Tanner graphs. Finally, we provide numerical simulation results to demonstrate the performance of the constructed LDPC codes based on BIBDs.
The main contributions of this paper are outlined as follows.
  • Novel structured construction: We present a systematic framework for constructing LDPC codes using complete BIBDs. The proposed method generates parity-check matrices with guaranteed structural properties that satisfy the row–column (RC) constraints, extending the partial geometry approach established in [18]. The construction method provides a mathematically rigorous yet practically viable coding solution that bridges the gap between theoretical design and communication requirements. This makes it particularly attractive for applications demanding both excellent error correction capability and implementation feasibility.
  • Girth guarantees and performance analysis: We provide a rigorous proof that the BIBD-LDPC codes achieve a minimum girth of 6, effectively eliminating detrimental short cycles that impair iterative decoding. The inherent properties of BIBDs, including balanced connectivity and optimized cycle structure, naturally prevent small trapping sets and low-weight code words, thereby enhancing both waterfall-region performance and error-floor characteristics.
  • Comprehensive cycle analysis: We develop a systematic methodology for analyzing the cycle structure of the constructed codes. The proposed technique enables precise enumeration of cycles (particularly lengths 6 and 8) in the Tanner graphs, with a generalizable framework that can be extended to count longer cycles (e.g., 10, 12, etc.). This analysis provides valuable insights into the code’s graphical properties and decoding behavior.

2. LDPC Codes Constructed from BIBDs and Their Tanner Graphs

2.1. LDPC Codes and Tanner Graphs

An LDPC code is defined by the null space of a sparse matrix ( H = [ h i j ] ), known as a parity-check matrix. If every row of H contains ρ nonzero elements and every column of H contains γ nonzero elements, the resulting LDPC code is referred to as ( γ , ρ ) -regular. The Tanner graph of an LDPC code is a bipartite graph, where the two types of vertices correspond to the row indices and column indices of H , respectively. An edge connects the row index (i) and the column index (j) if and only if element h i j of H is nonzero. A cycle in the Tanner graph is a closed path of interconnected edges that starts and ends at the same edge, traversing no other edge more than once. The length of the shortest cycles in the Tanner graph of an LDPC code is known as its girth.

2.2. Balanced Incomplete Block Designs (BIBDs)

Let X be a finite set of points and B be a collection of subsets of X , where the elements of B are referred to as blocks. The number of elements in X is denoted by υ , i.e., | X | = υ . Let the number of blocks in B be m, and let K denote the set of possible sizes for the blocks. Specifically, each block in B contains a number of elements that belong to K. This means that the size of any block in B is one of the values in set K, i.e., for B j B , 1 j m , | B j | K . A BIBD is an incidence structure defined by pair ( X , B ) , which satisfies the following properties:
(1)
Each block in B contains exactly k i points for k i K .
(2)
Every pair of distinct points in X is contained in exactly λ blocks.
This incidence structure ( X , B ) is denoted by BIBD ( K , λ ; υ ) . For K = { κ } , BIBD ( K , λ ; υ ) is denoted by BIBD ( κ , λ ; υ ) for short. In combinatorial design theory, BIBD ( K , 1 ; υ ) is also referred to as the Steiner 2 design. These properties ensure a balanced and structured relationship between the points and blocks, making balanced incomplete block designs (BIBDs) a cornerstone of combinatorial design theory. Their well-defined and symmetric structure is particularly valuable in the construction of LDPC codes, where BIBDs are employed to achieve desirable properties such as large girth and controlled cycle distributions in Tanner graphs. This makes BIBDs a powerful tool for designing LDPC codes with enhanced iterative decoding performance.

2.3. LDPC Codes Constructed Based on BIBDs

Consider a BIBD ( K , λ ; υ ) , where the number of blocks in B is m. The points and blocks in BIBD ( K , λ ; υ ) are represented as x 1 , x 2 , , x υ and B 1 , B 2 , , B m , respectively, that is, X = { x 1 , x 2 , , x υ } and B = { B 1 , B 2 , , B m } . Algebraically, BIBD ( K , λ ; υ ) can be represented by an incidence matrix ( I = [ I i j ] ) of size υ × m , whose elements are either 0 or 1. The rows of I correspond to the points of the BIBD, labeled from 1 to υ (or, equivalently, x 1 , x 2 , , x υ ), and the columns correspond to the blocks, labeled from 1 to m (or, equivalently, B 1 , B 2 , , B m ). Element I i j equals 1 (i.e., I i j = 1) if and only if the i-th point ( x i ) is contained in the j-th block ( B j ); otherwise, I i j = 0 . In this paper, the incidence matrix of a BIBD is used as the parity-check matrix, and its null space defines an LDPC code, referred to as the BIBD-LDPC code. This approach leverages the combinatorial properties of BIBDs to construct LDPC codes with desirable structural characteristics.
To facilitate the understanding of BIBDs, an example is provided. Consider a BIBD ( 3 , 1 ; 7 ) . Here, the number of elements in each block is 3, and the cardinality of point set X is 7. Without loss of generality, let the point set be X = { a , b , c , d , e , f , g } and the block set be B = { { a , e , g } , { a , b , f } , { b , c , g } , { a , c , d } , { b , d , e } , { c , e , f } , { d , f , g } } . A straightforward counting argument confirms that the incidence structure ( X , B ) satisfies the properties of a BIBD ( 3 , 1 ; 7 ) . Consequently, the incidence matrix ( I = [ I i j ] ) of size 7 × 7 is constructed as follows:
I = I i j 7 × 7 = 1 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 1 0 1 0 0 0 1 ,
where each row corresponds to a point in X and each column corresponds to a block in B . Element I i j is 1 if the i-th point is included in the j-th block; otherwise, it is 0. It can be observed that the rank of the incidence matrix ( I ) is 4. Consequently, the null space of I defines a ( 3 , 3 ) -regular ( 7 , 3 ) LDPC code. This code is characterized by a code length of 7, a dimension of 3, and a parity-check matrix with uniform row and column weights of 3.
To avoid generating cycles of length 4, a well-known row–column (RC) constraint can be applied to the parity-check matrix. Specifically, no two rows (or two columns) in the parity-check matrix should have more than one position in common. Therefore, for BIBD-LDPC codes to be free of cycles of length 4, it is necessary to ensure that any two points do not appear together in more than one block or, equivalently, any two blocks share, at most, one common point. This condition requires that the λ parameter equal 1. Additionally, the column weights of the parity-check matrix take values from set K. To ensure that the BIBD-LDPC code has a fixed column weight, we set K = { κ } . Consequently, in the remainder of this paper, the discussed BIBD-LDPC codes are constructed from BIBD ( κ , 1 ; υ ) .
According to the structural properties of BIBD ( κ , 1 ; υ ) , the code length of the constructed BIBD-LDPC code is given by
υ υ 1 κ κ 1 .
The incidence matrix of BIBD ( κ , 1 ; υ ) has a column weight of κ and a row weight of υ 1 / κ 1 . The rank of the incidence matrix depends on the specific structure of the BIBD. Numerical results show that the parity-check matrices of BIBD-LDPC codes typically have full (or nearly full) rank. Therefore, the code rate (R) of a BIBD-LDPC code constructed from BIBD ( κ , 1 ; υ ) is at least
R 1 κ κ 1 υ υ 1 .

3. Girth and Cycle Structure Analysis of BIBD-LDPC Codes

We now consider a BIBD-LDPC code whose parity-check matrix is the incidence matrix ( I ) of a given BIBD ( κ , 1 ; υ ) . In this section, we analyze the cycle structure of BIBD-LDPC codes, determine their girth, and present a method for counting cycles in their Tanner graphs. Specifically, We investigate how the combinatorial properties of BIBDs influence the cycle distribution in the Tanner graphs of these codes, potentially providing valuable insights into their iterative decoding performance.

3.1. Cycle Structure of BIBD-LDPC Codes

According to the definition of cycles in the Tanner graph [1,11], a cycle in the BIBD-LDPC code can be represented as an ordered sequence of positions of alternate nonzero elements in the parity-check matrix. Based on the structure of the incidence matrix of BIBD ( κ , 1 ; υ ) , a cycle of length 2 i in the Tanner graph of the BIBD-LDPC code can be expressed as the following sequence:
x j 0 , B l 0 , x j 1 , B l 1 , x j 2 , B l 2 , , x j i 1 , B l i 1 , x j 0 , B l 0
where for 0 k i 1 , j k j k + 1 , j i = j 0 , l k l k + 1 , l i = l 0 , x j k X , and B j k B . x j 0 , x j 1 , , x j i 1 are distinct points in X , and B l 0 , B l 1 , , B l i 1 are distinct blocks in B . Each consecutive pair ( ( x j i , B l i ) and ( x j i + 1 , B l i ) , where j i = j 0 and l i = l 0 ) corresponds to a nonzero entry in the incidence matrix ( I ), ensuring the cycle is closed. This sequence represents a closed path in the Tanner graph, where each point ( x j i ) is connected to block B l i and each block ( B l i ) is connected to the next point ( x j i + 1 ), forming a cycle of length 2 i .
In other words, the adjacent points (or blocks) in the sequence (1) are distinct from one another. Additionally, each block in (1) contains its two adjacent points, and each point in (1) is included in its two adjacent blocks. For a BIBD ( κ , 1 ; υ ) , any pair of points in X is contained in exactly one block. Consequently, for two points adjacent to the same block in (1), no other block contains both of them. Therefore, the point-and-block sequence (1) can be simplified and represented by the following point sequence:
x j 0 , x j 1 , x j 2 , , x j i 1
where for 0 k i 1 , j k j k + 1 , that is, a cycle of length 2 i can be fully represented by the point sequence (2), making it unnecessary to explicitly consider the blocks in the cycle. Therefore, a cycle of length 2 i corresponds uniquely to an ordered point sequence of the following form:
x j 0 , x j 1 , x j 2 , , x j i 1 ,
where x j 0 , x j 1 , x j 2 , , x j i 1 are distinct points in X and each consecutive pair ( x j , x j + 1 , where x i = x 0 ) is contained in exactly one block ( B k B ). This representation simplifies the analysis of cycles by focusing solely on the point sequence, leveraging the property of BIBD ( κ , 1 ; υ ) according to which each pair of points appears in exactly one block. As a result, the cycle structure is entirely determined by the arrangement of points, eliminating the need to explicitly track the blocks in the cycle.

3.2. Girth of BIBD-LDPC Codes

Based on the above analysis, we observe that BIBD-LDPC codes are constructed from the BIBD ( κ , 1 ; υ ) incidence structure, which is ( X , B ) , that is, λ = 1 . Hence, the parity-check matrices of these BIBD-LDPC codes satisfy the row–column (RC) constraint. This ensures that the constructed BIBD-LDPC codes are free of cycles of length 4 and, consequently, have a girth of at least 6. In fact, the girth of these BIBD-LDPC codes is exactly 6. To further determine the girth of BIBD-LDPC codes, we aim to identify a cycle of length 6 in the Tanner graph of a BIBD-LDPC code, and such a cycle corresponds to the point-and-block sequence described in (1). This sequence represents a closed path of length 6 in the Tanner graph, confirming the presence of cycles of length 6 in the BIBD-LDPC code.
Consider two distinct points ( x 1 , x 2 X ). According to the definition of BIBD ( κ , 1 ; υ ) , there exists a unique block ( B 1 , 2 B ) that contains both x 1 and x 2 . Since B 1 , 2 is a proper subset of X , there exists a point ( x 3 X ) such that x 3 B 1 , 2 . Consequently, x 3 is distinct from x 1 and x 2 . According to the properties of BIBD ( κ , 1 ; υ ) , there exists a unique block ( B 2 , 3 B ) that contains both x 2 and x 3 . It is clear that B 1 , 2 and B 2 , 3 are distinct blocks because x 3 B 1 , 2 but x 3 B 2 , 3 . Similarly, based on points x 1 and x 3 , there exists a unique block ( B 1 , 3 B ) that contains both x 1 and x 3 . Since x 2 B 1 , 3 (while x 2 B 1 , 2 ) and x 1 B 1 , 3 (while x 1 B 2 , 3 ), B 1 , 3 is distinct from both B 1 , 2 and B 2 , 3 . Thus, blocks B 1 , 2 , B 2 , 3 , and B 1 , 3 are all distinct. This leads to the following point-and-block sequence:
x 1 , B 1 , 2 , x 2 , B 2 , 3 , x 3 , B 1 , 3 , x 1 , B 1 , 2 ,
which forms a cycle of length 6 in the Tanner graph of the BIBD-LDPC code. This sequence satisfies the conditions for a cycle, as each consecutive pair of points and blocks corresponds to a nonzero entry in the incidence matrix, and the sequence is closed. Hence, this point-and-block sequence represents a closed path of length 6 in the Tanner graph, confirming the presence of cycles of length 6 in the BIBD-LDPC code. In the following, we explore methods to systematically identify and count such cycles.
It is evident that the point-and-block sequence described above can be simplified to the point sequence expressed as x 1 , x 2 , x 3 . Without loss of generality, any three distinct points selected from the point set ( X ) can form a similar point-and-block sequence as in (1). Consequently, there exist numerous cycles of length 6 in the Tanner graphs of BIBD-LDPC codes. This confirms that the girth of BIBD-LDPC codes constructed from BIBD ( κ , 1 ; υ ) is 6.

3.3. A Method for Counting Short Cycles of BIBD-LDPC Codes

Since the girth of BIBD-LDPC codes is 6, we focus on analyzing cycles of length 2 i in the Tanner graph of a BIBD-LDPC code for i 3 . Based on the cycle analysis in the preceding subsections, it is clear that the existence of cycles of length 2 i is closely tied to the point-and-block sequence described in (1) or, equivalently, the point sequence in (2). These sequences provide a systematic way to identify and characterize cycles in the Tanner graph, enabling a deeper understanding of the cycle structure and its impact on the performance of BIBD-LDPC codes.
According to the theory of quasi-cyclic LDPC (QC-LDPC) codes with a girth of g, Equation (4) in [11] provides the necessary and sufficient condition for the existence of cycles of length 2 i for g 2 i < 2 g [35]. Therefore, for the constructed BIBD-LDPC codes, the sequence (2) precisely represents cycles of length 2 i for 6 2 i 10 . From (2), it follows that identifying cycles of length 2 i is equivalent to finding i points in X such that any t adjacent points in these i points do not lie in the same block for 3 t i . Consequently, determining the number of cycles of length 2 i can be formulated as a combinatorial problem. It is important to note that for 2 i 12 , the existence of cycles of length 2 i depends on the presence of cycles of length j for j i , such as cycles of length 6. The analysis of these longer cycles involves more complex sequences derived from (2). In the following, we focus on cycles of length 2 i in the Tanner graph of BIBD-LDPC codes, which can be divided into three parts:
  • Selection of i points from X : The number of ways to choose i distinct points from the υ points in X is given by the combination formula expressed as
    C υ i = υ ! i ! ( υ i ) ! .
    This quantity is denoted by P 1 .
  • Exclusion of invalid cases: Among the chosen i points, some cases must be excluded where any t adjacent points (for 3 t i ) lie in the same block. These cases require a detailed combinatorial analysis, and the number of such invalid cases is denoted by P 2 .
  • Counting valid cycles of length 2 i : For the remaining valid selections of i points, the number of cycles of length 2 i that can be formed is denoted by P 3 . This involves determining how many distinct cycles of length 2 i exist for each valid set of i points. This is analogous to the circle permutation problem but without considering the order of permutation. A simple counting argument shows that
    P 3 = ( i 1 ) ! 2 .
    This formula accounts for the number of distinct cycles that can be formed from i points, treating rotations and reflections as identical.
Based on the above analysis, the total number of cycles of length 2 i in the Tanner graph of a BIBD-LDPC code is given by
( P 1 P 2 ) × P 3 .
Since P 1 and P 3 can be directly calculated using the corresponding formulas based on the parameters of the BIBD, our focus shifts to determining P 2 , which represents the number of invalid cases where t adjacent points (for 3 t i ) lie in the same block. Once P 2 is computed, the number of cycles of length 2 i can be determined for specific values of i. In the following, we apply the proposed cycle-counting method to calculate the number of cycles of lengths 6 and 8 in the Tanner graph of the BIBD-LDPC code constructed from BIBD ( κ , 1 ; υ ) . It is noted that parameters i , t , P 1 , P 2 , P 3 , κ , and υ are consistently used in the following two subsections to maintain a unified framework for counting cycles of different lengths in the Tanner graphs of BIBD-LDPC codes.

3.3.1. Number of Cycles of Length 6

In this case, we only consider i = 3 , and parameter t takes only one value, namely 3. Therefore, for the cases of P 2 , the only scenario to consider is when three points chosen from X lie in the same block. In other words, we calculate the number of cases where any three points of X are contained within a single block. For any block in B with κ 3 , the number of ways to choose three points from the block is given by
C κ 3 = κ ( κ 1 ) ( κ 2 ) 3 ! .
Since the total number of blocks in the BIBD is
υ ( υ 1 ) κ ( κ 1 ) ,
the total number of invalid cases ( P 2 ) is
P 2 = υ ( υ 1 ) ( κ 2 ) 3 ! .
Additionally, the values of P 1 and P 3 are calculated as follows:
P 1 = C υ 3 = υ ( υ 1 ) ( υ 2 ) 3 ! ,
and
P 3 = ( 3 1 ) ! 2 = 1 .
Combining P 1 and P 2 , the exact number of cycles of length 6 ( N 6 ) is
N 6 = ( P 1 P 2 ) × P 3 = ( υ ( υ 1 ) ( υ 2 ) 3 ! υ ( υ 1 ) ( κ 2 ) 3 ! ) × 1 = υ ( υ 1 ) ( υ κ ) 3 ! .
After a simple verification, it can be observed that even for κ = 2 , the number of cycles of length 6 remains consistent with the expression for N 6 in (3). Specifically, substituting κ = 2 into the formula expressed as
N 6 = υ ( υ 1 ) ( υ κ ) 3 ! ,
yields
N 6 = υ ( υ 1 ) ( υ 2 ) 3 ! .
This result aligns with the combinatorial interpretation, as the case of κ = 2 inherently prevents the formation of cycles of length 6 due to the inability to have three points in a single block. Thus, the formula remains valid for κ = 2 , confirming its generality.

3.3.2. Number of Cycles of Length 8

In this case, i = 4 , and we first assume κ 4 . The t parameter takes two values: 3 and 4. Therefore, cases of P 2 can be partitioned into two distinct categories: (a) all four points in the same block ( t = 4 ) and (b) three points in the same block and one point in a different block ( t = 3 ).
The first class of cases of P 2 is that all four points are in the same block ( t = 4 ). This corresponds to the scenario where any four points of X lie in the same block. The number of such cases, denoted by P 21 , is calculated as follows:
(1)
For each block, the number of ways to choose four points is expressed as
C κ 4 = κ ( κ 1 ) ( κ 2 ) ( κ 3 ) 4 ! .
(2)
The total number of blocks in the BIBD is expressed as
υ ( υ 1 ) κ ( κ 1 ) .
(3)
Thus, the total number of cases where four points lie in the same block is expressed as
P 21 = υ ( υ 1 ) κ ( κ 1 ) × κ ( κ 1 ) ( κ 2 ) ( κ 3 ) 4 ! = υ ( υ 1 ) ( κ 2 ) ( κ 3 ) 4 ! .
The second class of cases of P 2 is occurs when three points lie in the same block and one point is in a different block ( t = 3 ). This corresponds to the scenario where any three of the four points lie in the same block and the fourth point lies in a different block. The number of such cases, denoted by P 22 , is calculated as follows:
(1)
For each block, the number of ways to choose three points is expressed as
C κ 3 = κ ( κ 1 ) ( κ 2 ) 3 ! .
(2)
The fourth point must be chosen from the remaining ( υ κ ) points (since it cannot be in the same block as the first three points).
(3)
The total number of blocks in the BIBD is
υ ( υ 1 ) κ ( κ 1 ) .
(4)
Thus, the total number of cases where three points lie in the same block and the fourth point lies in a different block is expressed as
P 22 = υ ( υ 1 ) κ ( κ 1 ) × κ ( κ 1 ) ( κ 2 ) 3 ! × ( υ κ ) = υ ( υ 1 ) ( κ 2 ) ( υ κ ) 3 ! .
Combining these two cases, the total number of invalid cases ( P 2 ) is
P 2 = P 21 + P 22 = υ ( υ 1 ) ( κ 2 ) ( κ 3 ) 24 + υ ( υ 1 ) ( κ 2 ) ( υ κ ) 6 .
Since
P 1 = C υ 4 = υ ( υ 1 ) ( υ 2 ) ( υ 3 ) 4 ! .
and
P 3 = ( 4 1 ) ! 2 = 3 ,
the number of cycles of length 8 ( N 8 ) is expressed as
N 8 = ( P 1 P 2 ) × P 3 = υ ( υ 1 ) 8 × ( ( υ 2 ) ( υ 3 ) ( κ 2 ) ( 4 υ 3 κ 3 ) ) ,
where κ 4 .
When κ = 3 , it is evident that the cases of P 2 (where all four points lie in the same block) cannot occur, since each block contains only three points. Therefore, P 21 = 0 . For κ = 3 , the number of cycles of length ( N 8 ) is determined solely by the second cases of P 2 , where three points lie in the same block and the fourth point lies in a different block. Substituting κ = 3 into the expression for P 22 , we have
P 22 = υ ( υ 1 ) ( κ 2 ) ( υ κ ) 3 ! = υ ( υ 1 ) ( υ 3 ) 6 .
Since P 21 = 0 , the total number of invalid cases ( P 2 ) is
P 2 = P 21 + P 22 = υ ( υ 1 ) ( υ 3 ) 6 .
Hence, the number of cycles of length 8 ( ( N 8 ) ) for κ = 3 is
N 8 = ( P 1 P 2 ) × P 3 = υ ( υ 1 ) ( υ 3 ) ( υ 6 ) 8 .
When κ = 2 , the block size is too small to accommodate the conditions required for two classes of cases of P 2 . Specifically, the first class of cases requires four points to lie in the same block, which is impossible, since κ = 2 , and the second class of cases requires three points to lie in the same block, which is also impossible, since κ = 2 . Thus, both P 21 and P 22 are zero, and the total number of invalid cases ( P 2 ) is
P 2 = P 21 + P 22 = 0 + 0 = 0 .
Hence, the number of cycles of length 8 ( N 8 ) for κ = 2 is
N 8 = ( P 1 P 2 ) × P 3 = υ ( υ 1 ) ( υ 2 ) ( υ 3 ) 8 .
Based on the above analysis, it can be observed that for κ = 2 and κ = 3 , the number of cycles of length 8 ( N 8 ) is consistent with the expression for N 8 derived in (4) with κ 4 . Thus, the general expression for N 8 in (4) remains valid for κ = 2 and κ = 3 , demonstrating its generality across different block sizes. This confirms that the cycle-counting method is robust and applicable to a wide range of BIBD-LDPC codes.

4. Short Cycles of Specific BIBD-LDPC Codes

In this section, we provide specific examples of BIBD-LDPC codes and determine their short-cycle distributions. By applying the cycle-counting method developed in the previous sections, we calculate the number of cycles of lengths 6 and 8 for these codes. This analysis highlights the relationship between the parameters of the BIBD (e.g., κ , υ ) and the cycle structure of the resulting LDPC codes.
First, we provide some important parameters of BIBD-LDPC codes. Based on a BIBD ( κ , 1 ; υ ) , we can construct a BIBD-LDPC code of length υ υ 1 υ υ 1 κ κ 1 κ κ 1 , the parity-check matrix of which has a column weight of κ and a row weight of υ 1 / κ 1 . The code rate is about ( 1 κ κ 1 κ κ 1 υ 1 ( υ 1 ) ) . The detailed parameters of the BIBD-LDPC codes are presented in Table 1. Second, we provide some existing BIBDs. For convenience, we do not introduce the construction of the existing BIBDs and only provide their existence conditions. We summarize some existing BIBDs in Theorem 1.
Theorem 1.
A BIBD ( κ , 1 ; υ ) exists for κ = 3, 4, 5, 6, and 7 if one of the following conditions is satisfied.
(1) 
If υ 1 mod 6 or υ 3 mod 6 , there exists a BIBD ( 3 , 1 ; υ ) .
(2) 
If υ 1 mod 12 or υ 4 mod 12 , there exists a BIBD ( 4 , 1 ; υ ) .
(3) 
If υ 1 mod 20 or υ 5 mod 20 , there exists a BIBD ( 5 , 1 ; υ ) .
(4) 
If υ 1 mod 15 or υ 6 mod 15 for υ 16, 21, 36, 46, 51, 61, 81, 166, 226, 231, 256, 261, 286, 316, 321, 346, 351, 376, 406, 411, 436, 441, 471, 501, 561, 591, 616, 646, 651, 676, 771, 796, and 801, there exists a BIBD ( 6 , 1 ; υ ) .
(5) 
If υ = 42 i + 1 for i 1, 2, 3, 5, 6, 12, 14, 17, 19, 22, 27, 33, 37, 39, 42, 47, 59, and 62 or υ = 42 t + 7 for i 3, 19, 34, and 39, there exists a BIBD ( 7 , 1 ; υ ) .
Based on the cycle-number equations derived in Section 3.3, we can directly determine the number of short cycles in BIBD-LDPC codes constructed from a BIBD ( κ , 1 ; υ ) . By applying Theorem 1, we can obtain a BIBD and subsequently construct a BIBD-LDPC code. Using this approach, the number of short cycles in the Tanner graphs of the constructed BIBD-LDPC codes can be accurately counted. These results are recorded in Table 2.
Notably, the proposed cycle-counting method achieves O ( 1 ) complexity, as the enumeration of cycles of lengths 6 and 8 reduces to closed-form expressions parameterized by υ . This contrasts sharply with existing approaches that require greater computational complexity. For instance, counting cycles with a length of 6 in a BIBD-LDPC code constructed from BIBD ( κ , 1 ; υ ) using the competitive message-passing algorithm proposed in [10] incurs complexity of O ( g υ υ 1 υ υ 1 κ κ 1 κ κ 1 ) , whereas our method requires only two subtractions, three multiplications, and one division operation.

5. Simulation Results

In the following simulations, we assume an additive white Gaussian noise (AWGN) channel, binary phase-shift keying (BPSK) modulation, and the sum-product algorithm (SPA) with 50 iterations for decoding.
Consider BIBD ( 3 , 1 ; 63 ) . This design consists of 63 points and 651 blocks. Using its incidence matrix, we construct a (3,31)-regular (651,589) BIBD-LDPC code. The bit-error rate (BER) and word-error rate (WER) of this code, decoded using the sum-product algorithm (SPA), are illustrated in Figure 1. For comparison, we also construct a (3,31)-regular (651,588) LDPC code based on the progressive edge-growth (PEG) algorithm [16], referred to as the PEG-LDPC code. The BER/WER performance of this PEG-LDPC code is also included in Figure 1. From Figure 1, it is evident that the (651,589) BIBD-LDPC code outperforms the (651,588) PEG-LDPC code by approximately 0.3 dB at a WER of 10 6 . Additionally, the BIBD-LDPC code exhibits no error floor down to a BER of 2 × 10 9 . Notably, the (3,31)-regular (651,589) BIBD-LDPC code contains 39,060 cycles of length 6 and 1,669,815 cycles of length 8.
Consider BIBD ( 3 , 1 ; 75 ) . This design consists of 75 points and 925 blocks. The null space of the incidence matrix of this BIBD yields a (3,37)-regular (925,851) BIBD-LDPC code. The BER performance of this code under iterative decoding using the sum-product algorithm (SPA) with 1, 3, 5, 10, 20, and 50 iterations is depicted in Figure 2. As shown in Figure 2, the iterative decoding of this code converges very quickly. The BER performance curves for 20 and 50 iterations are nearly identical, indicating convergence. At a BER of 10 6 , the performance gap between 5 and 50 iterations is only 0.25 dB, while the gap between 10 and 50 iterations is approximately 0.1 dB. Furthermore, this BIBD-LDPC code exhibits a low error floor, as demonstrated in Figure 2. For the (3,37)-regular (925,851) BIBD-LDPC code, the numbers of cycles of lengths 6 and 8 are 66,600 and 3,446,550, respectively. For performance benchmarking, we compare the constructed (3,37)-regular (925,851) BIBD-LDPC code against the standard (651,589) 5G-LDPC code specified in [36]. Figure 3 presents the BER/WER performance under SPA decoding with both 5 and 20 iterations. It can be seen from Figure 3 that the constructed BIBD-LDPC code achieves approximately 0.2 dB coding gain at a BER of 10 5 with 20 decoding iterations compared to the 5G-LDPC code, and the performance advantage becomes more pronounced (about 1 dB gain at BER = 10 5 ) when using only 5 iterations. These comparative results validate that the proposed BIBD construction maintains performance with competitive with modern 5G standards while offering faster convergence, a critical advantage for latency-sensitive applications.
To evaluate the performance of our proposed BIBD-LDPC codes, we employ extrinsic information transfer (EXIT) chart analysis to examine their convergence behavior [37]. Figure 4 illustrates a typical EXIT chart for regular LDPC codes operating over a binary-input AWGN channel with parameters of γ = 3 and ρ = 37 . The EXIT chart utilizes extrinsic mutual information as its key metric, comprising two characteristic curves: (1) The upper solid blue curve ( I E , V vs. I A , V ) represents the variable-node processors (VNPs), showing the output extrinsic mutual information ( I E , V ) as a function of input a priori information ( I A , V ). (2) The lower dashed red curve ( I A , C vs. I E , C ) characterizes the check-node processors (CNPs), depicting output extrinsic mutual information ( I E , C ) versus input a priori information ( I A , C ). (Note that this curve is conventionally plotted with reversed axes for EXIT chart representation.) The iterative decoding process manifests as a trajectory bouncing between these curves, where extrinsic information from VNPs becomes a priori information for CNPs and vice-versa. Beginning at the (0,0) point (complete uncertainty), successful decoding is achieved when the trajectory converges to (1,1) (perfect information transfer and error-free decoding). This graphical representation vividly demonstrates the information exchange dynamics between VNPs and CNPs. The widening “tunnel” between the curves at higher SNR values accelerates decoder convergence. The shown SNR (slightly above 3.9437 dB) represents the decoding threshold for the (3,37) code ensemble. Below this critical threshold, the tunnel closes, preventing the trajectory from reaching the (1,1) point and resulting in nonzero error rates.

6. Conclusions

In this paper, we proposed a method for constructing LDPC codes based on a BIBD ( κ , 1 ; υ ) . We analyzed the cycle structure of the constructed LDPC codes and determined their girth. Numerical results show that the constructed LDPC codes exhibit excellent performance under iterative decoding. Furthermore, we presented a method for counting cycles in the Tanner graphs of these codes, specifically enumerating cycles of lengths 6 and 8. This method can be extended to systematically count cycles of lengths greater than 8 (e.g., 10, 12, etc.). However, the complexity of the analysis increases significantly with the cycle length, primarily due to the need to account for the presence of existing shorter cycles (such as those of lengths 6 and 8) and their interactions within the Tanner graph.

Author Contributions

Conceptualization, H.X. and X.Z.; methodology, H.X. and X.Z.; software, M.X. and H.Y.; validation, H.X. and M.X.; formal analysis, H.X. and X.Z.; investigation, H.X.; resources, H.Z.; data curation, H.X. and M.X.; writing—original draft preparation, H.X. and M.X.; writing—review and editing, H.X., X.Z., M.X., H.Y. and H.Z.; supervision, H.Z.; project administration, H.Z.; funding acquisition, H.X., X.Z., M.X., H.Y. and H.Z. All authors have read and agreed to the published version of the manuscript.

Funding

This work was supported in part by the National Natural Science Foundation of China (Grant Nos. 62172457, 11971311, and 61801527), the TianYuan Special Funds of the National Natural Science Foundation of China (Grant Nos. 12026230 and 12026231), and the Development Project of Henan Provincial Department of Science and Technology (Grant Nos. 252102210230, 252102210236, and 242102210200), and the Key Scientific Research Project in Colleges and Universities of Henan Province (Grant Nos. 22A520002 and 24A510003).

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

The data that support the findings of this research are available from the corresponding author upon reasonable request.

Conflicts of Interest

The authors declare no conflicts of interest.

Abbreviations

The following abbreviations are used in this manuscript:
LDPCLow-density parity check
BIBDBalanced incomplete block design
BIBD-LDPC codesLDPC codes constructed from BIBDs
MLMaximum likelihood
RCRow–column
QC-LDPCQuasi-cyclic LDPC
N 6 Number of cycles of length 6
N 8 Number of cycles of length 8
AWGNAdditive white Gaussian noise
BPSKBinary phase-shift keying
SPASum-product algorithm
PEGProgressive edge growth
PEG-LDPCLDPC code based on the progressive edge-growth algorithm
BERBit-error rate
WERWord-error rate

References

  1. Tanner, R.M. A recursive approach to low complexity codes. IEEE Trans. Inf. Theory 1981, 27, 533–547. [Google Scholar] [CrossRef]
  2. Li, J.; Lin, S.; Abdel-Ghaffar, K.; Ryan, W.E.; Costello, D.J., Jr. LDPC Code Designs, Constructions, and Unification; Cambridge University Press: New York, NY, USA, 2017. [Google Scholar]
  3. Blake, I.F.; Lin, S. On short cycle enumeration in biregular bipartite graphs. IEEE Trans. Inf. Theory 2018, 64, 6526–6535. [Google Scholar] [CrossRef]
  4. Halford, T.; Chugg, K. An algorithm for counting short cycles in bipartite graphs. IEEE Trans. Inf. Theory 2006, 52, 287–292. [Google Scholar] [CrossRef]
  5. Karimi, M.; Banihashemi, A.H. Counting Short Cycles of Quasi Cyclic Protograph LDPC Codes. IEEE Commun. Lett. 2012, 16, 400–403. [Google Scholar] [CrossRef]
  6. Dehghan, A.; Banihashemi, A.H. On Computing the Multiplicity of Cycles in Bipartite Graphs Using the Degree Distribution and the Spectrum of the Graph. IEEE Trans. Inf. Theory 2019, 65, 3778–3789. [Google Scholar] [CrossRef]
  7. Dehghan, A.; Banihashemi, A.H. Counting Short Cycles in Bipartite Graphs: A Fast Technique/Algorithm and a Hardness Result. IEEE Trans. Commun. 2020, 68, 1378–1390. [Google Scholar] [CrossRef]
  8. Dehghan, A.; Banihashemi, A.H. On Computing the Number of Short Cycles in Bipartite Graphs Using the Spectrum of the Directed Edge Matrix. IEEE Trans. Inf. Theory 2020, 66, 6037–6047. [Google Scholar] [CrossRef]
  9. Karimi, M.; Banihashemi, A.H. Message-Passing Algorithms for Counting Short Cycles in a Graph. IEEE Trans. Commun. 2013, 61, 485–495. [Google Scholar] [CrossRef]
  10. Li, J.; Lin, S.; Abdel-Ghaffar, K. Improved message-passing algorithm for counting short cycles in bipartite graphs. In Proceedings of the 2015 IEEE International Symposium on Information Theory (ISIT), Hong Kong, China, 14–19 June 2015; pp. 416–420. [Google Scholar]
  11. Fossorier, M. Quasicyclic low-density parity-check codes from circulant permutation matrices. IEEE Trans. Inf. Theory 2004, 50, 1788–1793. [Google Scholar] [CrossRef]
  12. Wu, X.; You, X.; Zhao, C. A necessary and sufficient condition for determining the girth of quasi-cyclic LDPC codes. IEEE Trans. Commun. 2008, 56, 854–857. [Google Scholar] [CrossRef]
  13. Gomez-Fonseca, A.; Smarandache, R.; Mitchell, D.G.M. An Efficient Strategy to Count Cycles in the Tanner Graph of Quasi-Cyclic LDPC Codes. IEEE J. Sel. Areas Inf. Theory 2023, 4, 499–513. [Google Scholar] [CrossRef]
  14. Xu, H.; Zhang, X.D.; Li, H.; Zhu, H.; Zhang, B.; Liu, H. A cyclic-shift based method for counting cycles of quasi-cyclic LDPC codes. Electron. Lett. 2024, 60, e13085. [Google Scholar] [CrossRef]
  15. Jiang, X.; Xia, X.G.; Lee, M.H. Efficient Progressive Edge-Growth Algorithm Based on Chinese Remainder Theorem. IEEE Trans. Commun. 2014, 62, 442–451. [Google Scholar] [CrossRef]
  16. Hu, X.Y.; Eleftheriou, E.; Arnold, D. Regular and irregular progressive edge-growth tanner graphs. IEEE Trans. Inf. Theory 2005, 51, 386–398. [Google Scholar] [CrossRef]
  17. He, X.; Zhou, L.; Du, J. PEG-Like Design of Binary QC-LDPC Codes Based on Detecting and Avoiding Generating Small Cycles. IEEE Trans. Commun. 2018, 66, 1845–1858. [Google Scholar] [CrossRef]
  18. Diao, Q.; Tai, Y.Y.; Lin, S.; Abdel-Ghaffar, K. LDPC Codes on Partial Geometries: Construction, Trapping Set Structure, and Puncturing. IEEE Trans. Inf. Theory 2013, 59, 7898–7914. [Google Scholar] [CrossRef]
  19. Diao, Q.; Li, J.; Lin, S.; Blake, I.F. New Classes of Partial Geometries and Their Associated LDPC Codes. IEEE Trans. Inf. Theory 2016, 62, 2947–2965. [Google Scholar] [CrossRef]
  20. Li, J.; Gong, Y.; Xiao, X.; Lin, S.; Abdel-Ghaffar, K. Cyclic Partial Geometries and Their Associated LDPC and Constant-Weight Codes. IEEE Trans. Inf. Theory 2023, 69, 5570–5596. [Google Scholar] [CrossRef]
  21. Xu, H.; Yu, Z.; Feng, D.; Zhu, H. New construction of partial geometries based on group divisible designs and their associated LDPC codes. Phys. Commun. 2020, 39, 100970. [Google Scholar] [CrossRef]
  22. Li, J.; Liu, K.; Lin, S.; Abdel-Ghaffar, K. Algebraic Quasi-Cyclic LDPC Codes: Construction, Low Error-Floor, Large Girth and a Reduced-Complexity Decoding Scheme. IEEE Trans. Commun. 2014, 62, 2626–2637. [Google Scholar] [CrossRef]
  23. Tang, H.; Xu, J.; Lin, S.; Abdel-Ghaffar, K. Codes on finite geometries. IEEE Trans. Inf. Theory 2005, 51, 572–596. [Google Scholar] [CrossRef]
  24. Zhang, G. Type-II quasi-cyclic low-density parity-check codes from Sidon sequences. Electron. Lett. 2016, 52, 367–369. [Google Scholar] [CrossRef]
  25. Karimi, B.; Banihashemi, A.H. Construction of Irregular Protograph-Based QC-LDPC Codes with Low Error Floor. IEEE Trans. Commun. 2021, 69, 3–18. [Google Scholar] [CrossRef]
  26. Gruner, A.; Huber, M. Low-Density Parity-Check Codes from Transversal Designs with Improved Stopping Set Distributions. IEEE Trans. Commun. 2013, 61, 2190–2200. [Google Scholar] [CrossRef]
  27. Li, J.; Liu, K.; Lin, S.; Abdel-Ghaffar, K.; Ryan, W.E. An unnoticed strong connection between algebraic-based and protograph-based LDPC codes, Part I: Binary case and interpretation. In Proceedings of the 2015 Information Theory and Applications Workshop (ITA), San Diego, CA, USA, 1–6 February 2015; pp. 36–45. [Google Scholar]
  28. Johnson, S.; Weller, S. Resolvable 2-designs for regular low-density parity-check codes. IEEE Trans. Commun. 2003, 51, 1413–1419. [Google Scholar] [CrossRef]
  29. Ammar, B.; Honary, B.; Kou, Y.; Xu, J.; Lin, S. Construction of low-density parity-check codes based on balanced incomplete block designs. IEEE Trans. Inf. Theory 2004, 50, 1257–1269. [Google Scholar] [CrossRef]
  30. Lan, L.; Tai, Y.Y.; Lin, S.; Memari, B.; Honary, B. New constructions of quasi-cyclic LDPC codes based on special classes of BIBD’s for the AWGN and binary erasure channels. IEEE Trans. Commun. 2008, 56, 39–48. [Google Scholar] [CrossRef]
  31. Djordjevic, I.B. Quantum LDPC Codes from Balanced Incomplete Block Designs. IEEE Commun. Lett. 2008, 12, 389–391. [Google Scholar] [CrossRef]
  32. Falsafain, H.; Esmaeili, M. Construction of Structured Regular LDPC Codes: A Design-Theoretic Approach. IEEE Trans. Commun. 2013, 61, 1640–1647. [Google Scholar] [CrossRef]
  33. Wang, Y.J.; Xiao, Z.Y.; Xiong, X.Y.; Yan, J.Z.; Wang, C.; Shi, S. A Rate Scalable Construction of Non-Homogeneous Quantum LDPC Codes of CSS Type Based on Balanced Incomplete Block Design. IEEE Commun. Lett. 2021, 25, 1408–1411. [Google Scholar] [CrossRef]
  34. Colbourn, C.J.; Dinitz, J. Handbook of Combinatorial Designs; CRC Press: Boca Raton, FL, USA, 2006. [Google Scholar]
  35. Xu, H.; Feng, D.; Luo, R.; Bai, B. Construction of Quasi-Cyclic LDPC Codes via Masking with Successive Cycle Elimination. IEEE Commun. Lett. 2016, 20, 2370–2373. [Google Scholar] [CrossRef]
  36. 3GPP TS 38.212. 5G NR; Multiplexing and Channel Coding (Release 15) V15.3.0; Sophia Antipolis: Valbonne, France, 2018. [Google Scholar]
  37. Liva, G.; Chiani, M. Protograph LDPC Codes Design Based on EXIT Analysis. In Proceedings of the IEEE GLOBECOM 2007—IEEE Global Telecommunications Conference, Washington, DC, USA, 26–30 November 2007; pp. 3250–3254. [Google Scholar]
Figure 1. The error performance of the constructed (651,589) BIBD-LDPC code and the comparable (651,588) LDPC code designed by the PEG algorithm in [16].
Figure 1. The error performance of the constructed (651,589) BIBD-LDPC code and the comparable (651,588) LDPC code designed by the PEG algorithm in [16].
Entropy 27 00476 g001
Figure 2. The decoding convergence rate of the constructed (925,851) BIBD-LDPC code.
Figure 2. The decoding convergence rate of the constructed (925,851) BIBD-LDPC code.
Entropy 27 00476 g002
Figure 3. The error performance of the constructed (925,851) BIBD-LDPC code and the comparable (925,851) 5G-LDPC code in [36].
Figure 3. The error performance of the constructed (925,851) BIBD-LDPC code and the comparable (925,851) 5G-LDPC code in [36].
Entropy 27 00476 g003
Figure 4. An EXIT chart example for the (3,37)-regular LDPC code ensemble.
Figure 4. An EXIT chart example for the (3,37)-regular LDPC code ensemble.
Entropy 27 00476 g004
Table 1. Parameters of BIBD-LDPC codes constructed from a BIBD ( κ , 1 ; υ ) .
Table 1. Parameters of BIBD-LDPC codes constructed from a BIBD ( κ , 1 ; υ ) .
BIBDsBIBD-LDPC Codes
Code LengthRow WeightColumn WeightCode Rate
( 3 , 1 ; υ ) υ ( υ 1 ) / 6 ( υ 1 ) / 2 3 ( 1 6 / ( υ 1 ) )
( 4 , 1 ; υ ) υ ( υ 1 ) / 12 ( υ 1 ) / 3 4 ( 1 12 / ( υ 1 ) )
( 5 , 1 ; υ ) υ ( υ 1 ) / 20 ( υ 1 ) / 4 5 ( 1 20 / ( υ 1 ) )
( 6 , 1 ; υ ) υ ( υ 1 ) / 30 ( υ 1 ) / 5 6 ( 1 30 / ( υ 1 ) )
( 7 , 1 ; υ ) υ ( υ 1 ) / 42 ( υ 1 ) / 6 7 ( 1 42 / ( υ 1 ) )
Table 2. The number of short cycles of BIBD-LDPC codes constructed from a BIBD ( κ , 1 ; υ ) .
Table 2. The number of short cycles of BIBD-LDPC codes constructed from a BIBD ( κ , 1 ; υ ) .
BIBDsCycle Lengths and Numbers of BIBD-LDPC Codes
Length 4Length 6Length 8
( 3 , 1 ; υ ) 0 υ ( υ 1 ) ( υ 3 ) / 6 3 C υ 4 υ ( υ 1 ) ( υ 3 ) / 2
( 4 , 1 ; υ ) 0 υ ( υ 1 ) ( υ 4 ) / 6 3 C υ 4 υ ( υ 1 ) ( 4 υ 15 ) / 4
( 5 , 1 ; υ ) 0 υ ( υ 1 ) ( υ 5 ) / 6 3 C υ 4 3 υ ( υ 1 ) ( 2 υ 9 ) / 4
( 6 , 1 ; υ ) 0 υ ( υ 1 ) ( υ 6 ) / 6 3 C υ 4 υ ( υ 1 ) ( 4 υ 21 ) / 2
( 7 , 1 ; υ ) 0 υ ( υ 1 ) ( υ 7 ) / 6 3 C υ 4 5 υ ( υ 1 ) ( υ 6 ) / 2
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Xu, H.; Zhang, X.; Xu, M.; Yu, H.; Zhu, H. LDPC Codes on Balanced Incomplete Block Designs: Construction, Girth, and Cycle Structure Analysis. Entropy 2025, 27, 476. https://doi.org/10.3390/e27050476

AMA Style

Xu H, Zhang X, Xu M, Yu H, Zhu H. LDPC Codes on Balanced Incomplete Block Designs: Construction, Girth, and Cycle Structure Analysis. Entropy. 2025; 27(5):476. https://doi.org/10.3390/e27050476

Chicago/Turabian Style

Xu, Hengzhou, Xiaodong Zhang, Mengmeng Xu, Haipeng Yu, and Hai Zhu. 2025. "LDPC Codes on Balanced Incomplete Block Designs: Construction, Girth, and Cycle Structure Analysis" Entropy 27, no. 5: 476. https://doi.org/10.3390/e27050476

APA Style

Xu, H., Zhang, X., Xu, M., Yu, H., & Zhu, H. (2025). LDPC Codes on Balanced Incomplete Block Designs: Construction, Girth, and Cycle Structure Analysis. Entropy, 27(5), 476. https://doi.org/10.3390/e27050476

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop