ORIGINAL ARTICLE: Kubischta, E., & Teixeira, I. (2023). The Not-So-Secret Fourth Parameter of Quantum Codes. arXiv:2310.17652. DOI: https://doi.org/10.48550/arXiv.2310.17652
Article Abstract: A quantum code is usually referred to using three parameters: the number of physical qubits n, the dimension of the codespace K, and the distance of the code d. But these three parameters are not the only invariants of a quantum code under code equivalence - there is also a “not-so-secret fourth parameter” G, the transversal group, which is of fundamental importance for fault tolerance. It was shown in a recent paper of Omanakuttan and Gross that in certain cases the Dicke state mapping from spin codes to multiqubit codes preserves distance and logical gates. We prove this result in general, and use it to construct three families of non additive codes that strictly outperform stabilizer codes with regards to the “new” parameter G. Our first family implements transversal gates which are impossible for any stabilizer code. Our second family has smaller length n than any stabilizer code with the same distance d and transversal group G. And our third family implements the famous T gate transversally for larger distance d and shorter length n than any known stabilizer codes.

Initializations


Codes

One can use our findSpinCode command to search for binary-dihedral covariant spin codes.

A 1st example

Suppose we want to find a d=3 code that implements
BD
2
transversally (which is just the single qubit Pauli group). Thus we take B =2, d=3, and we need 1 ≤ a ≤ B/2 so we must have a=1. Also we need spin j to be half integral so basically we just start at j=1/2 and keep checking until we find a spin code.
In[]:=
B=2;​​a=1;​​d=3;
Start with j=1/2
In[]:=
j=1/2;​​findSpinCode[B,a,j,d];
Checking for the existence of a ((1,2,3)) code that is (
BD
2
,
δ
1
) transversal
μ=1
ν=3
☒ Spin code should NOT exist here
No Codes found: min=474.681
The minimum should be approximately 0. If it’s not then there is no code here.
Now do j=3/2
In[]:=
j=3/2;​​findSpinCode[B,a,j,d];
Checking for the existence of a ((3,2,3)) code that is (
BD
2
,
δ
1
) transversal
μ=2
ν=3
☒ Spin code should NOT exist here
No Codes found: min=97.5289
Still no code.
Now do j=5/2
In[]:=
j=5/2;​​findSpinCode[B,a,j,d];
Checking for the existence of a ((5,2,3)) code that is (
BD
2
,
δ
1
) transversal
μ=3
ν=3
☒ Spin code should NOT exist here
No Codes found: min=14.6537
Still no code.
Now do j=7/2
In[]:=
j=7/2;​​{l0,l1}=findSpinCode[B,a,j,d];
Checking for the existence of a ((7,2,3)) code that is (
BD
2
,
δ
1
) transversal
μ=4
ν=3
☑ Spin code should exist here
---------------------------
Code Found that satisfies KL conditions within 2.90501×
-30
10
Weight Enumerators: 
1.
0
0
0
1.
0
0
4.45455

Δ ={0,0,0,4.45455}
Distance of our found code is d=3
☑ Pass... We have found a ((7,2,3,
BD
2
)) code!
Spin code does exist here! If the minimum if sufficiently small (say smaller than
-12
10
) then we look at the weight enumerators to guarantee that it really is a good code with the distance we are claiming it to have.​
​
Notice that only when μ =ν +1 did a code exist (which coincides with our conjecture).
For fun let’s see the spin codewords labeled as  j,m〉 where -j ≤ m ≤ j
In[]:=
{l0,l1}//RootApproximant//VecToSpinKetMatrix
Out[]//MatrixForm=
1
8
15

7
2
,-
7
2
-
1
8
7

7
2
,-
3
2
+
1
8
21

7
2
,
1
2
+
1
8
21

7
2
,
5
2

-
1
8
21

7
2
,-
5
2
-
1
8
21

7
2
,-
1
2
+
1
8
7

7
2
,
3
2
-
1
8
15

7
2
,
7
2

