Generalized Z p toric codes as qudit low-density parity-check codes
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: We're looking at the paper: "Generalized Z p toric codes as qudit low-density parity-check codes".
Mira: Here's the gist of the paper. Generalized Zp toric codes as qudit low-density parity-check codes study two-dimensional translation-invariant CSS stabilizer codes over prime-dimensional qudits on the square lattice under twisted boundary conditions, generalizing the Kitaev Zp toric code by augmenting each stabilizer with two additional qudits.
Kai: Using the Laurent-polynomial formalism, we adapt the Gr¨obner basis to compute the logical dimension k efficiently, without explicitly constructing large parity-check matrices.
Mira: We then perform a systematic search over various stabilizer realizations and lattice geometries for p ∈ 5, 7, 11, identifying qudit low-density parity-check codes with the optimal finite-size performance.
Kai: Representative examples include
[242, 10, 22: ]3 and
[120, 6, 20: ]11, both achieving kd p/n = kd p/n = kd p/n = kd p/n = kd p/n.
Title and authors: Kai: So we're looking at this paper now titled "Generalized Z p toric codes as qudit low-density parity-check codes". It's by Zijian Liang and Yu An Chen. Basically, they're taking the Kitaev Zp toric code, which is a well-known thing in topological quantum computing, and generalizing it for prime dimensions of qudits.
Mira: Right. But this paper isn't just taking one step; they are augmenting each stabilizer with two extra qudits. That makes it a generalized version of the Kitaev Zp toric code, which is what we use to understand topological order on a square lattice under twisted boundary conditions.
Lev: So, the core idea here is to build these codes using Laurent polynomials and then use Gröbner basis techniques to figure out the logical dimension k efficiently without building huge parity-check matrices. That's a big computational win if you're trying to design something on actual hardware, because constructing those matrices gets really tough fast.
Kai: That efficiency is key for me when I think about realizing these codes on superconducting qubits. If we can calculate the logical dimension k without those massive matrices, it opens up new avenues for designing better error-correcting codes for our physical systems.
Mira: And they are systematic in their search, testing various stabilizer realizations and lattice geometries for prime dimensions p equal to three, five, seven, and eleven. They are looking for the ones that perform best in terms of finite size performance.
Lev: I see them checking up to a system size n less than or equal to two hundred fifty for p equals three and up to n less than or equal to one hundred fifty for p equals five, seven, and eleven <ref:2602.20158#pg3>. That shows they are actually trying different scales for different qudit dimensions.
Kai: And they found some examples that look really promising, like the code
[two hundred forty-two ten twenty-two: ] three and the code
[one hundred twenty six twenty: ] eleven <ref:2602.20158#pg1>. They both achieve a performance metric of kd to n equal to twenty across those tested cases.
Mira: That performance metric is what they call kd squared over n. And the paper shows that across all the searched regimes, this best observed kd squared value for a fixed n actually increases as p gets larger.
Lev: That's interesting because it suggests that for higher dimensional qudits, you can get better codes at the same physical system size n. They also provide an empirical relation they found: kd squared equals zero point five four one one n squared log p plus three point eight four n.
Kai: That equation looks like a way we can predict the figure of merit for future code designs just by choosing a prime dimension p and a system size n. It gives us something concrete to work with instead of just guessing.
Mira: Exactly, and that relation seems compatible with what we expect from the Bravyi Poulin Terhal tradeoff when the interaction range grows with system size. That means as you make your physical setup bigger, the way you design your code's connectivity can change in a predictable way.
Lev: The paper notes that this compatibility happens when the geometric diameter of those weight six stabilizers can grow with n, depending on the exponents they choose for their Laurent polynomials f and g. That's a nice detail about how geometry plays into the scaling relationship they found.
Kai: So what does all this mean for us in terms of practical implementation? Are we talking about codes that are actually feasible to build right now, or is this more theoretical exploration?
Mira: It's definitely pointing toward things that could be built. They summarize the results in tables covering p equals three, five, seven, and eleven up to those system sizes. These tables highlight the realizations with the most local stabilizers as being representative examples for hardware implementation.
Lev: From an engineering standpoint, having a set of concrete parameters like f(x y) and g(x y) along with the boundary vectors a1 and a2 is really useful for someone trying to start designing a circuit. It gives you something tangible to build from.
Kai: I think the method itself is also pretty powerful because they use that Laurent polynomial formalism and then adapt the Gröbner basis to compute the logical dimension k efficiently, avoiding those giant parity-check matrices we usually have to deal with.
Mira: And that algebraic framework is really neat because it naturally incorporates twisted boundary conditions right into the search process. It lets them characterize these codes without having to construct every single matrix explicitly, which is a huge simplification.
Lev: The limitation they mention is that the primary computational bottleneck for them was distance estimation when the distance d was smaller than twenty six zero two point two zero one five eight hash p g one zero. That's a specific place where their calculation got slow and needed extra work for larger distances.
Kai: So, what does that limitation tell us about where we need to focus our efforts next? It suggests that for even bigger codes, checking those smaller distances could still be the hardest part computationally.
Mira: And they suggest a few things for the future. They say it will be important to extend the search to larger system sizes where even better performance might emerge. And they also point out that assessing these codes under circuit-level noise models and developing efficient logical gate implementations are important next steps.
Lev: I agree with those points. If we can get the enumeration procedure scaled up, say to n less than or equal to five hundred or beyond, then that opens up a lot more possibilities for testing real hardware constraints on these codes.
Kai: So, to wrap this up on "Generalized Z p toric codes as qudit low-density parity-check codes," we've seen they systematically search for high-performing examples across prime dimensions p equals three, five, seven, and eleven. They found concrete instances like
[two hundred forty-two ten twenty-two: ] three and
[one hundred twenty six twenty: ] eleven that achieve a performance metric of twenty <ref:2602.20158#pg1>.
Mira: That performance metric is summarized by the empirical relation kd squared equals zero point five four one one n squared log p plus three point eight four n. This relation gives us a prediction for the figure of merit based on the prime dimension and system size.
Lev: And we've seen that this scaling is compatible with the Bravyi Poulin Terhal tradeoff, which happens when you increase your interaction range with system size. It also means that if you want to build these codes, you need to design your geometry so that those interaction ranges can grow appropriately.
Kai: So the big picture here is that this paper gives us a solid foundation for finding specific qudit low-density parity-check codes, and then it tells us how to predict their performance scaling based on the dimension p and system size.
Mira: And it’s a good piece of work because they provide not just the search results but also a way to think about these systems algebraically, using the Laurent polynomial formalism for characterization.
Lev: We can take those specific parameters from Table V and use them as starting points for building simulations that test the performance under realistic noise models and see if they hold up when we push them toward larger system sizes.
The paper's summary: Kai: So, to wrap up the paper, it’s essentially about taking that standard Kitaev toric code—the Zp version—and making it more complex by adding two extra qudits to every stabilizer you have.
Mira: Right. They’re looking at these codes on a square lattice under twisted boundary conditions and they are checking different prime dimensions for the qudits, specifically three, five, seven, and eleven.
Lev: So what they did was systematically search for the best configurations across those different primes and lattice geometries to find these new qudit low-density parity-check codes that work best in practice.
Kai: They used this Laurent polynomial method instead of building massive parity-check matrices to figure out the logical dimension k, which is a huge computational shortcut.
Mira: And they found some specific examples like the
[two hundred forty-two ten twenty-two: ] three code and the
[one hundred twenty six twenty: ] eleven code that show really good performance across those tested cases.
Lev: The key result they highlighted is this performance metric called kd over n squared, and they found an empirical relationship that looks like kd squared equals zero point five four one one times n squared times log p plus three point eight four times n.
Kai: That equation tells us something really useful for future hardware design; it suggests how the figure of merit scales with the qudit dimension p and the system size n.
Mira: It also links up with what we call a Bravyi Poulin Terhal tradeoff, meaning as you make your physical system bigger, you have to change how much connectivity you allow in your code design to keep things efficient.
Lev: And they note that this scaling is compatible with that tradeoff because the geometric size of those stabilizers can grow with the system size if you pick the right exponents in those Laurent polynomials.
Kai: So, for someone just listening, it means they’ve given us a set of specific code blueprints and a mathematical rule to predict how good those blueprints will be for different hardware setups.
Mira: It moves beyond just finding one good code and gives us a systematic way to search for them based on the dimension of the qudit you want to use.
Lev: The main thing they point out about their work is that while they found some very promising examples, the next big step is checking those performance metrics at much larger system sizes, maybe up to five hundred, and seeing if that scaling relationship holds true then.
The paper's improvements: Mira: So, we've seen how they systematically searched for these qudit codes over prime dimensions three through eleven and found some specific examples that perform well in practice on smaller systems.
Kai: Right. They used this Laurent polynomial method to calculate the logical dimension k without building those huge parity-check matrices, which is a major computational shortcut for us experimentalists.
Lev: And they gave us this empirical scaling relation, where the performance metric kd over n squared looks like zero point five four one one times n squared times log p plus three point eight four times n.
Mira: That formula suggests that as you increase the qudit dimension p, you actually get better results for a fixed system size n.
Kai: That's interesting because it implies we might be able to design codes that are inherently better suited for larger qudits if we structure our lattice and boundary conditions correctly.
Lev: It also connects this scaling to the Bravyi Poulin Terhal tradeoff, which means as you scale up the physical system size n, your code's connectivity needs to adjust in a predictable way to keep it efficient.
Mira: And they point out that this relationship holds because the geometric size of those stabilizers can grow with n if you pick certain exponents in those Laurent polynomials.
Kai: So, for someone just listening, it means they’ve given us a set of specific code blueprints and a mathematical rule to predict how good those blueprints will be for different hardware setups.
Lev: It moves us past just finding one good code and gives us a systematic way to search for them based on the qudit dimension we want to use.
Mira: The main thing they emphasize about their work is that while they found these promising examples, the next big step is checking those performance metrics at much larger system sizes, maybe up to five hundred, and seeing if that scaling relationship holds true then.
Conclusion: Kai: So we've looked at the paper, "Generalized Z p toric codes as qudit low-density parity-check codes," and essentially they found a systematic way to search for high performing qudit quantum error correction codes over prime dimensions three through eleven using Laurent polynomials.
Mira: Right. They used this algebraic method to find specific code structures on a square lattice under twisted boundary conditions and identified some concrete examples like the two hundred forty-two ten twenty-two three code.
Lev: And they provided this scaling relation for the performance metric kd over n squared, which suggests that as you increase the qudit dimension p, you get better results for a fixed system size n.
Kai: That means we have a mathematical tool to predict how good these blueprints will be before we even start building them on actual superconducting hardware.
Mira: It also shows this scaling matches what we expect from the Bravyi Poulin Terhal tradeoff when the interaction range grows with the physical system size n.
Lev: The caveat is that this happens if you choose specific exponents in those Laurent polynomials so that the geometric size of those stabilizers can grow with n.
Kai: So, for someone just listening, it means they've given us a set of specific code blueprints and a mathematical rule to predict how good those blueprints will be for different hardware setups.
Mira: It moves beyond just finding one good code and gives us a systematic way to search for them based on the qudit dimension we want to use.
Lev: The main thing they point out about their work is that while they found some very promising examples, the next big step is checking those performance metrics at much larger system sizes, maybe up to five hundred, and seeing if that scaling relationship holds true then.
Zijian Liang, Yu-An Chen
International Center for Quantum Materials, School of Physics, Peking University
quant-ph, cond-mat.str-el, math-ph, math.MP, math.QA
Submitted: 2026-02-23
Updated: 2026-11-09
Comments: 9+2 pages, 5 figures; v2: typos fixed, figures updated
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 91/100
The gist: Generalized Zp toric codes as qudit low-density parity-check codes study two-dimensional translation-invariant CSS stabilizer codes over prime-dimensional qudits on the square lattice under twisted…
Key concepts
- Generalized Zp Toric Codes
- These are two-dimensional translation-invariant CSS stabilizer codes defined on a square lattice using prime-dimensional qudits (Zp). They generalize the well-known Kitaev toric code by adding extra qudits to each stabilizer, allowing for richer topological properties.
- Laurent Polynomial Formalism
- This mathematical tool uses polynomials in variables like x and y over a ring R = Zp[x ±1, y±1] to define the stabilizers of the codes. This approach allows researchers to efficiently calculate the logical dimension (k) without needing to build massive parity-check matrices.
- Gröbner Basis
- This is an algorithm used in polynomial rings that helps simplify and solve systems of polynomial equations. In this context, it is used to efficiently compute the ideal generated by the stabilizer polynomials, which directly reveals the logical dimension of the code.
- Bravyi–Poulin–Terhal Tradeoff
- This concept describes a relationship in topological codes where performance (like logical dimension) can be improved if the interaction range (how far stabilizers influence each other) is allowed to grow with system size. The paper shows this tradeoff is compatible with their findings.
Terminology
Summary
Generalized Zp toric codes as qudit low-density parity-check codes study two-dimensional translation-invariant CSS stabilizer codes over prime-dimensional qudits on the square lattice under twisted boundary conditions, generalizing the Kitaev Zp toric code by augmenting each stabilizer with two additional qudits. p. 0 Using the Laurent-polynomial formalism, we adapt the Gr¨obner basis to compute the logical dimension k efficiently, without explicitly constructing large parity-check matrices. p. 0 We then perform a systematic search over various stabilizer realizations and lattice geometries for p ∈ 5, 7, 11, identifying qudit low-density parity-check codes with the optimal finite-size performance. p. 0 Representative examples include [[242, 10, 22]]3 and [[120, 6, 20]]11, both achieving kd p/n = kd p/n = kd p/n = kd p/n = kd p/n. p. 0 Across the searched regime, the best observed kd squared at fixed n increases with p, with an empirical relation kd squared = 0. p. 00541 n squared ln p + 3. p. 0 p. 084 n, compatible with a Bravyi–Poulin–Terhal–type tradeoff when the interaction range grows with system size. p. 0
Code Construction and Analysis
The codes are specified by a pair of Laurent polynomials f(x, y) and g(x, y) in the ring R = Zp[x ±1, y±1], which determine the stabilizers of generalized Zp toric codes on twisted tori. The stabilizer group is generated by all lattice translates of Av and Bp, where Av and Bp are defined by these polynomials. p. 1 The topological order condition is satisfied when f(x, y) and g(x, y) are coprime. p. 1 The maximal number of logical qudits on a torus equals the number of independent anyon generators in the underlying topological order. p. 1
Systematic Search and Results
The authors systematically enumerate local stabilizer realizations together with twisted boundary conditions. For p = 3, they search system sizes up to n ≤ n ≤ 250, while for p ∈ 5, 7, 11 they search up to n ≤ n ≤ 150. p. 0 Representative examples include [[242, 10, 22]]3 and [[120, 6, 20]]11 which both attain kd p/n = kd p/n = kd p/n = kd p/n. p. 0
Performance Scaling and Tradeoffs
The best observed kd squared at fixed n increases with p, shown as Fig. 3, and the fit in Fig. p. 0 4 yields the empirical relation kd squared = 0. p. 00541 n squared ln p + 3.84 n. The linear fits in Fig. p. 3 3(a) suggest that the fitted slope of kd 2/n versus n grows approximately as ln p, as summarized in Fig. p. 3 3(b). This superlinear behavior is compatible with the Bravyi–Poulin–Terhal (BPT) bound when the interaction range r increases with system size. p. 3
Conclusion and Future Directions
The work provides a foundation for further theoretical and hardware-oriented investigations by summarizing high-performing instances in Tables I–IV. Future work may extend the search to larger system sizes, where further improvements could emerge. p. 4 It will also be important to assess the performance of these codes under circuit-level noise models and develop efficient logical-gate implementations. p. 4 The enumeration procedure is fully parallelizable, allowing scaling to n ≤ 500 or beyond. p. 4 The primary computational bottleneck is distance estimation for large d <ref:2602. p. 420158#pg10> and verifying the empirical relation (9) at larger n and p. p. 4 The paper concludes by noting that allowing higher-weight stabilizers is another natural direction. p. 4
Table Summaries
The results for qudit LDPC codes over Zp with p = 3, 5, 7, 11 are summarized in Tables I–IV. These tables cover p = 3 with n ≤ n ≤ 250 and p = 5, 7, 11 with n ≤ n ≤ 150. p. 0 p. 0 The tables highlight realizations with the most local stabilizers as representative examples. p. 0 p. 0 Table V lists the resulting code parameters, the defining polynomials f(x, y) and g(x, y), the boundary vectors ⃗a1, ⃗a2, and the corresponding kd p/n values. p. 9 The metric kd 2/n is a convenient summary statistic that combines rate and distance for finite-size comparisons. p. 9
Figure Interpretation
Figure 1(a) shows the Av and Bp stabilizers of the generalized Zp toric codes, parameterized by the Laurent polynomials f(x, y) = 1 + r1x + r2x a y b and g(x, y) = 1 + r3y + r4xy d in Eq. (5), with r1,r2,r3,r4 ∈ Zp ! <ref:2602.20158#pg3>. Figure 1(b) shows a twisted torus embedded in three-dimensional space <ref:2602. p. 120158#pg3>.
Ring Theory Framework
The derivation of Eqs. (6) and (7) for Zp qudits follows directly from the corresponding proofs for the Z2 case established previously <ref:2602. p. 220158#pg4>. The right-hand side of Eq. p. 2 (7) can be evaluated efficiently using a Gr¨obner basis computed via Buchberger’s algorithm <ref:2602. p. 220158#pg4>. The ring-theoretic approach naturally incorporates twisted boundary conditions and, together with Gr¨obner-basis techniques, enables efficient characterization and systematic searches for new qudit LDPC codes. p. 4
Bravyi–Poulin–Terhal Tradeoff
The superlinear behavior in n is therefore compatible with BPT whenever the interaction range r increases with system size. The geometric diameter of the weight-6 stabilizers can grow with n, depending on the chosen exponents in f(x, y) and g(x, y). p. 3 This relaxes the BPT constraint and is consistent with the empirical relation (9). p. 3 The logical dimension k is determined by the anyon algebra and computed as the dimension of the quotient ring R/I, where I = ⟨f(x, y), g(x, y)⟩ is the stabilizer ideal <ref:2602. p. 420158#pg4>.
Appendix A
Appendix A collects representative instances of Z2 bivariate bicycle (BB) codes compiled from Ref. [90] <ref:2602. p. 0 p. 020158#pg2> The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1 ⃗a2 and the metric kd 2/n. p. 9
Table V
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1, ⃗a2 and the metric kd 2/n. p. 9 The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1, ⃗a2 and the metric kd 2/n. p. 9
Figure 2 Interpretation
Figure 2 shows representative stabilizer realizations on twisted tori <ref:2602.20158#pg5>. Figure 2(a) shows X- and Z-stabilizers of the [[242, 10, 22]]3 code with f = 1 − x + x 3y−3 and g = 1 − y + x-4 y (0, 11) and g = 1 + y + xy−4 y−4 <ref:2602. p. 3 p. 320158#pg5>. Figure 2(b) shows X- and Z-stabilizers of the [[120, 6, 20]]11 code with f = 1 + x + x 3y squared and g = 1 + y + xy−3y−4 (0, 6) <ref:2602. p. 3 p. 320158#pg5>.
Figure 3 Interpretation
Figure 3(a) plots the metric kd 2/n versus block length n for p ∈ 5,7,11 together with linear fits for each p. Figure 3(b) shows slopes extracted from the fits in panel (a), plotted against ln(p). p. 4 p. 4
Figure 4 Interpretation
Figure 4 plots the metric kd 2/n for all code instances listed in Tables I–V against (ln p) n for the explored primes p ∈ 2, 3, 5, 7, 11. The solid line is the least-squares linear fit kd 2/n = 0. p. 3 p. 30541 (ln p) n + 3. p. 0 p. 084 with R squared = 0.96.
Table V Summary
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1, ⃗a2 and the metric kd 2/n. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1. p. 9 p. 9 p. 9 p. 9 p. 9 p. 9
Table I–IV Summary
The results for qudit LDPC codes over Zp with p = 3, 5, 7, 11 are summarized in Tables I–IV. These tables cover p = 3 with n ≤ n ≤ 250 and p = 5, 7, 11 with n ≤ n ≤ 150. The tables highlight realizations with the most local stabilizers as representative examples.
Table V Summary (Z2)
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1, ⃗a2 and the metric kd 2/n. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1.
Table V Summary (Z5)
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1.
Table V Summary (Z7)
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1.
Table V Summary (Z11)
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1.
Appendix A Summary
Appendix A collects representative instances of Z2 bivariate bicycle (BB) codes compiled from Ref. [90] <ref:2602.20158#pg2>. Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1, ⃗a2 and the metric kd 2/n.
Figure 2 Summary
Figure 2 shows representative stabilizer realizations on twisted tori <ref:2602.20158#pg5>. Figure 2(a) shows X- and Z-stabilizers of the [[242, 10, 22]]3 code with f = 1 − x + x 3y−3 and g = 1 − y + x-4 y (0, 11) and g = 1 + y + xy−4 y−4 <ref:2602.20158#pg5>. Figure 2(b) shows X- and Z-stabilizers of the [[120, 6, 20]]11 code with f = 1 + x + x 3y squared and g = 1 + y + xy−3y−4 (0, 6) <ref:2602.20158#pg5>.
Figure 3 Summary
Figure 3(a) plots the metric kd 2/n versus block length n for p ∈ 5,7,11 together with linear fits for each p. Figure 3(b) shows slopes extracted from the fits in panel (a), plotted against ln(p).
Figure 4 Summary
Figure 4 plots the metric kd 2/n for all code instances listed in Tables I–V against (ln p) n for the explored primes p ∈ 2, 3, 5, 7, 11. The solid line is the least-squares linear fit kd 2/n = 0.0541 (ln p) n + 3.84 with R squared = 0.96.
Table V Summary (Z3)
Table V lists the resulting code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1. The table reports the code parameters [[n, k, d]] f(x, y) g(x, y) ⃗a1.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
System design for qudit low-density parity-check codes can be optimized by systematically searching over various stabilizer realizations and lattice geometries for prime dimensions p in set p = 3, 5, 7, 11 to identify qudit LDPC codes with optimal finite-size performance.
-
The Laurent polynomial formalism can be adapted to compute the logical dimension k efficiently without explicitly constructing large parity-check matrices by using Gröbner basis techniques on the ring R = Zp[x ±1, y±1].
-
The empirical relation kd2 = 0.0541 n squared ln p + 3.84 n can be used to predict the figure of merit kd2/n across different qudit dimensions p and system sizes n for future code design choices.
-
The performance metric kd2/n can be used as a convenient summary statistic to organize representative instances of codes, highlighting those with the most local stabilizers as being most promising for implementation on qudit hardware.
-
The search procedure can be scaled to n less than or equal to 500 or beyond using clusters or supercomputers because the enumeration procedure is fully parallelizable.
Sources
- Stabilizer Codes and Quantum Error Correction
- Quantum codes on a lattice with boundary
- Coprime Bivariate Bicycle Codes and Their Layouts on Cold Atoms
- Low-Overhead Entangling Gates from Generalised Dehn Twists
- Ambiguity Clustering: an accurate and efficient decoder for qLDPC codes
- Toward Low-latency Iterative Decoding of QLDPC Codes Under Circuit-Level Noise
- Machine Learning Message-Passing for the Scalable Decoding of QLDPC Codes
- SSIP: automated surgery with quantum LDPC codes
- Lowering Connectivity Requirements For Bivariate Bicycle Codes Using Morphing Circuits
- Improved QLDPC Surgery: Logical Measurements and Bridging Codes
- Multivariate Bicycle Codes
- Logical Operators and Fold-Transversal Gates of Bivariate Bicycle Codes
- Single-shot and two-shot decoding with generalized bicycle codes
- Qudit low-density parity-check codes
- Witt Groups and Bulk-Boundary Correspondence for Stabilizer States
- Gauge Color Codes: Optimal Transversal Gates and Gauge Fixing in Topological Stabilizer Codes
- Operator algebra and algorithmic construction of boundaries and defects in (2+1)D topological Pauli stabilizer codes
- Self-dual bivariate bicycle codes with transversal Clifford gates
Related papers
- Fulqrum: a generalized framework for quantum subspace diagonalization
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements
- Barriers to dequantization of near-term molecular electronic structure methods
- BRIDGE: Lazy-Move Compilation for Dual-Species Neutral-Atom Quantum Computers
- Non-Hermiticity of an anomalous superradiant phase