Kenta Kasai

Q. What is the high-level design philosophy behind your code construction method?

A: We first construct a code, decode it, and observe the decoding failures. From those failures, we infer the algebraic and graph-theoretic structures of the code that caused them. We then modify the construction so that those harmful structures do not appear. By repeating this process, we gradually find better codes. The same philosophy applies to decoding algorithms: we observe decoding failures and listen to what the code is telling us. Decoding failures are extremely valuable, so it is important to look not only at superficial error-rate numbers, but also at the structure of the errors.

Q. What do you mean by the “orthogonality barrier” in binary CSS LDPC codes?

A: The commutativity condition \(H_X H_Z^{T} = 0\) is essential, but enforcing it directly at the level of sparse regular binary parity-check matrices severely restricts edge placements. This tends to introduce many short cycles (especially 4- and 6-cycles), which reduces girth and hurts distance and BP performance. In our framework, the construction uses latent matrices that provide design freedom together with parent matrices, and orthogonality is enforced only on the active matrices (not on the parent matrices themselves). By controlling commutativity on the active part, we retain regularity while avoiding short cycles and achieving larger girth.

Reference: arXiv:2601.08824

Q. Can you construct shorter block-length codes to obtain convincing lower bounds on distance?

A: This is a very reasonable concern. At very long block lengths, it is often difficult to obtain solid lower bounds, and relying only on upper bounds can make it hard to judge how much the construction helps. Shorter instances would make it easier to compute convincing lower bounds and verify whether the distance is genuinely improved.

The latest arXiv version includes a brief discussion of an idea to relax some construction constraints to target shorter block lengths while aiming to keep girth 8 and (hopefully) minimum distance 48: arXiv:2601.08824.

Reference: arXiv:2601.08824

Q. How do you obtain large girth in the binary construction?

A: Avoiding only 4-cycles is not sufficient to unlock strong BP performance, so we also eliminate 6-cycles. As discussed in arXiv:2601.08824, in generalized Hagiwara-Imai codes with column weight \(\ge 3\), 8-cycles cannot be avoided, so girth 8 is the practical target in our setting.

Reference: K. Kasai, “Breaking the Orthogonality Barrier in Quantum LDPC Codes,” arXiv:2601.08824, 2026

Q. Why choose a \((3,12)\)-regular design?

A: In density-evolution benchmarks, column weight 3 is the best-performing choice. Row weight 12 is the smallest value achievable by our proposed construction, so \((3,12)\)-regular is a natural design point.

Reference: arXiv:2601.08824

Q. Why is the decoding performance high even though the row weight is large?

Looking only at the row weight can be misleading, because BP decoding performance is not determined by row weight alone. In the \((3,12)\)-regular design, the column weight is kept at 3, so the local information flow around variable nodes remains favorable. Moreover, by eliminating 4-cycles and 6-cycles and targeting girth 8, the early BP messages are closer to the tree-like behavior assumed by density evolution. In other words, in the ideal-syndrome model, the waterfall performance is governed primarily by the DE threshold together with finite-length effects.

Row weight 12 is large in the sense that each check node touches many variables, but it is also the design point that realizes rate \(R=1-2\cdot3/12=1/2\). Keeping a high rate requires fewer checks relative to the number of variables, which naturally increases the row weight. The key is not merely to lower the row weight, but to control the placement so that the larger checks do not create many short cycles or harmful low-weight structures.

The decoder also matters. The joint BP decoder used in the experiments does not decode the \(X\) and \(Z\) components independently; it preserves the local correlation of Pauli errors at each qubit. Residual trapping-cycle errors are then corrected by lightweight post-processing. Thus the observed performance comes from the combination of girth, degree distribution, correlation-preserving decoding, and post-processing.

Of course, row weight 12 is also a disadvantage for syndrome-extraction circuits. A high-weight check touches many qubits, so measurement faults and circuit faults can accumulate and increase the effective noise seen by the decoder. The current interpretation is that the \((3,12)\)-regular LDPC code has sufficiently strong ideal-decoding performance, as predicted by DE and observed with joint BP, to more than compensate for this disadvantage in the regimes studied. Therefore, a circuit-level evaluation must balance the extra noise caused by larger checks against the stronger decoding capability of the code itself.

Reference: arXiv:2601.08824, arXiv:2605.05132

Q. Is it enough to design quantum codes by importing classical LDPC constructions?

No. Classical LDPC theory provides powerful design principles, such as degree distributions, girth, density evolution, and minimum-distance heuristics, but quantum error correction has additional constraints. A quantum CSS code must satisfy the orthogonality condition \(H_XH_Z^{\mathsf T}=0\). It must also support syndrome-extraction circuits, tolerate measurement errors, solve a space-time decoding problem involving both data and measurement faults, and fit the interaction structure available on the target hardware.

Thus the goal is not to transplant a classical LDPC construction unchanged into the quantum setting. The useful strategy is to start from the good local structure and BP-threshold intuition of classical LDPC codes, and then redesign the code around CSS orthogonality, avoidance of low-weight logical operators, decoder structure, implementable syndrome extraction, and performance under circuit-level noise. In this sense, classical coding theory is an important benchmark, but practical qLDPC design is a different co-design problem involving the code, the implementation, and the decoder.

