The feature of quantum error correcting codes called degeneracy is that they can sometimes be used to correct more errors than they can uniquely identify. It seems that codes exhibiting such characteristic are able to overcome the performance of quantum error correction codes that are nondegenerate.

I am wondering if there exists some kind of measure, or classification method in order to determine how degenerate is a quantum code, and so if there has been any study trying to determine the error correction abilities of quantum codes depending on the degeneracy of them.

Apart from that, it would be interesting to give reference or some intuition about how to construct good degenerate codes, or just reference about the current state of the art of those issues.


2 Answers 2


I don't have a complete answer, but perhaps others can improve on this starting point.

There are probably 3 things to ask about the code:

  1. How degenerate is it?

  2. How hard is it to perform the classical post-processing of the error syndrome in order to determine which corrections to make?

  3. What are its error correcting/fault-tolerant thresholds?

I suppose a simple enough measure of degeneracy is the extent to which the Quantum Hamming Bound is surpassed. For an $[[N,k,d]]$ code, a non-degenerate code must satisfy:

$$2^{N-k}\geq\sum_{n=0}^{\lfloor d/2\rfloor}3^n\binom{N}{n}$$

So the amount by which that bound is violated suggests something interesting about how densely the information is packed. Of course, that's no use if your mega-degenerate code cannot actually correct for any errors. Similarly, if your code is in principle awesome, but it takes too long to actually work out what the correction is, your code isn't really any use in practice because errors will continue to accumulate as you try to work out what corrections to do.

  • $\begingroup$ Thanks for the thought about the question. The points you give in order to analyze the code are really interesting and I think that considerig the violation of the quantum Hamming bound in order to analyze the degeneracy is really interesting. I have been thinking about using the cardinals of the error cosets which will be bigger than one for degenerate codes in order to classify the degeneracy, what do you think about it? Also if you have any interesting reference about the topic, it would be interesting to share it. $\endgroup$ May 14, 2018 at 13:52
  • $\begingroup$ @JosuEtxezarretaMartinez Perhaps you could expand your idea more within the question? I'm not sure I immediately understand what you're getting at, but it will also advertise it to a wider audience than the comment will... $\endgroup$
    – DaftWullie
    May 14, 2018 at 21:04
  • $\begingroup$ Ok, I guess I will prepare a question about that sometime. Also, the link you wrote is not working because it has taken the bracket and the "(here)" as part of it, it'd be nice if you edit it so that other people can use that. Thanks. $\endgroup$ May 15, 2018 at 7:37
  • $\begingroup$ Off the top of my head, I don't know of any references. To myknowledge, properties of degenerate codes are relatively under-studied in this way, because the first major challenge is to find some good degenerate codes. I don't think we know so many (e.g. here), and they don't beat the quantum Hamming bound by very much. $\endgroup$
    – DaftWullie
    May 15, 2018 at 15:24

It seems to me that the feature is only interesting if one introduces some notion of weight of the stabilizers and errors. The distance of the code does this implicitly since it cares about correcting all Pauli words from weight 0 up to some $d-1$.

Otherwise, all $[n, k, .]$ stabilizer codes are degenerate. They will have $n-k$ stabilizer generators. You will thus have $2^{n-k}$ disjoint correctable error classes (one per syndrome configuration). Each of these classes is itself composed of $2^{n-k}$ different Pauli errors ($e$ and other Paulis which are equivalent to $e$ up to stabilizers).

Intuitively, I would expect a measure of degeneracy to quantify how many low weight errors coincide in each class. One could say that counting only those Pauli errors words of weight lower than $d$ is a way to do it. By this definition any code which has a stabilizer of weight lower than $d$ is degenerate (that is the Yes/No approximation to quantifying degeneracy which coincides with the usual definition). In this case, each class has at most one Pauli word of weight less than d/2 in it.

However, I suspect there should be a smoother way to quantify this (and possibly still computable) which is probably where the question is coming from.

  • $\begingroup$ This paper: arxiv.org/abs/quant-ph/0604107 seems to discuss some definition of a degenerate quantum code, but the definition is given in a very hand-wavy manner... Would be interesting to hear if there is any other updated thoughts or literature on this. $\endgroup$
    – shixian105
    Nov 17, 2023 at 4:06

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.