Protograph-Based LDPC Codes

• Protograph-Based LDPC codes are structured error-correcting codes derived from a small bipartite graph (protograph) that is lifted to form larger code ensembles.
• They achieve near-capacity iterative decoding thresholds through techniques like spatial coupling and convolutional extensions.
• Incorporating quasi-cyclic designs and rate compatibility, these codes offer provable linear minimum distance growth essential for reliable digital communications.

Protograph-based @@@@1@@@@ (Low-Density Parity-Check) codes are a class of structured LDPC codes derived from a small bipartite base graph, known as a protograph. This approach enables the construction of code families with rich ensemble properties—such as rate compatibility, capacity-approaching iterative thresholds, linear growth of minimum Hamming distance, and efficient quasi-cyclic (QC) representations—while retaining manageable analysis and flexible implementation pathways. The protograph framework also accommodates spatial coupling and convolutional code generalizations, and admits powerful algebraic and combinatorial tools for detailed performance guarantees and optimization.

1. Foundations of Protograph-Based LDPC Codes

A protograph is defined by a small bipartite graph (base matrix) $B\in\mathbb{Z}_+^{n_c\times n_v}$, where $n_v$ is the number of variable nodes and $n_c$ the number of check nodes; entries can exceed one, indicating multiple edges between node pairs. The protograph ensemble is generated by a “lifting” procedure: each node and edge in the base graph is replicated $N$ times, and the $B(i,j)$ edges are permuted among the $N$ node copies. The full-length code has $n = N n_v$ variables and $(N n_c)$ checks, and the code inherits degree distributions, locality, and (when QC lifting is used) automorphism structure from the protograph.

This structured lifting preserves the ensemble properties of degree distributions and permits exact tracking of message types in iterative decoding, which can be leveraged for performance prediction and optimization (Mitchell et al., 2010, Ranganathan et al., 2017, Chen et al., 2014).

2. Convolutional and Terminated Protograph Codes

Spatially-coupled and terminated convolutional variants are obtained by “edge-spreading”: the base matrix $B$ is written as a sum $B = \sum_{i=0}^{m_s} B_i$ of nonnegative matrices, each $B_i$ corresponding to connections at time offset $i$ and $m_s$ indicating syndrome former memory. The convolutional base matrix is bi-infinite, formed by diagonally stacking the $B_i$'s. A terminated (length $L$) code is constructed by truncating to a banded $B[0,L-1]$ of size $((L+m_s) n_c) \times (L n_v)$. After lifting, the block length is $n = N L n_v$.

The design rate is

$$R_L = 1 - \frac{(L + m_s)n_c}{L n_v} = 1 - \frac{L + m_s}{L}(1 - R),$$

and, as $L\to\infty$, $R_L \rightarrow R = 1 - n_c/n_v$.

Spatially-coupled (SC) and terminated protograph-based codes exhibit iterative decoding thresholds that approach the MAP (maximum a posteriori) threshold of the underlying uncoupled ensemble, a property known as threshold saturation. Degree profiles smoothly interpolate between perfectly regular (bulk) and lower-degree nodes at boundaries, with the precise local irregularities dependent on the choice of $\{B_i\}$ (Mitchell et al., 2010, 0805.0241).

3. Iterative Decoding Thresholds and Capacity Approach

Iterative decoding performance of a protograph code is evaluated through density evolution on the base graph. For the binary erasure channel (BEC) with erasure probability $\epsilon$, the protograph structure allows exact per-edge recursion:

• At each iteration $\ell$, message-erasure probabilities $x_e^{(\ell)}$ on edges $e$ are updated via standard variable-node and check-node rules.

The iterative (belief propagation) threshold $\epsilon_\mathrm{BP}$ is defined as the supremum $\epsilon$ for which $x_e^{(\ell)}\to 0$ as $\ell\to\infty$ for all $e$. For terminated spatially-coupled ensembles, $\epsilon_\mathrm{BP}(L)\to\epsilon_\mathrm{MAP}$ (the MAP threshold of the uncoupled ensemble) as $L\to\infty$. Hence, terminated and SC protograph codes are capacity-approaching under iterative decoding (Mitchell et al., 2010, Pradhan et al., 2013, Chen et al., 2014).

4. Minimum Distance Growth and Ensemble Properties

