---
title: 'QC-LDPC JSCC: Robust Joint Coding'
url: https://www.emergentmind.com/topics/qc-ldpc-based-jscc
type: topic
---

# QC-LDPC JSCC: Robust Joint Coding

Quasi-Cyclic Low-Density Parity-Check (QC-LDPC) code-based Joint Source-Channel Coding (JSCC) encompasses structural, algorithmic, and hardware advances in the implementation of integrated source and channel coding, targeting efficient, robust, and near-capacity communications for next-generation semantic and task-driven services. By leveraging quasi-cyclic LDPC constructions and refined protograph linking, QC-LDPC-based JSCC schemes achieve favorable trade-offs between code rate, encoding/decoding complexity, and error resilience, facilitating deployment in constrained edge devices and latency-sensitive applications [2310.01024][2309.14653].

## 1. Code Construction and Protograph Design

QC-LDPC-based JSCC schemes construct their codes starting from two optimized protograph LDPC base matrices: one for source compression ($\mathbf B_{s1}$) and one for channel protection ($\mathbf B_{c1}$). For example, [2310.01024] uses $50\times90$ base matrices from [Chen et al., IEEE Trans. Commun., 2018], achieving a decoding threshold of $-2.1$ dB. The composite block-structured parity-check matrix is built as:
\[
\mathbf H_{50\times90} = 
\begin{pmatrix}
\mathbf H_{s}(20\times40) & \mathbf H_L(20\times50) \\
\mathbf{0}(30\times40) & \mathbf H_{c}(30\times50)
\end{pmatrix},
\]
with the linking block $\mathbf H_L=[\mathbf 0_{20\times30}\;\mathbf I_{20\times20}]$.

Subsequent two-stage lifting transforms this base to a scalable, hardware-suited QC-LDPC code. Each “1” is replaced by a $z\times z$ circulant permutation matrix (CPM; $z=160$), while “0” entries become all-zero blocks, producing
\[
\mathbf H_{QC} =
\begin{pmatrix}
\mathbf H_{sQC}(3200\times6400) & \mathbf H_{LQC}(3200\times8000) \\
\mathbf{0}(4800\times6400)      & \mathbf H_{cQC}(4800\times8000)
\end{pmatrix}.
\]
The resulting source compression ratio is $R_s=2$, channel code rate $R_c=0.4$, leading to an overall JSCC code rate $R_{\mathrm{overall}}=R_s\,R_c=0.8$. The generator matrix $\mathbf G$ underlying the end-to-end mapping is implicitly realized via the block structure, supporting efficient parity computation and systematic encoding for hardware.

Advances from [2309.14653] employ a double-protograph structure with refined “linking” submatrices. The traditional identity-based SCCV linking is replaced with a lower- or upper-triangular submatrix, $T_{m_s}$, providing design flexibility:
\[
T_{m_s} =
\begin{pmatrix}
1 & 0 & \ldots & 0 \\
t_{2,1} & 1 & \ldots & 0\\
\vdots & \ddots & \ddots & 0\\
t_{m_s,1} & \ldots & t_{m_s,m_s-1} & 1
\end{pmatrix}.
\]
This enables up to $0.41$ dB improvement in channel threshold and $0.5$ dB reduction in source symbol error rate (SSER) at SSER $= 10^{-6}$.

## 2. Encoder Design, Mapping, and UEP

The encoder first maps the semantic source vector $\mathbf s\in\{0,1\}^{6400}$ to a compressed binary sequence via $\mathbf b = \mathbf H_{sQC}\,\mathbf s$, yielding $3200$ bits, which are then encoded by the channel LDPC block to form an $8000$-bit codeword. The overall end-to-end mapping is formalized as:
\[
\mathbf c = f_{\mathrm{JSCC}}(\mathbf s) = \mathrm{LDPC}_c(\mathrm{LDPC}_s(\pi(\mathbf s))),
\]
where $\pi$ is an interleaver. For semantic communication, Unequal Error Protection (UEP) is critical; “critical” source bits (e.g., image keypoints) are strategically positioned through $\pi$ to correspond to variable nodes of higher degree in the parity-check graph, leveraging node degree diversity for stronger protection. De-interleaving follows decoding to restore original bit ordering and UEP.

A double-stage lifting, typically a graph-constrained PEG lift ($z_1$) and a large QC lift ($z_2$), consolidates the design for practical implementation and facilitates circulant-based encoding/decoding.

## 3. Layered Decoding Algorithms and Inter-Module Messaging

QC-LDPC decoding for JSCC systems utilizes a layered sum-product algorithm adapted to the two-subgraph structure of the composite matrix, with iterative message exchange between the source and channel components. The node update schedule follows:
- Variable-to-check update:
  \[
  \beta_{jk} = L_k + \sum_{j'\in M(k)\setminus j} \alpha_{j'k}
  \]