For example, arXiv:2601.08824 aims to keep classical-LDPC-like large-girth structure while handling CSS orthogonality and avoiding harmful low-weight structures. In arXiv:2604.16209, the design is evaluated in a more implementation-oriented setting, including syndrome extraction on reconfigurable atom arrays, atom-rearrangement constraints, a hierarchical decoder, and a circuit-level noise model. The basic philosophy is therefore to use the strengths of classical LDPC design, while adapting the code to the circuit, noise, and decoding constraints required for quantum computation.

Q. What decoding method is used in the binary experiments?

A: The baseline decoder is joint belief propagation (joint BP). CSS syndrome decoding is written as a factor graph in which the \(X\)- and \(Z\)-side Tanner graphs are coupled by the local joint prior at each qubit, and the sum-product algorithm is run on this factorization. This lets BP retain the local correlation between the two Pauli error components instead of decoding them separately.

In the experiments, this joint BP decoder is combined with lightweight post-processing. In particular, we apply PP-flip and PP-OSD to correct residual trapping-cycle errors, improving the low-FER regime without heavy complexity.

Reference: arXiv:2601.08824, arXiv:2605.05132

Q. What does the notation \([[9216,4612,\le 48]]\) indicate?

A: The “\(\le 48\)” indicates an upper bound on the minimum distance. This bound is derived from a potential (latent) matrix associated with the construction. Obtaining convincing lower bounds—especially at very long block lengths—is challenging and is a key motivation for exploring shorter instances.

Reference: arXiv:2601.08824, arXiv:2604.15307

Q. What does the density-evolution threshold \(p=0.05702\) represent?

A: Density evolution tracks the message distributions of BP under the cycle-free (tree) assumption in the infinite-length limit. The threshold is the crossover point where BP transitions from successful to unsuccessful decoding on average. It serves as an analytical benchmark, not a finite-length guarantee.

Reference: arXiv:2601.08824

Q. What is density evolution for CSS-type non-orthogonal codes?

A CSS-type non-orthogonal code ensemble means an idealized ensemble with two LDPC-type parity-check matrices, one for the \(X\) side and one for the \(Z\) side, but without yet imposing the CSS orthogonality condition \(H_XH_Z^{\mathsf T}=0\). Density evolution treats this non-orthogonal ensemble as a classical-LDPC-like tree model and tracks how the BP message distribution evolves in the infinite-length limit.

In practice, the message distribution is often too complicated to write in closed form, so we use Monte Carlo density evolution, also called population density evolution. The idea is to represent the message distribution by a large population of samples and repeatedly apply variable-node, check-node, and channel updates by random sampling.

The important point is that this is a benchmark, not a performance guarantee for a constructed finite-length CSS code. Orthogonality, short cycles, finite-length effects, degeneracy, and correlations between the \(X\) and \(Z\) sides are outside this idealized model. Thus the DE threshold is used as a reference for what BP performance one would expect from a classical-LDPC-like ideal model with the same degree distribution.

Comparing this benchmark with simulations of an explicitly constructed orthogonal CSS code tells us how much of the classical LDPC iterative-decoding behavior is preserved after imposing the CSS orthogonality constraint.

Reference: D. Divsalar, S. Dolinar, C. Jones, and K. Andrews, “Capacity-Approaching Protograph Codes,” IEEE J. Sel. Areas Commun., 2009, T. Richardson and R. Urbanke, Modern Coding Theory, Chs. 3--5 and App. B, 2008

Q. What is minimum-distance analysis for CSS-type non-orthogonal codes?

If density evolution is a benchmark for BP decoding performance, minimum-distance analysis is a benchmark for how often low-weight codewords appear in a classical-LDPC-like ideal ensemble with the same degree distribution. In the CSS-type non-orthogonal model, the \(X\)- and \(Z\)-side parity-check matrices are first treated as separate classical LDPC parity-check matrices, and one studies the expected number of low-weight vectors in their kernels or the growth rate of their weight distributions.

A typical calculation estimates the exponential growth rate of the expected number of vectors of weight \(\omega n\) satisfying the parity checks. If this growth rate is negative in a weight range, vectors of that weight are unlikely to appear in the random ensemble. This gives a classical-LDPC-style indication of whether the minimum distance should grow linearly, or whether low-weight structures are expected to be common.

This is not, however, a proof of the minimum distance of a constructed finite-length quantum CSS code. The actual CSS distance is affected by the orthogonality condition \(H_XH_Z^{\mathsf T}=0\), equivalence modulo row spaces, degeneracy, finite-length short cycles, and special algebraic structure. Therefore this analysis should be read as a benchmark for the classical-LDPC-like distance behavior before imposing the CSS orthogonality constraint.

Comparing this benchmark with low-weight searches and upper/lower-bound calculations for an explicitly constructed orthogonal CSS code helps measure how much the orthogonality constraint and the construction rules create low-weight logical operators.

Reference: R. G. Gallager, “Low-Density Parity-Check Codes,” IRE Trans. Inf. Theory, 1962, S. Abu-Surra, D. Divsalar, and W. E. Ryan, “Enumerators for Protograph-Based Ensembles of LDPC and Generalized LDPC Codes,” IEEE Trans. Inf. Theory, 2011, T. Richardson and R. Urbanke, Modern Coding Theory, Ch. 7, 2008