Protograph-based LDPC codes enable rigorous combinatorial analysis of the minimum Hamming distance. Using average weight enumerators derived from the protograph spectrum, one can show that, for large $n$, typical codes have $d_{\min} \geq \delta n$ for some $\delta>0$, i.e., the ensemble is asymptotically good.

For quasi-cyclic (QC) sub-ensembles (where all liftings are circulant), explicit upper bounds on $d_{\min}$ are available due to the combinatorial structure of circulant matrices (Ranganathan et al., 2017, Mitchell et al., 2010):

$$d_{\min}(C) \leq \min^*_{S\subset \{1,\ldots,n_v\}, |S|=n_c+1} \sum_{i\in S}\mathrm{perm}(B_{S\setminus\{i\}}),$$

where $\mathrm{perm}(\cdot)$ denotes matrix permanent. This bound can be further increased by taking $m$-fold covers of the base protograph (“arrays of circulants”), enhancing the distance for QC liftings.

Explicit edge-spreading (choice of $\{B_i\}$) and careful cover selection can dramatically increase $d_{\min}$—in concrete (3,6)-regular cases, bounds of 30, 56, 176, 210, etc., can be achieved by increasing the complexity of the cover (Mitchell et al., 2010, Ranganathan et al., 2017).

5. Quasi-Cyclic and Rate-Compatible Protograph Codes

QC-LDPC codes result from restricting the lifting permutations to circulants, which provide efficient encoder/decoder implementations and favorable hardware properties. Rate-compatible protograph-based codes, particularly “protograph-based Raptor-like (PBRL) codes,” have an explicit two-part protograph:

• A high-rate “precode” (an LDPC protograph)
• An “LT part” that appends degree-1 variable nodes, increasing redundancy and providing incremental rate steps.

PBRL ensembles enable design across a wide range of rates without sacrificing waterfall performance. Optimization of the base protograph for the minimum-distance upper bound—particularly in the QC sub-ensemble—substantially reduces error floors at short blocklengths, with finite-length codes constructed by QC-lifting and permutation-optimization (e.g., ACE, cPEG) (Ranganathan et al., 2017, Chen et al., 2014).

6. Graph Covers, Local Irregularity, and Advanced Optimizations

Graph covers of the protograph (arrays of circulants) allow the base graph to be “folded” into larger structures, further increasing achievable minimum distance in QC sub-ensembles. Beyond classical regular/irregular designs, local irregularity—where degree variation is introduced within the subgraph induced by a base matrix entry—can be exploited. This reduces decoding thresholds by tuning the local degree distribution without sacrificing the base graph's overall structure (Wüst et al., 23 May 2025).

Finite-length performance is further enhanced by incorporating Markov Chain Monte Carlo (MCMC) algorithms in the design process. The MC$^2$ method uses Gibbs sampling in the space of lifting or partitioning arrangements to minimize the number of detrimental short cycles and absorbing sets, achieving significant reduction in error floors and construction complexity relative to classical deterministic approaches (Tanrıkulu et al., 22 Apr 2025).

7. Design Workflow and Practical Considerations

A canonical design procedure for protograph-based LDPC codes includes:

1. Selection of variable/check degrees $(J,K)$ and syndrome-former memory $m_s$
2. Edge-spreading $\{B_i\}$ to optimize iterative thresholds and minimum distance
3. Termination at length $L$ to arrive at a block code with rate $R_L$
4. Lifting by $N$, restricting to circulant permutations for QC realization if desired
5. If necessary, construction of $m$-fold covers or introduction of local irregularity for further performance gains

The resulting codes combine near-capacity iterative thresholds, provable linear distance growth, and highly efficient QC-friendly encodings. The framework applies uniformly across regular, irregular, and generalized node types, for both block and convolutional settings, and admits extension to joint code-channel designs (e.g., for ISI, BICM) as well as non-binary generalizations (Mitchell et al., 2010, Ranganathan et al., 2017, Wüst et al., 23 May 2025, Tanrıkulu et al., 22 Apr 2025).

---

References:

• (Mitchell et al., 2010)
• (Ranganathan et al., 2017)
• (Chen et al., 2014)
• (0805.0241)
• (Pradhan et al., 2013)
• (Wüst et al., 23 May 2025)
• (Tanrıkulu et al., 22 Apr 2025)