CAMEL-Ensemble Quaternary BP Decoder

• CAMEL-Ensemble Quaternary BP is an advanced decoding method that combines ensemble strategies with GF(4) belief propagation tailored for nonbinary and quantum CSS LDPC codes.
• It employs specialized scheduling and decimation techniques to significantly reduce short cycle-induced error floors in quaternary Tanner graphs.
• The decoder achieves improved error rate performance and high throughput by integrating optimized protograph-based code constructions and layered message-passing algorithms.

The CAMEL-Ensemble Quaternary Belief Propagation (BP) Decoder is a class of decoding architectures and algorithms designed primarily for nonbinary LDPC and quantum CSS LDPC codes. CAMEL leverages ensemble techniques, quaternary sum-product message passing on $\mathrm{GF}(4)$, and tailored scheduling to substantially mitigate error floors caused by short cycles, especially in quaternary Tanner graphs arising in quantum LDPC code constructions. The term “CAMEL” refers both to an ensemble structure used to sidestep problematic cycle patterns and to protograph-optimized code constructions facilitating efficient implementation and high throughput in classical and quantum regimes (Baldelli et al., 13 Jan 2026, Steiner et al., 2019, Miao et al., 2022).

1. Quaternary Belief Propagation Fundamentals

Quaternary BP decoding operates on the Galois Field $\mathrm{GF}(4) = \{0, 1, \omega, \bar{\omega}\}$, directly matching the algebraic structure of Pauli error models (for QLDPC) and higher-order modulation codes (for classical LDPC) (Baldelli et al., 13 Jan 2026, Miao et al., 2022). Each variable node $v$ carries a belief (probability vector or log-likelihood ratio) over possible error symbols $e_v \in \mathrm{GF}(4)$, while each parity constraint (row of the parity-check matrix) enforces a $\mathrm{GF}(4)$ sum condition on its neighborhood.

The sum-product updates involve, at every iteration and edge, a marginalization over all compatible assignments that satisfy the $\mathrm{GF}(4)$ linear constraint, combining incoming messages multiplicatively (or additively in the log domain). Initialization typically incorporates the channel or error-prior likelihood model – e.g., depolarizing error for QLDPC or soft demodulator outputs for classical codes.

For quantum (CSS) codes, BP is performed on a parity-check matrix of the form

$H = [\omega H_X ; \bar{\omega} H_Z],$

where $H_X$, $H_Z$ are binary matrices, and checks have coefficients in $\mathrm{GF}(4)$ depending on the $X/Z$ syndrome constraints (Baldelli et al., 13 Jan 2026). In classical settings with QMP, message alphabets are explicitly quantized, e.g., to four reliability levels (±H, ±L) (Steiner et al., 2019).

2. CAMEL-Ensemble Architecture and Cycle Mitigation Strategy

The main innovation of the CAMEL-Ensemble design is its systematic approach to combating short (especially length-4) cycles, which would otherwise cause destructive correlations and degrade BP performance, notably in quantum Tanner graphs (Baldelli et al., 13 Jan 2026, Miao et al., 2022). The core strategy is ensemble-based: the decoder operates not as a single instance of BP but as a controlled ensemble of BP decoders, each configured to break the cycle structure in a targeted manner.

In the dyadic-matrix CSS construction, the code’s binary components are engineered (via the “CAMEL compatibility condition”) so that all unavoidable 4-cycles are concentrated through a single variable node $v^*$. The CAMEL decoder exhaustively “decimates” $v^*$: it runs four instances of BP, each with $e_{v^*}$ fixed to a different symbol in $\mathrm{GF}(4)$. Each run then operates on a 4-cycle-free subgraph, sharply reducing the risk of trapping sets. The final decoded output is selected among valid candidates by minimal weight (Baldelli et al., 13 Jan 2026).

For ensemble and neural settings, overcomplete check matrices (e.g., stacking low-weight dual codewords as additional check rows) are employed (Miao et al., 2022). The complete set of checks is partitioned into $K$ sub-ensembles, where each micro-iteration only updates a portion, emulating a layered schedule that further diminishes the impact of short cycles.

3. Algorithmic Workflow and Message Passing Equations

The canonical CAMEL ensemble BP operates under a flooding schedule, iterating (up to $T_{\mathrm{max}}$ times) the following update steps (Baldelli et al., 13 Jan 2026, Miao et al., 2022):

• Initialization: For each $v$ and each $a \in \mathrm{GF}(4)$, set $m_{v \to c}^{(0)}(a) = P_{\text{ch},v}(a)$, with $P_{\text{ch},v}$ as determined by the channel/error model.
• Check-to-variable:

$$u_{c \to v}^{(t)}(a) \propto \sum_{\{a_i\}} \mathbb{I}\Big[\sum_{i} h_{c, v_i} a_i + h_{c, v} a = 0\Big] \prod_{i=1}^{d_c - 1} m_{v_i \to c}^{(t-1)}(a_i)$$

• Variable-to-check:

