# Stabilizer Code with small support

The support of an $$n$$ qubit state is the number of nonzero coefficients when the state is written as a linear combination of computational basis kets.

The Steane $$[[7,1,3]]$$ code has logical 0 and logical 1 which are both a uniform superposition over 8 computational basis kets. \begin{align} |0>_L=& |0000000>+|1010101>+|0110011>+|1100110>\\ &+|0001111>+|1011010>+|0111100>+|1101001>\\ |1>_L=& |1111111>+|0101010>+|1001100>+|0011001>\\ &+|1110000>+|0100101>+|1000011>+|0010110> \end{align} Support 8 is very small. What are examples of other quantum error correcting $$[[n,1,3]]$$ codes with even smaller support? For example support $$1$$ or $$2$$ or $$4$$?

• For CSS codes I think the number of terms should be just $2^{|H_x|}$. This is the order of the group generated by $H_x$ taken as a classical code. The $[[9,1,3]]$ code can have either $|H_x|=2, |H_z|=6$ or $|H_x|=6, |H_z|=2$. The first version would give you four terms. Relationship of $|H_x|$ to distance may not be straight forward. Nov 13, 2022 at 18:07

Let's think for a moment why the Steane code basis state have a support of 8. The Steane code is a CSS code with generators, $$g_0 = X_0X_1X_2X_3$$ $$g_1 = X_0X_1X_4X_5$$ $$g_2 = X_0X_2X_4X_6$$ $$g_3 = Z_0Z_1Z_2Z_3$$ $$g_4 = Z_0Z_1Z_4Z_5$$ $$g_5 = Z_0Z_2Z_4Z_6$$

The zero-basis state is constructed via $$|\bar 0\rangle = (I+g_0)\cdots (I+g_5)|0000000\rangle.$$ But the generators $$g_3,g_4,g_5$$ are $$Z$$ type generators and don't do anything to $$|0000000\rangle$$. So we are left with $$|\bar 0\rangle = (I+g_0)(I+g_1)(I+g_3)|0000000\rangle.$$

You can see that this state must have a support of 8 because there are 8 unique combinations of $$g_0,g_1,g_2$$ multiplying $$|0000000\rangle$$.

You can easily see that this result is general. For a CSS code, if there are $$r_x$$ $$X$$-type generators, then the support of the encoded basis states will be $$2^{r_x}$$.

The next natural question to ask ourselves is, can we somehow reduce the number of $$X$$-type generators? Or concretely, for a $$[[n,k=1,d=3]]$$ code, how small can we make $$r_x$$?

Let's look at the Steane code again in terms of its error-correcting properties. The Steane code corrects any single-qubit bit-flip or phase-flip error. What are the possible phase-flip errors (which are corrected by $$X$$-type generators)? They are eight such errors: $$\{I, Z_0,\dots, Z_6\}$$, where the $$I$$ is no error. So, to distinguish between these 8 possibilities, we need 3 bits of information, which is provided by having 3 $$X$$-type generators in our code. If we have any fewer, then the code will not be able to identify every phase-flip error.

This result is valid for any non-degenerate codes. If there are $$n$$ physical qubits, then there will be $$n+1$$ possible single-qubit phase-flip errors (including the identity). To identify each one, we will need at least $$\log_2(n+1)$$ $$X$$-type generators, i.e. $$r_x \ge \log_2(n+1)$$. If the code is degenerate, then fewer $$X$$-type generators will be required.

From our first result, we can immediately see that the support of the encoded basis states will have to be at least $$n+1$$.

I will leave it to you to think about if and how the results change if $$k \ne 1$$ or $$d \ne 3$$.

• Does this result that an $[[n,1,3]]$ code must have support at least $n+1$ hold for just $[[n,1,3]]$ CSS codes? All $[[n,1,3]]$ stabilizer codes? All $[[n,1,3]]$ codes? Nov 12, 2022 at 21:41
• I showed it for $[[n,1,3]]$ CSS codes. I doubt the same bound holds for non-CSS [n,1,3]]$stabilizer codes. But I don't even know how to start investigating that question. There is too much freedom in non-CSS codes. Nov 12, 2022 at 21:55 • +1 that's an interesting fact about CSS codes. I'm interested more generally in stabilizer codes and especially in specific examples of stabilizer codes with small support. So I think I'll wait and see if other answers address those aspects of the question Nov 13, 2022 at 1:25 • It seems that there is a$ [[9,1,3]] $CSS code, some version of the Shor code, with code words$ |0>_L=|000 000 000>+ |110 110 110>+ |011 011 011>+ |101 101 101> $and$ |1>_L=|111 111 111>+ |001 001 001>+ |100 100 100>+ |010 010 010> $, stabilizer generators$ XXI XXI XXI, IXX IXX IXX, ZII ZII III, IZI IZI III, IIZ IIZ III, ZII III ZII, IZI III IZI, IIZ III IIZ $. This$ [[n,1,3]] $CSS code has support less than$ n+1=10 \$. So it seems that your answer is wrong. (sorry to be harsh I know you're new!) Is there something here I'm not understanding correctly? Nov 13, 2022 at 4:25
• You are correct. I failed to account for degenerate code, where different phase-flip errors act on encoded states in the same way. This makes the second result only valid for non-degenerate codes. Nov 13, 2022 at 22:25