Lastly, we can convert to a multiqubit code using the Dicke bootstra. Notice that there are n=7 qubits here because j=7/2 (and in general we have n=2j). We display logical zero
In[]:=
DickeBootstrap[l0//RootApproximant]//VecToKet
Out[]=
15
|0000000〉
8
-
|0000011〉
8
3
-
|0000101〉
8
3
-
|0000110〉
8
3
-
|0001001〉
8
3
-
|0001010〉
8
3
-
|0001100〉
8
3
+
1
8
3
5
|0001111〉-
|0010001〉
8
3
-
|0010010〉
8
3
-
|0010100〉
8
3
+
1
8
3
5
|0010111〉-
|0011000〉
8
3
+
1
8
3
5
|0011011〉+
1
8
3
5
|0011101〉+
1
8
3
5
|0011110〉-
|0100001〉
8
3
-
|0100010〉
8
3
-
|0100100〉
8
3
+
1
8
3
5
|0100111〉-
|0101000〉
8
3
+
1
8
3
5
|0101011〉+
1
8
3
5
|0101101〉+
1
8
3
5
|0101110〉-
|0110000〉
8
3
+
1
8
3
5
|0110011〉+
1
8
3
5
|0110101〉+
1
8
3
5
|0110110〉+
1
8
3
5
|0111001〉+
1
8
3
5
|0111010〉+
1
8
3
5
|0111100〉+
3
|0111111〉
8
-
|1000001〉
8
3
-
|1000010〉
8
3
-
|1000100〉
8
3
+
1
8
3
5
|1000111〉-
|1001000〉
8
3
+
1
8
3
5
|1001011〉+
1
8
3
5
|1001101〉+
1
8
3
5
|1001110〉-
|1010000〉
8
3
+
1
8
3
5
|1010011〉+
1
8
3
5
|1010101〉+
1
8
3
5
|1010110〉+
1
8
3
5
|1011001〉+
1
8
3
5
|1011010〉+
1
8
3
5
|1011100〉+
3
|1011111〉
8
-
|1100000〉
8
3
+
1
8
3
5
|1100011〉+
1
8
3
5
|1100101〉+
1
8
3
5
|1100110〉+
1
8
3
5
|1101001〉+
1
8
3
5
|1101010〉+
1
8
3
5
|1101100〉+
3
|1101111〉
8
+
1
8
3
5
|1110001〉+
1
8
3
5
|1110010〉+
1
8
3
5
|1110100〉+
3
|1110111〉
8
+
1
8
3
5
|1111000〉+
3
|1111011〉
8
+
3
|1111101〉
8
+
3
|1111110〉
8

A 2nd example

Suppose we want to find a d=3 code that implements
BD
4
transversally (which is just the single qubit Pauli group together with the phase gate
S=
-π/4

0
0
π/4

). Thus we take B =4, d=3, and we need 1 ≤ a ≤ B/2 so we must have a=1 or a=2. The a controls the irrep and there is different behavior for each as demonstrated below.
In[]:=
B=4;​​d=3;
Let’s find the smallest a=1 code that has B=4 and d=3.
In[]:=
a=1;​​findSpinCode[B,a,1/2,d];​​findSpinCode[B,a,3/2,d];​​findSpinCode[B,a,5/2,d];​​findSpinCode[B,a,7/2,d];​​findSpinCode[B,a,9/2,d];
Checking for the existence of a ((1,2,3)) code that is (
BD
4
,
δ
1
) transversal
μ=1
ν=2
☒ Spin code should NOT exist here
No Codes found: min=324.263
Checking for the existence of a ((3,2,3)) code that is (
BD
4
,
δ
1
) transversal
μ=1
ν=2
☒ Spin code should NOT exist here
No Codes found: min=66.3156
Checking for the existence of a ((5,2,3)) code that is (
BD
4
,
δ
1
) transversal
μ=1
ν=2
☒ Spin code should NOT exist here
No Codes found: min=15.7221
Checking for the existence of a ((7,2,3)) code that is (
BD
4
,
δ
1
) transversal
μ=2
ν=2
☒ Spin code should NOT exist here
No Codes found: min=6.1762
Checking for the existence of a ((9,2,3)) code that is (
BD
4
,
δ
1
) transversal
μ=3
ν=2
☑ Spin code should exist here
Thus the smallest code with a=1 and these properties is in 9 qubits.
Now let’s find the smallest a=2 code that has B=4 and d=3.
Thus the smallest code with a=2 and these properties is in 11 qubits.
Thus different choices of irreps determine when you will find an optimal code.
We found a spin code and checked that indeed it has d=3. Display the spin codewords
Lastly, convert to a multiqubit code using the Dicke bootstrap. Notice it is in n=13 qubits because the spin code was in j=13/2 (and in general we have n=2j). We display logical zero
This code implements the famous T gate transversally and has distance 3 (meaning it can correct an arbitrary single qubit error). Our code does this using 11 physical qubits which is smaller than the smallest such stabilizer code (the [[15,1,3]] Reed Muller code that does so in 15 qubits).
Now grab the spin codewords:
Lastly, convert to a multiqubit code using the Dicke bootstrap. We display logical zero
This code implements the famous T gate transversally and has distance 5 (meaning it can correct an arbitrary two qubit error). Our code does this using 27 physical qubits which is smaller than the smallest such stabilizer code (the [[49,1,5]] code).
Now grab the spin codewords:

CITE THIS NOTEBOOK

The Not-So-Secret Fourth Parameter of Quantum Codes​
by Eric Kubischta and Ian Teixeira
Wolfram Community, STAFF PICKS, November 28, 2023
​https://community.wolfram.com/groups/-/m/t/3073281