1
$\begingroup$

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 $?

$\endgroup$
1
  • 1
    $\begingroup$ 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. $\endgroup$
    – unknown
    Nov 13, 2022 at 18:07

1 Answer 1

3
$\begingroup$

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$.

$\endgroup$
5
  • $\begingroup$ 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? $\endgroup$ Nov 12, 2022 at 21:41
  • $\begingroup$ 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. $\endgroup$ Nov 12, 2022 at 21:55
  • $\begingroup$ +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 $\endgroup$ Nov 13, 2022 at 1:25
  • $\begingroup$ 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? $\endgroup$ Nov 13, 2022 at 4:25
  • $\begingroup$ 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. $\endgroup$ Nov 13, 2022 at 22:25

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.