Example CSS codes and the properties "doubly even" and "self dual"

Steane's $$[[7,1,3]]$$ code is a well known CSS code which is self-dual and doubly even. Indeed the entire family of $$[[2^{2m+1}-1,1,2^{m+1}-1]]$$ codes mentioned in equation (7.230) of http://theory.caltech.edu/~preskill/ph229/notes/chap7.pdf is self-dual and doubly even.

The $$[[23,1,7]]$$ Golay code is another well known CSS code which is self-dual and doubly even.

The $$[[15,1,3]]$$ quantum Reed-Muller code is a well known CSS code which is doubly even but not self dual ($$X$$ type stabilizers have weight $$8$$ while the $$Z$$ type stabilizers have weight $$4$$). Indeed the entire family of $$[[2^{k+1}-1,1,3]]$$ codes mentioned here Eastin Knill Theorem and groups of transversal gates is doubly even but not self dual.

Shor's $$[[9,1,3]]$$ code is a well known CSS code which is not self-dual and not doubly even.

What is an example of a well known CSS code which is not doubly even but is self dual? Or are those all uninteresting? (EDIT thanks to DaftWullie: When I say well known I mean it has some interesting or good properties that make it well known. For example it would be good if the code had distance $$d\geq 3$$ although $$d=2$$ could still be interesting if other stuff about the code stands out).

• Perhaps it's worth adding on the constraint that the distance of the code should be at least 3? (Or maybe you're willing to consider distance 2, which do have some uses e.g. in magic state distillation...) Jun 3, 2022 at 6:43
• I'm confused by the terminology. I know the definition "self dual" and "doubly even" for classical codes; what is it for quantum codes? A CSS code is defined by two classical codes $H_X$ and $H_Z$; if $H_X$ is self dual and $H_X=H_Z$ then they're both rate 1/2 classical codes so the CSS code built from them is 0 dimensions. Your example $[[7,1,3]]$ is built with $H_X=H_Z=H$ where $H$ is Hamming code $[n=7,k=4]$. $H$ is not self dual; its dual is $[n=7,k=3]$. Similarly $[[23,1,7]]$ is built up from $[n=23,k=12]$ classical binary Golay code which is also not a self dual (classically). Jun 4, 2022 at 2:23
• @unknown You are not alone in being confused! See my comment math.stackexchange.com/questions/1851346/… There is a very unfortunate clash of terminology between classical and quantum error correction folks. for qecc self dual just means a CSS code where the X and Z type stabilizers basically look the same. For doubly even the terminology doesn't clash it just means all the stabilizer generators have weight divisible by 4 as you would expect. Jun 4, 2022 at 13:15
• @IanGershonTeixeira I think using "self dual" for qecc to mean $H_X=H_Z$ is a bad choice. It doesn't look like it's caught on so maybe it's not too late to avoid it. What do you mean by "basically look the same"? are they the same code or not? Also a code can have different generators with different weights so I think "doubly even" should refer to all codewords. Another point of confusion is that a qecc can be associated with a classical code over GF(4) and self duality can be defined in that context too. Jun 4, 2022 at 15:01

Take the classical single parity check codes on $$4a+2$$ bits. These have distance 2 and parity check matrix $$H=[1,1,\cdots,1]$$; as classical codes $$H^T H=0$$ and the weights of $$H$$ are obviously not multiples of 4. So taking $$H_X=H_Z=H$$ should work.

Here's an example of $$[[21,1,5]]$$ code which is even but not doubly even : $$H=H_X=H_Z=$$

[ [  1,  1,  1,  0,  0,  1,  0,  0,  1,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  1,  1,  1,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  1,  1,  0,  0,  0,  0,  1,  0,  0,  0,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  1,  0,  0,  0,  1,  1,  1,  1,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  0,  1,  1,  0,  1,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  1,  1,  0,  1,  0,  0,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  1,  0,  0,  1,  0,  0,  0,  1,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  0,  1,  0,  0,  1,  1,  0,  1,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  1,  1,  0,  0,  1 ] ]