Q. If a code is randomly selected from the ensemble, could its performance still vary significantly?

This is a natural concern. Since LDPC constructions contain randomness, one has to ask whether a particular instance might deviate substantially from the ensemble-average behavior. In classical LDPC coding theory, concentration theorems address exactly this issue for standard ensembles specified essentially by the degree distribution: for sufficiently large blocklength, the BP decoding performance of a random LDPC code concentrates with high probability around the average behavior predicted by density evolution.

Our CSS construction includes orthogonality constraints and algebraic placements, so the concentration theorem in Modern Coding Theory does not apply to it directly. In the actual design, we also impose constraints beyond the degree distribution, such as girth, blocklength, and upper-bound checks related to the minimum distance. Nevertheless, empirically, after these constraints are imposed, random choices from the remaining degrees of freedom still show the same kind of self-averaging behavior familiar from classical LDPC ensembles: different instances with the same design parameters tend to have similar decoding behavior.

Empirically, this is what we observe. When several instances with the same design parameters are compared, their FER curves and BP waterfall locations tend to cluster in a similar range close to the density-evolution benchmark, rather than showing wildly different behavior. The error-floor region needs more care, however. The failure-rate scale of practical interest is extremely small, so it is more sensitive to rare harmful structures and finite-length effects than the waterfall region. Thus the current interpretation is that the proposed construction appears to exhibit concentration-like behavior for waterfall performance, while a rigorous concentration theorem including the CSS orthogonality constraint and a full error-floor analysis remain open theoretical problems.

Reference: T. Richardson and R. Urbanke, Modern Coding Theory, Ch. 3 and App. C, 2008, arXiv:2601.08824

Q. How does this binary construction differ from earlier QLDPC constructions?

A: One characteristic feature is that we try to inject as much randomness as possible into the construction. More precisely, within the class of codes satisfying the required regularity and girth constraints, we try to construct codes as randomly as possible. Fully unconstrained randomness is incompatible with CSS commutativity and large girth, so the guiding principle is to impose only the necessary constraints and keep the construction otherwise as unbiased as possible.

Reference: arXiv:2601.08824

Q. You say randomness is important. How is it incorporated into the code construction?

We do not generate completely unconstrained random codes. Instead, we first specify the code ensemble we want to sample from. The constraints include the degree distribution, girth, blocklength, CSS orthogonality, and checks related to low-weight structures. Since it is difficult to certify the exact minimum distance at very large blocklengths, we use low-weight logical-operator searches and upper-bound evaluations to screen candidate instances.

Within the set of candidates satisfying these constraints, we then choose shifts, APM elements, finite-field coefficients, and related construction data randomly. In other words, the construction does not fix a single deterministic code from the outset; it randomly selects a code instance from the constrained ensemble of codes satisfying regularity, large girth, orthogonality, and distance-related screening criteria.

This is how randomness is injected while preserving the constraints required for a quantum CSS code. The goal is to retain as much of the randomness and self-averaging behavior familiar from classical LDPC ensembles as possible, without giving up CSS commutativity.

Reference: arXiv:2601.08824

Q. What key idea enables the proposed codes to approach the hashing bound?

The construction cleverly exploits two well-known insights from classical coding theory: (i) non-binary LDPC codes with column weight two tend to perform especially well under iterative decoding, and (ii) column weight two allows flexible designs that can effectively eliminate short cycles in the Tanner graph.

By combining these properties with affine permutation matrix (APM) placements, the proposed codes achieve both orthogonality and large girth, which suppress error floors and enable sharp threshold-like performance. As a result, the quantum LDPC codes constructed in this way approach the hashing bound, even at practical blocklengths.

Reference: arXiv:2506.15636, arXiv:2501.13923

Q. Why can’t binary LDPC codes with column weight 2 have minimum distance growing linearly?

A binary parity-check matrix with column weight 2 can be viewed as the incidence matrix of an ordinary graph: each variable node is an edge connecting the two check nodes in which that column has ones. A codeword is then a set of edges for which every check node has even degree, namely a sum of cycles. Therefore, the minimum distance is upper bounded by the length of the shortest cycle in that graph.

Since LDPC codes also have bounded row weight, the corresponding graph has bounded degree. In bounded-degree graphs, the shortest cycle length can grow at most on the order of \(\log n\) as the number of vertices grows. Thus binary column-weight-2 LDPC codes cannot be expected to have minimum distance growing linearly with blocklength.

Reference: R. G. Gallager, “Low-Density Parity-Check Codes,” IRE Trans. Inf. Theory, 1962, T. Richardson and R. Urbanke, Modern Coding Theory, Chs. 2 and 7, 2008

Q. Why is the BP threshold of regular column-weight-2 LDPC codes low?

The reason is already visible from density evolution on the binary erasure channel. For a \((d_v,d_c)\)-regular LDPC ensemble over the BEC, let \(\epsilon\) be the channel erasure probability and let \(x_l\) be the erasure probability of a variable-to-check message at iteration \(l\). The density-evolution update is \[ x_{l+1} = \epsilon\left(1-(1-x_l)^{d_c-1}\right)^{d_v-1}. \]

