Disassembling qLDPC codes for depth-optimal parity-check circuits

arXiv:2608.19917 · quant-ph · Submitted 2026-08-20 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Disassembling qLDPC codes for depth-optimal parity-check circuits".

Mira: Quantum low-density parity-check (qLDPC) codes are promising for scalable fault-tolerant quantum computing, but their practical implementation requires efficient syndrome extraction circuits.

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So, we're looking at this paper titled "Disassembling qLDPC codes for depth-optimal parity-check circuits," and the authors are Minh T. P. Nguyen, Maximilian Rimbach-Russ, and Stefano Bosco from QuTech at Delft University of Technology. It sounds like they're tackling a fundamental issue in quantum hardware design: how to build efficient syndrome extraction circuits for qLDPC codes that actually work in practice.

Mira: That title really tells you the core idea is about finding a way to simplify the problem by breaking down the code structure first, which is something we always appreciate when looking at complex stabilizer codes. It suggests they're not just applying heuristics but are looking for a structural reason to make things simpler.

Lev: From a hardware perspective, that means if this works, it could translate directly into much less CNOT depth for the circuits we need to run on real quantum hardware, which is exactly what we're aiming for in fault-tolerant systems. It moves the problem from a general scheduling nightmare to something more manageable.

Kai: Exactly Lev; the implication is that we can design circuits based on the code's construction rather than just brute-forcing a schedule over every single edge, which seems much more practical for experimentalists like myself.

Mira: I think what's interesting about their approach is using those symmetries inherent in how qLDPC codes are constructed to quotient them down into a much smaller instance before lifting the solution back to the full code structure. It’s a way of imposing structure where it already exists.

Lev: That structural exploitation is key; if they can get an analytical construction for codes like Lifted Product or Balanced Product, that gives us a solid benchmark for what's achievable in terms of depth bounds.

The paper's summary: Kai: So, the paper summarizes how they reverse the code construction process by identifying edge symmetries and partitioning the edges into classes with shared time labels, which lets them reduce a full scheduling problem to a much simpler graph. It seems like they are essentially finding shortcuts through the complexity of assembling these large codes.

Mira: That reduction step is powerful because it’s not just about simplifying the graph size; it's about transforming the constraints—those two restrictions on time labels, equation (one) and equation (two)—into a manageable set for that reduced graph structure <ref:2608.19917#pg1>. It shows how symmetry quotienting directly helps satisfy those properness constraints more easily.

Lev: For us in error correction, that means if they can find a valid schedule on this reduced graph, we know it will automatically translate into a valid circuit on the full Tanner graph TC without needing extra checks for every single edge interaction.

Kai: And for the Quantum Tanner codes specifically, they’ve shown that by choosing specific orientations for rows and columns in their algebraic setup, they can construct a schedule that automatically satisfies the properness constraint without any hard searching involved.

Mira: That finding regarding the Quantum Tanner codes is quite telling; it suggests that some code families have an inherent structure that makes scheduling trivial once you set up the initial algebraic conditions correctly, which is a deep theoretical insight into those specific code constructions.

Lev: If they can prove this holds for codes up to nearly six hundred data qubits, then for real hardware implementation, we have a very strong indication that these types of codes are not just theoretically interesting but practically viable for large-scale systems <ref:2608.19917#pg0,codes up to nearly 600 data qubits>.

The paper's improvements: Kai: The paper points out several improvements, particularly how they derive analytically optimal constructions for Lifted Product and Balanced Product codes, giving us a provably optimal or near-optimal CNOT depth based on the parameters of the code construction. That analytical result is what really stands out to me as a concrete achievement.

Mira: I agree; getting an analytical construction instead of just a heuristic one means we have a mathematical guarantee on the circuit depth for those code families, which gives us much more confidence in scaling up our hardware designs. It moves us from hoping it works to knowing exactly how deep it will be.

Lev: For Lifted Product codes, they derived a sandwich structure consisting of three time bands: an early band E, a middle band M, and a late band L, which leads to a total depth calculation that is optimal when at least one of the code parameters A or B is even. That specific structural insight into the time bands is what we need to know when designing the physical layout of the circuit.

Kai: That structural description of time bands sounds very useful for physical implementation; it tells us how to lay out the CNOT layers spatially, which is crucial for minimizing crosstalk and optimizing hardware connectivity.

Mira: And they also show that by imposing a stronger condition on the properness constraint—specifically that each summand vanishes independently in the LP case—they arrive at this three-band structure, which is a more robust way to ensure correctness than just meeting the basic constraints.

Lev: The paper notes a limitation, though; it mentions that for Lifted Product codes, this optimal depth is achieved specifically when at least one of A or B is even, so we can't claim universal optimality across all parameter choices for those specific codes.

