For a $d=2t+1$ code, is a Pauli error of weight $> t$ equal to a logical error multiplied by a weight $\leq t$ Pauli error?

Question

Consider a distance $d=2t+1$ stabilizer code.

Consider a Pauli error $E$ of weight $w(E)>t$.

Is it true in general that $E$ can always be written as $E' \times O_L$, where $O_L$ is a logical operator (possibly multiplied by some stabilizers), and $E'$ is a Pauli error of weight $w(E') \leq t$?

Basically the intuition which motivates my question is that if I have a Pauli error exceeding what my code can correct, I know that the state after error-correction will have a logical error. In such a case, does it mean that everything behaved as if the state before correction had a logical error multiplied by a correctable error?

If this is not true in general, is this property at least true for a "well known" specific class of stabilizer codes?

Answer 1

Lets make a counting argument to show this is not true. I will do it first for the $[[5,1,3]]$ code and then the general case.

The $[[5,1,3]]$ code

Lets count the Pauli operators first. There are $4^{5+1}$ Pauli operators for the 5-qubit space, or just $4^5 = 1024$ if we ignore the phase, which I will do from now on. The formula for the number of $t$-weight operators is $$ \#_{wt}(t') = 3^{t'} {5 \choose {t'}}. $$ This tells us that $$ \#_{wt}(0) = 1, \\ \#_{wt}(1) = 15, \\ \#_{wt}(2) = 90, \\ \#_{wt}(3) = 270, \\ \#_{wt}(4) = 405, \\ \#_{wt}(5) = 243. $$ From this we know that there are $16$ errors of weight less than equal to $t=1$ (what you call $E'$), and $1008$ errors of weight greater than $t=1$ (what you call $E$).

Separately, we know that the size of the stabilizer group (with 4 generators) for the $[[5,1,3]]$ code is $2^4 = 16$.

We also need to count the number of logical operators. The logical operators are contained in the normalizer of the stabilizer group. The normalizer has size $2^{n+k} = 2^6 = 64$. Out of these 16 operators are the logical identity (in fact, exactly the 16 operators of the stabilizer group), and 16 operators each are the logical $X,Y,Z$.

Now we can turn to your question. There are 48 non-identity logical operators. There are 16 errors of weight less than equal to $t=1$. Note there is no overlap in these two categories (all elements in the normalizer have weight greater than $1$).

So there are $16 \times 48 = 768$ operators of what you designate $E' \times O_L$. As we can see that this is less than the $1008$ operators of type $E$ that we computed above. So, the conjecture does not hold for this code.

Though there are lots of operators that can be written in this way.

The general case

Let us consider a $[[n,k,2t+1]]$ code.

• The number of errors of weight less than or equal to $t$ are $$ \#_{wt\le t} = \sum_{i=0}^t 3^{i} {n \choose {i}}. $$
• The number of errors of weight greater than $t$ are $$ \#_{wt> t} = 4^n - \#_{wt\le t}. $$
• The size of the stabilizer group is $2^{n-k}$.
• The number of non-identity logical operators are $2^{n+k} - 2^{n-k}$.

We compute the difference in the two type of operators that you identify as $$ (4^n - \#_{wt\le t}) - (2^{n+k} - 2^{n-k})\#_{wt\le t}. $$

If this expression was negative for some values of $n,k,t$, then it is possible for your conjecture to hold for those values. I won't analyze this.