For column weight 2, namely \(d_v=2\), this becomes \[ x_{l+1} = \epsilon\left(1-(1-x_l)^{d_c-1}\right) = \epsilon(d_c-1)x_l+O(x_l^2). \] Thus the slope near the zero fixed point is \(\epsilon(d_c-1)\). Successful BP decoding requires the zero fixed point to be stable, so one must have \(\epsilon(d_c-1)<1\), or equivalently \(\epsilon<1/(d_c-1)\).

This is the binary-LDPC picture. If the same column-weight-2 structure is lifted to a non-binary finite field, each BP message becomes a probability distribution over field elements rather than a single binary reliability value. This gives the decoder more information to work with, and in high-rate regimes column-weight-2 non-binary LDPC codes can perform much better than their binary counterparts. The npj Quantum Information paper uses this finite-field extension idea together with the CSS construction, retaining the structural advantages of column weight 2 while obtaining strong decoding performance.

In the binary case, this upper bound becomes especially small in the high-rate regime, where the row weight \(d_c\) is large. By contrast, for column weight 3 or larger, the linear term near zero disappears, so this first-order stability constraint does not arise in the same way. This is the basic reason why regular binary LDPC codes with column weight 2 tend to have poor BP thresholds, while non-binary extensions can substantially improve performance.

Reference: R. G. Gallager, “Low-Density Parity-Check Codes,” IRE Trans. Inf. Theory, 1962, T. Richardson and R. Urbanke, Modern Coding Theory, Ch. 3, Sec. 3.9, and App. B, 2008, D. Komoto and K. Kasai, “Quantum error correction near the coding theoretical bound,” npj Quantum Information, 2025

Q. LDPC codes with column weight 2 are known to have logarithmic minimum distance and poor decoding performance, aren’t they?

Indeed, classical binary LDPC codes with column weight 2 have a minimum distance that grows only logarithmically with respect to the code length, and their BP decoding threshold is significantly worse than that of column-3 codes. However, the situation is quite different for non-binary LDPC codes. When the code rate is high, the BP threshold of column-2 non-binary LDPC codes can approach the channel capacity, whereas that of column-3 codes becomes much poorer.

Moreover, non-binary extensions can substantially increase the minimum distance, leading to performance without observable error floors. As mentioned in the following Q&A, it is well known in classical coding theory that good BP decoding performance does not necessarily require the minimum distance to grow linearly with the code length.

Reference: Roumy et al., 2004, Jin, Khandekar, and McEliece, 2000, arXiv:2506.15636

Q. Is the minimum distance of the proposed codes large? If not, why do they still perform so well?

The minimum distance of our codes does not grow linearly with blocklength. However, this does not prevent strong decoding performance under belief propagation (BP). From the theory of density evolution, it is well understood that what primarily determines BP performance are the column weight and row weight of the parity-check matrix, not the asymptotic growth of minimum distance.

Furthermore, it is known that classical LDPC codes with column weight three or larger typically have minimum distance that grows linearly with blocklength when constructed at random. This explains why researchers in LDPC coding theory tend not to emphasize minimum distance as the decisive factor: good iterative decoding performance can be achieved without relying on very large minimum distance.

While minimum distance is an important metric for characterizing the error-floor regime, achieving linearly growing minimum distance is not strictly necessary for excellent iterative decoding performance. This insight can be traced back to lessons from classical coding theory. During the 1980s and early 1990s, much of the community’s attention was directed toward the algebraic aspects of minimum-distance theory, and practical iterative methods received less focus. Consequently, the (re)discovery of turbo codes (1993) and LDPC codes (reintroduced in the mid-1990s, following Gallager’s original 1962 work) came somewhat later, even though their effectiveness derives not primarily from large minimum distance but from efficient iterative decoding and code structures that are well suited for BP.

Reference: arXiv:2506.15636

Q. What are the main components of the proposed coding framework?

The framework integrates four ingredients:
(i) Affine permutation matrix (APM) constructions to avoid short cycles,
(ii) joint belief propagation decoding over non-binary fields \(\mathbb{F}_q\),
(iii) optimization of minimum distance by carefully selecting matrix entries,
(iv) lightweight post-processing to remove residual errors.

Reference: arXiv:2506.15636, arXiv:2501.13923

Q. How does the proposed decoding differ from conventional methods?

Conventional BP decoding for CSS codes often treats \(X\) and \(Z\) errors as two separate binary LDPC decoding problems. Under depolarizing noise, however, the two Pauli components on the same qubit are not independent: they are locally correlated through \(Y\) errors. The proposed joint BP builds a factor graph in which the \(X\)-side and \(Z\)-side Tanner graphs are coupled by the local joint prior at each qubit, and then runs the sum-product algorithm on that factorization. The main difference is that syndrome decoding is performed without discarding the local correlation between the two Pauli error components.

Another equivalent viewpoint is four-state BP, where the local states are the Pauli labels \(I,X,Y,Z\). arXiv:2605.05132 shows that joint BP and four-state BP compute the same posterior weights, messages, and beliefs after relabeling the four local Pauli states and marginalizing the irrelevant binary component. In this sense, joint BP is a CSS-explicit binary factor-graph formulation: it preserves the correlation lost by separate \(X/Z\) decoding while representing the same essential posterior calculation as four-state BP.