Conclusion: Kai: So to wrap up, the main point of "Disassembling qLDPC codes for depth-optimal parity-check circuits" is that by quotienting the symmetries inherited from code construction, they can design low-CNOT-depth circuits for CSS qLDPC codes that are analytically optimal or near-optimal for specific families.

Mira: That’s right; the paper demonstrates a methodology where structural analysis and symmetry quotienting lead to reduced scheduling problems that yield analytically derived optimal depths for Lifted Product and Balanced Product codes, while showing depth-optimal circuits for Quantum Tanner codes up to six hundred data qubits <ref:2608.19917#pg0,for Lifted Product and Balanced Product codes>.

Lev: For me, the biggest implication is that this research provides a rigorous method to bridge the gap between theoretical qLDPC code construction and actual physical circuit design by providing verifiable depth bounds and optimal scheduling techniques we can use as a foundation.

Kai: And for experimentalists like myself, it means we have a blueprint for designing hardware control sequences that are significantly leaner than what we'd get from an exhaustive search approach, especially when dealing with larger codes.

Mira: It really highlights how the underlying algebraic structure of good qLDPC codes dictates the difficulty and eventual solvability of their scheduling problems, which is a very deep connection between algebra and physics.

Lev: In short, this paper offers a structured way to tackle the problem of efficiently implementing these powerful codes on real quantum hardware by leveraging inherent code symmetries to get provably better circuit depths for LP codes and excellent results for QT codes.

Kai: It’s a solid piece of work that gives us a clear path forward for designing more efficient quantum error correction circuits based on these promising qLDPC codes.

Mira: Indeed, it shows the power of exploiting the symmetry quotienting technique to simplify complex scheduling problems into something tractable and analytically solvable, which is really elegant work.

Lev: We'll keep an eye on how this methodology gets applied in actual hardware prototypes as we look for that tangible reduction in gate count.

QuTech and Kavli Institute of Nanoscience, Delft University of Technology

quant-ph

Submitted: 2026-08-20

Updated: 2026-10-04

Comments: 20 pages, 5 figures, 2 Tables. Supplementary Material and GitHub updated

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 91/100

The gist: Quantum low-density parity-check (qLDPC) codes are promising for scalable fault-tolerant quantum computing, but their practical implementation requires efficient syndrome extraction circuits.

Key concepts

Edge Partition P
This is an equivalence relation defined on the edges of the code's Tanner graph. Edges that are related by the same construction operation are assigned identical time labels. This step simplifies the full scheduling problem by grouping related edges together, allowing for a more manageable reduction before lifting back to the final code structure.
Properness Constraint
This constraint ensures circuit correctness by preventing errors from propagating across data qubits during syndrome extraction. It requires that operators acting on ancilla qubits are restricted to their specific support, mathematically ensuring that certain time labels for X and Z operators do not interfere with each other on shared data qubits.
Group Lift (for LP codes)
For Lifted-Product codes, this operation is used to analyze the code's structure. It collapses the group coordinate in the graph, simplifying the edge structure into a 'TA □ TB' form. This simplification allows researchers to derive an optimal three-band time schedule (Early, Middle, Late) that minimizes circuit depth.
Quantum Tanner (QT) Codes
These codes are analyzed using an algebraic view based on embedding classical codewords onto a left-right Cayley complex. The assembly involves base CSS codes followed by group lifts. By choosing specific orientations for the rows and columns, the authors construct a schedule that automatically satisfies the properness constraint, achieving depth-optimal circuits.

Terminology

Summary

Quantum low-density parity-check (qLDPC) codes are promising for scalable fault-tolerant quantum computing, but their practical implementation requires efficient syndrome extraction circuits. This work introduces a strategy to design low-CNOT-depth interleaved parity-check circuits for CSS qLDPC codes by exploiting the underlying symmetries inherited from their construction, thereby reducing the problem complexity.

The gist

This work introduces a strategy for constructing low-CNOT-depth interleaved parity-check circuits for CSS qLDPC codes by quotienting the symmetries inherited from their construction and reducing the problem to a much smaller instance.

Disassembling qLDPC codes

The core idea is to reverse the code construction operations by quotienting the graph edge symmetries, which imprints specific structures on Tanner graphs. The process involves:

  1. Identifying explicit operations (e.g., hypergraph products or group lifts) that assemble a code from smaller components, resulting in a sequence of transformations from a base graph T0 to the final Tanner graph TC (Equation 4).

  2. Defining an edge partition P as an equivalence relation on the edge set E where edges related by the same construction operation are assigned identical time labels: e1, e2 ∈ ⟨e⟩P ⇒ τ (e1) = τ (e2) (Equation 5).

  3. Choosing a sequence of partitions, denoted as a sequence of operations P1 through PN, that reverses the code-construction steps: T0 ←−−− P1 T1 ←−−− · · · PN TC (Equation 6).

  4. This process transforms the full scheduling problem into a reduced and significantly simpler graph, allowing for an efficient solution before lifting the result back to TC.

