A Two-Branch Finite-Field Construction for Regular CSS LDPC Bases

Abstract: This paper develops a two-branch multiplicative-coset construction for regular Calderbank-Shor-Steane (CSS) quantum low-density parity-check base matrices. For a target column weight (J) and an even row weight (L), the method reduces regularity, CSS orthogonality, and same-type 4-cycle exclusion to explicit quotient-coset conditions over a finite field. A normalized exhaustive search for these conditions produces base matrices for several ((J,L)) pairs, so the construction is not tied to a single degree distribution. The construction separates the finite-length design into two stages: the base matrix fixes the degree distribution and the first girth constraints, and a cyclic lift randomizes edge connections subject to exact algebraic checks. As a detailed example, we carry one ((3,10))-regular base through the lift and decoding stages. For this example, the selected 64-fold lift gives a code whose same-type Tanner graphs have girth at least eight, and it also excludes a specified weight-16 nondegenerate logical-support orbit. The resulting instance is a ([[10240,4108,\,10\le d\le32]]) CSS code. For decoding, we use joint log-domain belief propagation together with low-complexity deterministic post-processing rules for small residual syndromes, including repairs for residual patterns with two unsatisfied checks. The frame error rate (FER) measurements provide finite-length decoding data for this detailed example; at depolarizing probability (p=0.058), the post-processing FER is (1.0\times10^{-7}).

• The paper introduces a two-branch finite-field method to construct regular CSS LDPC bases with validated orthogonality and exclusion of short cycles.
• It employs a two-stage process separating base matrix design and cyclic lift to control degree distributions, enforce girth constraints, and eliminate low-weight logical operators.
• Finite-length simulations on a 64-fold lift instance demonstrate robust decoding performance with blocklength 10240 and an FER of 1.0×10⁻⁷ at a depolarizing probability of 0.058.

Two-Branch Finite-Field Construction for Regular CSS LDPC Bases: Summary and Analysis

Motivation and Context

The paper "A Two-Branch Finite-Field Construction for Regular CSS LDPC Bases" (2605.23894) addresses the explicit construction of regular Calderbank–Shor–Steane (CSS) quantum low-density parity-check (LDPC) codes at finite block lengths. The work is situated within a broader context where quantum LDPC codes, and CSS codes specifically, are constrained by orthogonality and the exclusion of short cycles, which complicate the design of sparse-graph codes compatible with iterative decoding protocols. The main contribution is a two-branch finite-field-based combinatorial approach for constructing regular CSS LDPC base matrices, enabling systematic control over degree distributions, girth, and feasible lifts for large-scale code instances.

Two-Branch Finite-Field Base Construction

The construction leverages finite fields and their multiplicative subgroups to generate base matrices for LDPC codes. The two-branch structure is used to enforce CSS orthogonality: each branch contributes incidence patterns to the base matrices, and explicit coset conditions ensure that commutative requirements and same-type cycle exclusion are satisfied. The method can handle various $(J, L)$ pairs (column weight $J$, row weight $L$), and the key certificates reduce the intricate conditions for regularity, orthogonality, and cycle exclusion to finite coset feasibility tests.

This approach separates the construction into two design stages:

1. Base Matrix Design: Fixes degree distributions and imposes girth constraints via combinatorial and algebraic choices over the finite field.
2. Cyclic Lift: Implements randomness in edge connections by assigning cyclic permutation matrix (CPM) lifts, subject to further algebraic congruence constraints that protect girth and exclude low-weight logical operator candidates.

Algebraic Certification and Explicit Search

The structural design is anchored in algebraic certificates:

• Regularity is ensured by the choice of field and subgroup.
• CSS Orthogonality and same-type 4-cycle exclusion are certified via quotient-coset conditions and reduction to difference orbits under subgroup action.
• Feasibility of coefficient choices is resolved by normalized exhaustive search, exploiting translation and scaling symmetries in the field.

This process produces a range of base matrices for diverse $(J, L)$ pairs, as documented with explicit coefficient examples and binary rank computations. These bases are not limited to a single degree distribution, demonstrating broad applicability.

Lift Constraints and Finite-Length Optimization

For the primary example—a $(3,10)$-regular base with a 64-fold CPM lift—the procedure applies additional congruence constraints:

• CSS orthogonality post-lift is guaranteed by equating CPM exponents across shared row-column pairs.
• Exclusion of same-type lifted 6-cycles is enforced by ensuring nonzero congruence sums for all base 6-cycles.
• Avoidance of weight-16 logical operators is achieved by prohibiting closure in the lift of certain low-weight base-column orbit patterns (using subgroup coset exclusion in the CPM exponent assignments).

These constraints are managed via a finite satisfaction problem, solved through randomized and deterministic search, and directly verified for the constructed instance.

Distance Certification and Decoding

The minimum distance interval for the constructed code is established through rigorous enumeration techniques:

• Complete support enumeration for logical operators below weight $D$ provides a certified lower bound.
• Explicit logical witnesses constructed via subgroup-based supports yield a certified upper bound.

For the $(3,10)$-regular code with blocklength $N = 10240$, parameters $[[10240,4108,10 \le d \le 32]]$ are realized, with no nontrivial logical representative below weight 10 and explicit logical representatives at weight 32.

Decoding is implemented via joint log-domain Belief Propagation (BP) in the CSS factor-graph formulation, supplemented by deterministic low-complexity post-processing rules for small residual syndromes. The decoder does not utilize global low-weight syndrome solvers or post-hoc logical corrections in the frame error rate (FER) measurements.

Numerical Results and Performance

Finite-length simulation for the constructed code yields strong decoding performance. At depolarizing probability $p=0.058$, the post-processed FER is $J$0. The decoding curve is plotted against both the quantum hashing bound and a BP density-evolution reference for the regular $J$1 ensemble.

Figure 1: FER of the 64-fold lift for $J$2 CSS code. The hashing line is the depolarizing-channel quantum hashing bound for effective rate $J$3. The DE line is an approximate BP density-evolution reference for the regular $J$4 ensemble.

Empirically, no logical error event with weight below 32 is observed, and the minimum distance is consistent with the certified upper bound, although the rigorous bound remains $J$5.

Implications and Future Directions

The two-branch finite-field framework enables systematic finite-length design of regular CSS LDPC bases, with controllable degree distributions and rigorous algebraic exclusion of short cycles and specified low-weight logical operators. The separation of base and lift constraints simplifies the certification of properties needed for iterative decoding, allowing for reproducible finite-length studies of quantum LDPC codes.

Several directions are anticipated:

• Construction of bases with girth at least eight at the base stage, obviating the need for extensive congruence exclusion in the lift.
• Expansion beyond finite fields to more general modules or groups, leveraging orbit-based certificate techniques.
• Application to larger-scale codes with systematically certified minimum distance and error floor properties.
• Integration with more advanced decoder architectures focusing on degeneracy and quantum error correction thresholds.

The rigorous algebraic approach, combined with explicit finite search and decoding experiment, offers a pathway towards robust, performance-characterized quantum LDPC code instances relevant for both theoretical studies and practical quantum error correction deployments.

Conclusion

The paper establishes a formal, algebraic, and combinatorial protocol for constructing regular CSS LDPC bases over finite fields, offering explicit certificates for regularity, orthogonality, and cycle exclusion. For detailed finite-length examples, rigorous exclusion of low-weight logical operators and strong numerical decoding results are provided. The framework articulates a reproducible construction path and proposes further extensions in both algebraic structure and decoder sophistication, foreshadowing scalable finite-length quantum LDPC designs (2605.23894).