Reference: K. Kasai, “A Factor-Graph Formulation of CSS Syndrome Decoding: Joint BP and Four-State BP,” arXiv:2605.05132, 2026

Q. What is the stabilizer weight?

The stabilizer weight is upper bounded by e × L, where e is the field extension degree and L is the row weight. For example, with e = 8 and L = 6, the stabilizer weight is at most 48, and crucially remains constant regardless of code length.

Reference: arXiv:2506.15636

Q. Does using non-binary LDPC codes mean we are encoding qudits?

No. Although matrices are defined over \( \mathbb{F}_q \) and decoding operates over non-binary fields, the physical system is still qubits. Each element of \( \mathbb{F}_q \) is expanded into an \( e \times e \) binary companion matrix, ensuring the code remains a binary CSS code.

Reference: arXiv:2506.15636

Q. How are orthogonal matrices constructed using APM (Affine Permutation Matrices)?

Our method generalizes the Hagiwara–Imai construction. Specifically, we place affine permutation matrices (APMs) at cyclically shifted positions within the parity-check matrices. By carefully choosing the shifts and the APM entries, the resulting non-binary matrices \( H_{\Gamma} \) and \( H_{\Delta} \) become orthogonal over \( \mathbb{F}_q \).

In other words, the inner product between any row of \( H_{\Gamma} \) and any row of \( H_{\Delta} \) cancels to zero in \( \mathbb{F}_q \). After expanding each field element into an \( e \times e \) binary companion matrix, we obtain binary parity-check matrices \( H_X \) and \( H_Z \) that satisfy \( H_X H_Z^{T} = 0 \). This approach ensures orthogonality while avoiding short cycles, leading to improved decoding performance.

Reference: arXiv:2506.15636

Q. Can you suggest a good noncommutative group that sits between APM and GPM?

A natural intermediate choice is the one-dimensional affine group \( \mathrm{AGL}_1(R)=R\rtimes R^{\times} \) over a finite ring \(R\). It is richer than pure generalized permutation/monomial actions because it includes translations as well as multiplicative actions, but it is still structured enough to analyze algebraically and to use in explicit code constructions.

In particular, affine groups over finite commutative principal ideal rings provide a good balance between flexibility and tractability. They are noncommutative in an essential way, yet remain close enough to permutation-matrix-based constructions to be useful for QLDPC design.

Reference: arXiv:2604.02063

Q. Density evolution suggests that column-weight-2 LDPC codes are weak. Does that mean degree-2 columns should never appear, even individually?

No. The density-evolution conclusion is an ensemble-level asymptotic statement, not a rule forbidding every individual degree-2 column. A small number of degree-2 columns can be acceptable, and in irregular LDPC design they are often used deliberately.

The real issue is whether degree-2 columns appear with too large a fraction or in harmful local configurations that create long chains, small stopping sets, or trapping sets. So the right design principle is not “never use degree 2,” but rather “control carefully how much degree 2 is used and where it appears.”

Reference: Roumy et al., 2004, Jin, Khandekar, and McEliece, 2000

Q. What is the typical decoding-curve behavior of LDPC codes? What are the waterfall and error-floor regions?

When the decoding performance of an LDPC code is plotted with the channel error probability on the horizontal axis and FER or BER on a logarithmic vertical axis, the curve typically has two qualitatively different regions. Near the threshold, a small improvement in the channel error probability can cause the decoding-failure probability to drop very rapidly. This steep transition is called the waterfall region. For BP decoding, the location and shape of this region are closely related to the density-evolution threshold and to finite-length scaling.

In the waterfall region, the main failure mechanism is the existence of nontrivial fixed points of the density-evolution equations, together with finite-length fluctuations that push the decoding trajectory to the bad side. As a result, BP can leave behind errors whose size scales proportionally with the code length.

As the channel error probability is reduced further, the curve may stop dropping steeply and begin to flatten. This is the error-floor region. In this regime, the dominant mechanisms are no longer the average density-evolution behavior, but rare local structures such as low-weight logical operators related to the minimum distance, or small trapping sets that negatively affect BP convergence. The remaining error size is usually of order \(O(1)\), namely it does not scale with the blocklength. Thus good waterfall performance and the absence of an error floor down to very small FER are related, but they are distinct design goals.

Reference: arXiv:2501.13923, arXiv:2506.15636

Q. Why does the BP waterfall curve scale like a Q-function?

For LDPC codes on the binary erasure channel, finite-length scaling in the waterfall region is fairly well understood. Near the density-evolution threshold \(p_{\mathrm{th}}\), decoding success is governed mainly by whether finite-length randomness shifts the effective threshold to one side or the other. This fluctuation is a sum of many local contributions, so it is naturally approximated by a Gaussian law.

As a result, for blocklength \(n\) and physical error rate \(p\), the failure probability has the schematic form \[ P_{\mathrm{fail}}(p,n) \approx Q\!\left(\frac{p_{\mathrm{th}}-p}{\alpha n^{-1/2}}\right), \] where \(Q(x)\) is the upper tail of the standard normal distribution. In other words, the sharp asymptotic threshold is rounded at finite length over a window of width \(O(n^{-1/2})\), and the rounded transition is described by a Gaussian tail.

The rigorous theory is clearest for the binary erasure channel, but similar finite-length scaling is often observed empirically for more general iterative decoders. This is why fitting BP FER curves by a Q-function is a natural way to summarize waterfall-region finite-length effects.