$$m_{v \to c}^{(t)}(a) \propto P_{\text{ch},v}(a) \prod_{c' \in N(v) \setminus c} u_{c' \to v}^{(t)}(a)$$

• Soft decision: Compute marginal beliefs and pick

$\hat{y}_v = \arg\max_a m_v^{(t)}(a)$

Early stopping applies if the syndrome matches.

For ensemble settings: each decoder run uses modified priors (e.g., $P_{\text{ch}}^{(g)}(v^*)(a) = \delta_{a,g}$ for fixed $v^*$) (Baldelli et al., 13 Jan 2026). For overcomplete neural ensemble decoding, log-domain updates and trainable per-node weights are applied (Miao et al., 2022).

4. Code Construction and Compatibility Conditions

CAMEL decoders are tightly coupled to the underlying code design, especially in CSS QLDPC constructions. The CAMEL compatibility condition,

$H'_X (H'_Z)^{T} = 1_{r \times r}$

(working over $\mathrm{GF}(2)$), ensures that the only length-4 cycles remaining in the $\mathrm{GF}(4)$ parity-check graph are those involving the final column. By appending all-ones columns to both $H'_X$ and $H'_Z$, orthogonality is maintained ($H_X H_Z^{T}=0$) while enabling the CAMEL ensemble approach to efficiently decimate the only remaining problematic variable (Baldelli et al., 13 Jan 2026).

Code matrices are constructed by lifting exponent matrices using dyadic permutation matrices (DPMs), and affine row designs guarantee high girth (eliminating 4-cycles within each matrix and guaranteeing controlled overlap across the $X$/$Z$ components). In overcomplete neural ensemble decoders, redundant check rows are synthesized by combining low-weight dual codewords via probabilistic search strategies (Miao et al., 2022).

5. Performance, Complexity, and Implementation

Extensive numerical evidence demonstrates that the CAMEL-enumerative strategy can eliminate or substantially lower logical error rates, especially by removing error floors formerly caused by 4-cycle trapping sets (Baldelli et al., 13 Jan 2026, Miao et al., 2022). In the quantum regime, for codes such as D1 ($n=257$, $R_Q=0.47$), CAMEL approximately matches genie-aided performance by removing the BP4 error floor near $p\approx0.03$. In large codes (D2: $n=1025$, $R_Q=0.57$), CAMEL yields minor further gains as error floors are already rare.

Implementation costs are dominated by per-iteration message passing, with check-node updates scaling as $O(4^{d_c-1})$ (for $d_c\sim 3$–$4$), but practical implementation employs precomputed convolution kernels or FFTs. Memory requirements per edge are modest – two $4$-vector probability messages and channel priors – though running four decoder ensemble instances multiplies total run count by $4$ (Baldelli et al., 13 Jan 2026).

In ensemble/quaternary message-passing decoders for spatially coupled LDPCs, CAMEL supports data flow reduction of $3$–$4\times$ versus conventional $6$–$8$ bit BP. Fully parallel hardware architectures achieve $>\text{Tb/s}$ throughput, with each message exchange quantized to two bits and per-edge memory holding only two real weights ($w_L, w_H$) (Steiner et al., 2019).

6. Extensions: Neural BP and Overcomplete Ensembles

CAMEL methodologies have been extended to neural belief propagation using overcomplete check matrices (Miao et al., 2022). Here, redundant parity checks are introduced, and the set of check updates is cycled through in small subsets (“K-layer” ensemble), implementing a layered micro-scheduling that further randomizes the influence of short cycles. Learnable scalar weights at each node and iteration (optimized via stochastic gradient descent) enable the decoder to model local degeneracies and variance in message reliabilities, yielding up to $2$–$3$ orders of magnitude improvement in frame error rate at practical channel error rates with low decoding latency.

The general workflow is preserved: initialize variable LLRs, perform iterative variable-to-check and check-to-variable updates (with neural weights), and output the best candidate matching the syndrome. Training proceeds in stages, first targeting low-weight error patterns, then fine-tuning on random higher-weight syndromes.

7. Comparative Summary and Guidelines

CAMEL-Ensemble Quaternary BP decoders represent a convergence of code-design-optimized graph structures, ensemble (multi-path) inference mechanisms, and advanced message-passing algorithms (including neural parameterization) to achieve decoder throughput and performance near theoretical BP limits. Design guidelines recommend moderate degree ($d_v=4$), optimized protograph irregularity, fully connected spatial coupling, and DE-optimized weight/threshold choices. In classical high-throughput settings (e.g., 16-QAM/PAS), CAMEL ensemble QMP recovers $>0.7$ dB over binary message passing and approaches full-BP within $0.75$ dB, all with strict internal data-flow and memory efficiency (Steiner et al., 2019).

A plausible implication is that ensemble and overcomplete strategies—when combined with careful code construction—substantially extend the domain of BP-based decoders in both quantum and classical settings, circumventing fundamental graph-theoretic barriers which previously limited their performance (Baldelli et al., 13 Jan 2026, Miao et al., 2022).