Scheduling parity-checks

The syndrome extraction circuit is formulated as a jobscheduling problem where each edge e in E is assigned a time label τ(e) specifying the CNOT layer. Two critical restrictions must be satisfied for a valid circuit:

  1. Edges sharing a vertex must carry distinct time labels: τ (e1) ≠ τ (e2) if e1 ∩ e2 ≠ ∅ (Equation 1).

  2. The properness constraint, which prevents contamination, requires that the X-operator on an ancilla vx propagates only to the data qubits in its support: Xvx → Xvx ⊗ supp(vx), and analogously for a Z-operator on vz. This is mathematically expressed as: "τ (vx−vq) < τ (vz−vq) ≡ 0 (mod 2)" for shared data qubits (Equation 2).

Lifted Product codes

For Lifted-Product (LP) codes, the structure is analyzed through a group lift operation. The parity-check matrices are defined using left and right lifts of protographs A and B: HX = L(A ⊗ InB) R(InA ⊗ B) (Equation 8a). The group lift imposes an equivalence relation Plift that collapses the group coordinate, simplifying the edge structure to TA □ TB (Equation 10). By imposing a stronger condition on the properness constraint, specifically that each summand vanishes independently, the authors derive a sandwich structure of three time bands: Early band (E) - Middle band (M) - Late band (L) (Equation 13). This leads to a total depth of ∆A + 2⌈∆B/2⌉, which is optimal when at least one of ∆A or ∆B is even.

Quantum Tanner codes

Quantum Tanner (QT) codes are analyzed using an algebraic viewpoint based on embedding classical codewords on a left-right Cayley complex. The code assembly follows a two-step pattern involving base CSS codes and group lifts: C0,C1 C′0,C′1 ⊗−−→ T (base) QT G-lift−−→ TQT (Equation 16). The group lift imposes an edge partition Plift that collapses the group coordinate, leading to a properness constraint that depends only on the classical codes Cc and C′c: "X j∈Srow 1 τ r X0(i, j) < τ r′ Z1(i, j) ≡ 0 (mod 2)" (Equation 21). By choosing specific orientations for rows and columns, the authors construct a schedule that automatically satisfies this constraint. Applying this strategy to codes up to nearly 600 data qubits using a CP-SAT solver results in depth-optimal circuits, saturating the lower bound ∆.

Conclusion

The framework successfully constructs low-CNOT-depth interleaved parity-check circuits by leveraging algebraic structure and symmetry quotienting. The approach yields analytically optimal circuits for LP codes and numerically optimal results for QT codes, demonstrating that the underlying algebraic structure of good qLDPC codes can significantly simplify the syndrome extraction scheduling problem.

Improvements for AI systems

Based on the provided scientific paper, here are specific improvements that could be made to AI systems, leveraging the concepts presented in this research:

  1. The core contribution is a methodology for constructing low-CNOT-depth syndrome-extraction circuits for Quantum Low-Density Parity-Check (qLDPC) codes by exploiting structural symmetries inherited from their explicit constructions (like hypergraph products or group lifts).

  2. The paper demonstrates that disassembling the code by quotienting these symmetries and solving the resulting reduced scheduling problem yields depth-optimal circuits for Lifted Product (LP), Balanced Product (BP), and Quantum Tanner (QT) codes.

Here are specific improvements to AI systems:

  1. AI-driven circuit design for quantum error correction:

  2. The improved system can automatically generate syndrome extraction circuits for large qLDPC codes up to nearly 600 data qubits with provably optimal or near-optimal CNOT depth, significantly reducing the hardware complexity and gate count required for fault-tolerant quantum computation.

  3. AI-driven code structure exploitation:

  4. The system can analyze the explicit construction operations (e.g., hypergraph products, group lifts) that define a qLDPC code and automatically determine the optimal edge partition (symmetry quotient) to simplify the syndrome extraction scheduling problem, allowing for rapid discovery of low-depth circuits without exhaustive search.

  5. AI-driven constraint satisfaction solver for scheduling:

  6. The system can solve the reduced parity-check scheduling problem (an edge-coloring or related constraint satisfaction problem on a simplified Tanner graph) to find the exact time labels (CNOT layers) that satisfy all properness constraints, guaranteeing a valid, low-depth circuit.

  7. AI for exploring decoder performance:

  8. By leveraging the relationship between interleaved circuits and their non-interleaved counterparts (using circuit distance bounds), the system can efficiently screen potential schedules to identify those that minimize overall circuit distance, leading to more robust decoding algorithms for BP-OSD decoders.

In summary, the improved AI system would transition from a general quantum simulation/design tool to a highly specialized, structure-aware optimizer capable of generating physically realizable quantum hardware control sequences (syndrome extraction circuits) with guaranteed minimal gate depth based on the underlying mathematical structure of the chosen error-correcting code.

Sources

Related papers