Reference: A. Amraoui, A. Montanari, T. Richardson, and R. Urbanke, “Finite-Length Scaling for Iteratively Decoded LDPC Ensembles,” IEEE Trans. Inf. Theory, 2009

Q. Why is a new construction of quantum LDPC codes necessary?

Conventional quantum LDPC codes suffer from low coding rates, high error floors, lack of scalability, and heavy post-processing requirements. As a result, performance does not scale with blocklength and remains far from the hashing bound. Our work aims to construct codes with non-vanishing rate and efficient decoding that achieve performance close to the hashing bound.

Reference: arXiv:2601.08824, arXiv:2506.15636

Q. Why do the results focus on large blocklengths?

Threshold phenomena and error-floor behavior become visible only at very large blocklengths. Demonstrating sharp threshold-like performance without error floors in this regime provides the strongest evidence of scalability. While short blocklengths also show good scaling, long blocklength results best highlight the theory.

Reference: arXiv:2601.08824, arXiv:2506.15636

Q. Are measurement errors considered?

No. The analysis assumes an idealized setting where all gate operations, stabilizer measurements, and recovery operations are error-free. The purpose is to isolate the coding-theoretic limitations apart from engineering constraints.

In contrast, arXiv:2604.16209 studies a more implementation-oriented setting for reconfigurable atom arrays, including syndrome extraction, atom rearrangement constraints, and a circuit-level noise model. Thus the ideal-measurement model discussed here should be understood as a coding-theoretic benchmark, while circuit-level noise is treated in that related work.

Reference: arXiv:2601.08824, arXiv:2506.15636, arXiv:2604.16209

Q. How is decoding success or failure determined?

Decoding is judged by whether the difference between the true error and the estimated error belongs to the dual code. In other words, if \( (x + \hat{x}) \in C_X^{\perp} \) and \( (z + \hat{z}) \in C_Z^{\perp} \), then the decoding is considered successful, because both correspond to valid stabilizers and represent the same logical state.

If the difference vector is not in the dual, then the estimated error introduces a logical error and decoding is considered unsuccessful. Our framework also includes lightweight post-processing that can correct many failures by resolving small trapping-cycle structures.

Reference: arXiv:2506.15636, arXiv:2601.08824

Q. Could the unusually sharp performance curves be an artifact of incorrect decoding criteria? For example, are you simply counting any error pattern that satisfies the syndrome as a decoding success?

In our framework, decoding success is not judged merely by reproducing the measured syndrome. Instead, the definition is stricter: the difference between the true error and the estimated error must belong to the dual code. In that case, the estimated error corresponds to a valid stabilizer and preserves the logical state, and only then is decoding counted as successful. If this condition is not met, the event is classified as a decoding failure since it introduces a logical error.

1. Open problems on the construction theory of (3,*)-regular quantum LDPC codes

In this year's papers arXiv:2601.08824 and arXiv:2604.20838, we exhibited concrete (3,*)-regular quantum LDPC families, including (3,12)-regular, (3,8)-regular, and (3,6)-regular examples, with large girth constructions and strong decoding performance. In arXiv:2511.04634, we also attempted a random construction method for qLDPC codes, but it did not succeed in systematically producing large girth. On the other hand, the constructed (3,*)-regular families sometimes show experimentally strong performance close to DE benchmarks, but there is still no general theorem guaranteeing this behavior. In addition, arXiv:2604.15307 presents many explicit upper-bound witnesses for the minimum distance of quantum APM-LDPC codes, including these families. However, a unified theory explaining why these constructions work well is still missing.

1. Tight lower bounds on the minimum distance: how close one can get to matching the upper-bound witnesses in arXiv:2604.15307 with rigorous lower bounds for the same code families. This appears to be quite difficult, since effective minimum-distance lower bounds are not known even for classical standard regular LDPC codes, protograph codes, or APM/CPM-LDPC codes in general.
2. Unified construction theory: how to identify the algebraic and combinatorial structures behind the good performance of the (3,8)-regular girth-8 example with FER = 10^-8 and the related (3,12)-regular and (3,6)-regular families, and turn them into reproducible design principles.
3. High-rate small-blocklength large-girth constructions: how to systematically construct small quantum LDPC codes with rate R > 1/2 that still have regular structure and large girth.

Please get in touch if you are interested in this group of problems.

2. Open problems for finite-degree quantum LDPC codes reaching the GV bound

In arXiv:2603.24588, we construct finite-degree quantum LDPC codes reaching the Gilbert-Varshamov bound from Hsu-Anastasopoulos codes and MacKay-Neal codes. This is a strong distance-theoretic result, but it does not automatically provide practically sparse syndrome measurement or good BP-decoding behavior. In particular, it remains unclear how to turn this into code families that simultaneously retain finite degree, strong distance, implementability, and decoding tractability. In this context, we are particularly interested in the following two open problems.

1. Sparse syndrome measurement problem: how far one can sparsify the syndrome-extraction circuits or measurement operators while preserving the favorable distance behavior of the codes.
2. Spatially coupled construction problem: whether one can build spatially coupled versions of this construction that simultaneously retain finite degree, good distance, and practical decoding performance.