The logicals for the code $$L=L_X=L_Z$$=

[ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0 ] ]


Here's the GAP code used in the search

LoadPackage("guava","0",false);
TestA:=function(n)local code,H,T,k,w,dim,DminC,DminD,wgt;
for k in [2..n-1] do
code:=BestKnownLinearCode(n,k,GF(2));
#uncomment this to show for k=10 code is shortened golay
#if(k=10)then
#code:=BinaryGolayCode();
#code:=ShortenedCode(code,[1,2]);
#fi;
code:=DualCode(code);
code:=EvenWeightSubcode(code);
dim:=Dimension(code);
Print("n=",String(n,-3)," k=",String(k,-3)," dim=",String(dim,-3));
if(dim>0)then
H:=GeneratorMat(code);T:=H*TransposedMat(H);
if(T=0*T)then
DminC:=MinimumDistance(code);
DminD:=MinimumDistance(DualCode(code));
Print(" dC=",DminC);Print(" dD=",DminD);
H:=List(H,x->List(x,Int)); # convert from GF(2) matrix to binary matrix
wgt:=Collected(List(H,Sum));Print(" weights=");for w in wgt do Print(w[1],",");od;
if(DminC>2 and DminD>2)then Print("\n");Print("H=\n");PrintArray(H);fi;
fi;
fi;
Print("\n");
od;
return code;
end;


Here's a log of running it for n=21

gap> code21:=TestA(21);;
n=21  k=2   dim=18
n=21  k=3   dim=17
n=21  k=4   dim=16
n=21  k=5   dim=15
n=21  k=6   dim=14
n=21  k=7   dim=13
n=21  k=8   dim=12
n=21  k=9   dim=11
n=21  k=10  dim=10  dC=6 dD=5 weights=6,10,
H=
[ [  1,  1,  1,  0,  0,  1,  0,  0,  1,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  1,  1,  1,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  1,  1,  0,  0,  0,  0,  1,  0,  0,  0,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  1,  0,  0,  0,  1,  1,  1,  1,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  0,  1,  1,  0,  1,  0,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  1,  1,  0,  1,  0,  0,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  1,  0,  0,  1,  0,  0,  0,  1,  0,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  0,  1,  0,  0,  1,  1,  0,  1,  0,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  0 ],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  1,  0,  1,  1,  1,  0,  0,  1 ] ]

n=21  k=11  dim=9
n=21  k=12  dim=8
n=21  k=13  dim=7
n=21  k=14  dim=6
n=21  k=15  dim=5
n=21  k=16  dim=4
n=21  k=17  dim=3
n=21  k=18  dim=2
n=21  k=19  dim=1   dC=20 dD=1 weights=20,
n=21  k=20  dim=0

• I would prefer an example which is error correcting (distance 3) not just error detecting (distance 2) if that's possible Jun 30, 2022 at 18:14
• I edited the answer to add a d>2 example Jul 2, 2022 at 17:42
• More of a search through a database rather than a constructive method; GAP (with GUAVA package) has a database of best known (classical) linear codes. I wrote a simple search routine (in GAP) to look for codes that meet the criteria. The code above is derived from the best known code $[21,10,7]$ which I'm pretty sure is the binary golay code shortened by 2 bits. Taking the dual code of that gives a $[21,11,6]$ code; and its even weight subcode gives the $[21,10,6]$ code in the answer. Jul 2, 2022 at 21:26
• I added the GAP code to the answer. I did check that using the shortened golay code gives the same result (you can uncomment a few lines to check). I use the classical $H$ found from the search to define a CSS code with $H_X=H, H_Z=H$. Guava doesn't work with qecc as far as I know. I use custom code to work with these (much too large to include here). I did check the distance of the qecc and it is in fact 5 not 6; also the dual code of $H$ has $d=5$. Jul 3, 2022 at 3:08
• I added the logicals to the answer; this is just $H^\perp - H$; the weight is $5$ which is another check of the distance... Jul 3, 2022 at 17:57