1
$\begingroup$

Sometimes, in the discussion of why low-density parity check codes are useful, I have heard that stabilizer codes with large stabilizer generators have several drawbacks. For example, I have heard it can be difficult to measure a large stabilizer, leading to larger measurement error rates, and I have heard it can be difficult to decode these "high-density" parity-check codes.

Besides these drawbacks (tabling whether they are indeed fair drawbacks), are there other drawbacks to using "large stabilizer" codes? Alternatively, if we overcame measurement difficulties and decoding difficulties, would there still be reasons to prefer low-density codes to high-density ones? I'm particularly interested in whether CSS codes with intrinsically high-weight stabilizer generators might suffer worse thresholds with maximum likelihood decoders under uncorrelated noise (like i.i.d. bitflip noise) relative to codes where there's a choice of low-weight stabilizer generators.

As a note of clarification, by "large stabilizer" codes, I have in mind families of codes with varying $n$ where the smallest possible stabilizer generator is growing unboundedly with $n$. That is, these codes intrinsically have large stabilizers, and it's not just a poor choice of stabilizer generators that is making the stabilizer measurements high weight.

$\endgroup$

1 Answer 1

1
$\begingroup$

When we talk about LDPC codes, there's typically two parameters that define how "low-density" it is.

The first is "how many data qubits does each stabilizer involve"? The second is "how many stabilizers touch each data qubit"?

It's important, in fault-tolerance, to keep these two quantities low. If we treat each time one qubit touches another as noisy, then the total amount of entropy in the stabilizer measurement accumulates as the size of the stabilizer increases. The same thing is true for the data qubits. In fact, frequently these two quantities are intertwined because the data qubits can wait around for a while as the stabilizers are being measured, and this waiting around also accumulates noise. So, fundamentally, LDPC codes are important because their "entropy injected into the system" vs. "accumulation of syndrome information" ratio is low.

A second concern is the overhead of measuring larger-weight stabilizers fault-tolerantly. In practice, measuring high-weight stabilizers can lower the effective protection offered by the code because of correlated errors produced by the larger circuits. There are ways to mitigate this, but again, they frequently come at the cost of even larger, more complicated circuits and increased entropy.

Consequently, LDPC codes are pretty integral to quantum fault-tolerance. One thing I want to push back on, though, is the "complexity of decoding high-weight stabilizers". This is sort of true, in the sense of accounting for correlated errors induced by measuring high-weight stabilizers. But it isn't always true - for example, the Bacon-Shor code has high-weight stabilizers, but is even easier to decode than the surface code! In fact, it's basically equivalent (in complexity) to decoding the repetition code.

This isn't to say that "high-density" parity check codes don't have a place in quantum fault-tolerance, however. Just recently, there was a paper on reducing the overhead of error-correction by using "high-density" parity check codes in tandem with low-density parity check codes (in that case, the surface code).

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.