In other words, the central question is whether the GV-bound-reaching property can be preserved while moving toward code families that are also favorable from the measurement and decoding viewpoints.

3. Constructible qLDPC ensembles whose BP performance is predictable by density evolution

Another open problem is to propose qLDPC code ensembles that are genuinely constructible and whose BP decoding performance can be predicted by density evolution.

In arXiv:2511.04634, we attempted to randomize qLDPC constructions, but could not maintain large girth. Meanwhile, the (3,*)-regular constructions studied this year sometimes come experimentally close to DE benchmarks, yet there is still no ensemble-level theory that predicts such behavior in a general constructible setting. Therefore, there is still no fully satisfactory framework that simultaneously supports practical finite-length constructions and analytically tractable ensemble-level performance prediction, so establishing a model that naturally connects code construction and decoding analysis remains open.

Boston Research Visit Slides and Script Available (May 2026)

The slides and read-aloud script for my Boston research visit are now available. The visit took place from May 11 to May 15, 2026. During this stay, I visited QuEra, Harvard, and MIT for research talks and discussions. The talk presents recent work on bringing classical LDPC design principles to quantum LDPC codes under CSS constraints.

📄 Download Slides (Boston Research Visit, 2026)
📄 Download Script (Boston Research Visit, 2026)

New preprint and code release: "High-Girth Regular Quantum LDPC Codes from Affine-Coset Structures" (April 23, 2026)

A new preprint, joint work with Koki Okada, "High-Girth Regular Quantum LDPC Codes from Affine-Coset Structures", is now available on arXiv.

The paper studies a P=32 CPM-lifted [[16384,4142,≤40]] quantum LDPC code constructed from a girth-8 (3,8)-regular CSS base code. With BP decoding and post-processing, we observed FER about 10^-8 at p=0.085.

The decoder, P=32 check matrices, and one-trial iteration tracing example are available on GitHub.

New Preprint on arXiv: "Heuristic Search for Minimum-Distance Upper-Bound Witnesses in Quantum APM-LDPC Codes" (April 17, 2026)

A new preprint, "Heuristic Search for Minimum-Distance Upper-Bound Witnesses in Quantum APM-LDPC Codes", is now available on arXiv.

This work studies certified upper bounds on the minimum distance of quantum APM-LDPC codes constructed from affine permutation matrices. It develops a unified framework for finding low-weight non-stabilizer logical representatives using latent row relations, restricted-lift subspaces, CRT-stripe constructions, cycle-8 trapping-set structures, and decoder-failure residuals.

Candidate witnesses are accepted only after explicit kernel-membership and row-space exclusion tests, so the reported values provide certified upper bounds within the explored parameter range.

New Preprint on arXiv: "Cross-Commuting Nonabelian Squares in Affine Groups over Finite Commutative Principal Ideal Rings" (April 2, 2026)

A new preprint, "Cross-Commuting Nonabelian Squares in Affine Groups over Finite Commutative Principal Ideal Rings", is now available on arXiv.

The paper studies when two affine families can commute across the two families while each family remains internally noncommutative. For finite commutative principal ideal rings, it gives a complete classification in terms of the local factor decomposition of the ring.

For residue rings, the result yields an exact criterion for when this cross-commuting nonabelian pattern exists in AGL_1(Z/nZ). The work is also related to the algebraic structure underlying affine-permutation-based quantum code constructions.

Invited Talk at the 2026 YITP Fault-Tolerant Logical Processing Workshop (February 12, 2026)

Prof. Kenta Kasai has accepted an invitation to deliver an invited talk at the 2026 YITP Fault-Tolerant Logical Processing Workshop, to be held September 28–October 9, 2026 at the Yukawa Institute for Theoretical Physics, Kyoto University (Kyoto, Japan).

ITA 2026 Slides and Manuscript Available (February 10, 2026)

The slides and manuscript for ITA 2026 are now available.

📄 Download Slides (ITA 2026)
📄 Download Manuscript (ITA 2026)

QEC26 Program Committee Member (February 4, 2026)

Prof. Kenta Kasai has accepted an invitation to serve on the Program Committee for the 8th International Conference on Quantum Error Correction (QEC26), to be held June 7–12, 2026 in Santa Barbara, CA.

New Preprint on arXiv: "Breaking the Orthogonality Barrier in Quantum LDPC Codes" (January 13, 2026)

We have released a new preprint titled "Breaking the Orthogonality Barrier in Quantum LDPC Codes" on arXiv.

The paper focuses on the orthogonality barrier in quantum LDPC codes and presents a framework and constructions that overcome this constraint.

Paper Published in npj Quantum Information (September 30, 2025)

The paper titled "Quantum error correction near the coding theoretical bound", authored by Daiki Komoto and Kenta Kasai (Institute of Science Tokyo), has been published in npj Quantum Information.

This study proposes a new quantum error correction framework based on LDPC codes that achieves performance near the coding-theoretical (hashing) bound. The work demonstrates efficient decoding for hundreds of thousands of logical qubits, marking a major step toward scalable fault-tolerant quantum computation.

▶︎ Read the article on npj Quantum Information (Nature)

New Preprint on arXiv: "Sharp Error-Rate Transitions in Quantum QC-LDPC Codes under Joint BP Decoding" (July 16, 2025)