- Check-to-variable update via the min–sum or hyperbolic tangent rule:
  \[
  \alpha_{jk} = 2\,\mathrm{atanh}\left(\prod_{k'\in N(j)\setminus k}\tanh(\beta_{jk'}/2)\right)
  \]
- Inter-decoder messaging (at punctured nodes $N^{sc \leftrightarrow cc}$):
  \[
  I^{sc\to cc}_k = \prod_{j\in M^{sc}(k)} \tanh(\beta_{jk}^{sc}/2)
  \]
A posteriori LLR for bit $k$ is $\ell_k = L_k + \sum_{j\in M(k)} \alpha_{jk}$. Early stopping is triggered on convergence or after maximum iterations, with hard decisions based on LLR sign.

## 4. Hardware Implementation and Quantization

A prototypical hardware realization uses a Xilinx Virtex UltraScale+ FPGA platform integrated with RISC-V and neural network accelerators. The QC-LDPC structure enables a single-group layered decoder configuration ($G_s=G_c=1$) with 20 layers of 160 CNs per subgraph and fully pipelined block-parallel processing per layer.

The decoder data path is quantized to 6-bit fixed-point (“Proposed-Q6”), replacing floating-point arithmetic. Small LUTs approximate the $\tanh$ function, further reducing complexity. Additional parity bits are used to mitigate performance losses due to quantization. The entire decoder occupies $\sim$33% of LUTs and FFs, only 1.4% of BRAMs, and achieves an iteration of the full layered schedule in 31 ms at 100 MHz clock frequency [2310.01024].

In the encoding process, the sequential XOR operations corresponding to the triangular linking structure ensure linear complexity in the source block length ($O(N_s)$), enabling scalable and high-throughput realization [2309.14653].

## 5. Performance and Comparative Analysis

Quantitative evaluation of QC-LDPC JSCC demonstrates robust BER performance over AWGN, with the 6-bit (“Proposed-Q6”) and floating-point (“Proposed-FP32”) implementations exhibiting comparable curves within 0.2–0.3 dB separation at code rate $R=0.8$ and frame length $N_c=8000$. At low SNR ($-2$ to $0$ dB), throughput and robustness significantly surpass separate source-channel coding (SSCC) baselines, which require lower code rates ($R\leq0.5$) to maintain similar BER. Representative performance summary (SSER at $10^{-6}$) is provided below for the triangular-linking double-protograph design [2309.14653]:

| Example   | Rate $R$ | $(E_s/N_0)_{\rm trad}$ | $(E_s/N_0)_{\rm opt}$ | $\Delta$ Threshold |
|-----------|----------|------------------------|-----------------------|-------------------|
| Ex. 1     | 1        | $-5.127$ dB            | $-5.267$ dB           | $+0.14$ dB        |
| Ex. 2     | 2        | $-9.324$ dB            | $-9.734$ dB           | $+0.41$ dB        |
| Ex. 3     | 1        | $-0.653$ dB            | $-0.840$ dB           | $+0.19$ dB        |

A comparison with AR4JA-JSCC and AR3A-JSCC codes indicates that the optimized triangular-linking double-protograph construction can achieve or surpass their threshold and error floor performance while delivering lower encoding complexity [2309.14653].

## 6. Design Guidelines, Trade-offs, and Future Prospects

Designers balance channel threshold and encoding complexity primarily through the choice of linking structure ($I_{m_s}$ vs $T_{m_s}$), size of lifting parameters ($z_1$, $z_2$), and detailed configuration of non-diagonal entries in $T_{m_s}$. The introduction of a triangular linking matrix introduces only a minimal complexity rise but yields substantial threshold gains up to 0.41 dB, making this trade-off favorable for high-reliability, real-time systems.

Future research directions identified in [2310.01024] include:
- Collaborative edge-AI JSCC parameter tuning using federated learning and semantic feedback.
- Integration of binarized neural semantic encoders with QC-LDPC to reduce edge device power budget.
- Hybrid models combining data-driven deep-JSCC and QC-LDPC structure for adaptive, end-to-end learning.
- Security and privacy analyses: UEP JSCC robustness against eavesdropping, differential privacy, and adversarial manipulation.

QC-LDPC-based JSCC thus underpins scalable, UEP-capable, low-latency coding and decoding frameworks, anticipated to serve as a foundation for 6G semantic communications, federated inference, and other emerging task-oriented wireless systems [2310.01024][2309.14653].

Source: https://www.emergentmind.com/topics/qc-ldpc-based-jscc