We have released a new preprint titled "Sharp Error-Rate Transitions in Quantum QC-LDPC Codes under Joint BP Decoding" on arXiv.

This work reports the first observation of steep error-rate “waterfall” transitions in quantum LDPC codes with non-vanishing coding rate using binary joint belief propagation decoding. This phenomenon was previously believed to require more complex decoding strategies.

The paper also investigates the cause of error floors, identifying trapping sets in the Tanner graph as key contributors. These insights enable the potential design of codes and decoders that both maintain steep thresholds and reduce the error floor, moving quantum error correction closer to practical deployment.

Read the full preprint on arXiv

New Preprint Published on arXiv: "Quantum Error Correction Exploiting Degeneracy to Approach the Hashing Bound" (June 19, 2025)

Our new preprint titled "Quantum Error Correction Exploiting Degeneracy to Approach the Hashing Bound" is now available on arXiv.

This work presents a decoding algorithm that explicitly exploits the degeneracy of quantum errors under the depolarizing channel. Using non-binary LDPC codes and syndrome-based methods, the proposed decoder achieves a frame error rate of $10^{-4}$ at a physical error rate of 9.45% with a code of 104,000 logical qubits and 312,000 physical qubits, approaching the quantum hashing bound.

Papers and Posters Accepted at ISTC 2025 (June 11, 2025)

The following paper and poster presentations have been accepted to ISTC 2025 (13th International Symposium on Topics in Coding), which will be held in Los Angeles, USA, in August 2025.

• Regular Paper
  “Quantum Error Correction with Girth-16 Non-Binary LDPC Codes via Affine Permutation Construction”
  Kenta Kasai
• Poster Presentations
  “A Review of Recent Developments in Quantum Error Correction Using Non-Binary LDPC Codes”
  Kenta Kasai
  “Towards High-Girth Quantum LDPC Codes Beyond Conventional Constraints”
  Daiki Komoto, Kenta Kasai

The regular paper presents a novel construction of quantum APM-LDPC codes using non-circulant affine permutation matrices, demonstrating the feasibility of girth-16 code design beyond the conventional constraints of quantum QC-LDPC codes. The poster presentations provide an overview of recent developments in quantum error correction using non-binary LDPC codes and future directions for high-girth code constructions.

📄 Download Slides (ISTC 2025 Presentation)

Poster to Be Presented at ISIT 2025 Workshop Q-PIC (June 24, 2025)

Prof. Kenta Kasai will present his poster titled “Perspectives on Degeneracy and Structure in Non-Binary LDPC Code-Based QEC” at the ISIT 2025 workshop “Quantum Information – Open Problems, Impact, and Challenges (Q-PIC)”.

The workshop focuses on key challenges and open problems in quantum information science, and the poster highlights new perspectives on degeneracy and structural properties in quantum error correction based on non-binary LDPC codes.

The poster will be on display starting at 9:30 AM on June 24, 2025 (Tuesday) at the Rackham Graduate School, University of Michigan. Prof. Kasai will also deliver a 30-second pitch talk and be available for Q&A sessions.

For more details, please visit the Q-PIC workshop page.

Presentation at ISIT 2025 Recent Results Poster Session (June 23, 2025)

Prof. Kenta Kasai will present his recent work titled “Follow-Up Study on Efficient Mitigation of Error Floors in Quantum Error Correction using Non-Binary LDPC Codes” at the Recent Results Poster Session of the IEEE International Symposium on Information Theory (ISIT) 2025.

The session will take place on Monday, June 23, 2025, from 14:30 to 15:50 at the ballroom of the Michigan League in Ann Arbor.

This follow-up study builds upon previously proposed techniques to mitigate error floors in quantum LDPC codes and evaluates their performance and practicality in greater depth.

▶︎ ISIT 2025 Recent Results Session
▶︎ arXiv preprint

Poster Accepted at QEC25: "Towards Practical Quantum Error Correction" (May 22, 2025)

The poster "Towards Practical Quantum Error Correction: Near-Optimal Performance and Floor Mitigation via Non-Binary LDPC Codes", authored by Kenta Kasai, has been accepted for presentation at the Quantum Error Correction (QEC25) conference.

This work addresses the suppression of error floors in quantum LDPC codes and demonstrates near-optimal performance using non-binary belief propagation decoding.

The acceptance rate for this year’s poster session was below 40%, making it a highly competitive venue for recent results in quantum error correction.

More details available on the QEC25 website.

Paper Accepted at ISIT 2025: "Efficient Mitigation of Error Floors in Quantum Error Correction using Non-Binary Low-Density Parity-Check Codes" (April 27, 2025)

The paper "Efficient Mitigation of Error Floors in Quantum Error Correction using Non-Binary Low-Density Parity-Check Codes", authored by Kenta Kasai, has been accepted for presentation at the IEEE International Symposium on Information Theory (ISIT 2025).

This paper presents decoding algorithms designed to mitigate the error floor in quantum LDPC codes constructed over non-binary fields, achieving performance close to the hashing bound under practical quantum noise models.

As a follow-up to this work, we will present new results in the Recent Results Poster Session at ISIT 2025, to be held in Ann Arbor, Michigan.

Preprint available on arXiv.

📄 Download Slides (ISIT 2025 Presentation)