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

Question

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...) — DaftWullie, Jun 03 '22 at 06: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). — unknown, Jun 04 '22 at 02:23
@unknown You are not alone in being confused! See my comment https://math.stackexchange.com/questions/1851346/how-can-the-hamming-7-4-code-be-self-dual 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. — Ian Gershon Teixeira, Jun 04 '22 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. — unknown, Jun 04 '22 at 15:01

unknown · Accepted Answer · 2022-07-03T17:56:15.027

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 — Ian Gershon Teixeira, Jun 30 '22 at 18:14
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. — unknown, Jul 02 '22 at 21:26
Could you expand your answer with more details about how you found this code? For example I have GAP but have never used the GUAVA package I'd be curious to see your code. Were you basically looking for the best singly even weakly self dual classical codes? Also classical coding theory is not my strong suit so I'd be curious to hear you comment more on the relation between the binary Golay code, the $[21,10,7]$ code, it dual $[21,11,6]$ and the even weight subcode $[21,10,6]$. And ultimately how you put those together to get a $[[21,1,5]]$ CSS code. Also is it possible you meant $[[21,1,6]]$? — Ian Gershon Teixeira, Jul 03 '22 at 02:20
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$. — unknown, Jul 03 '22 at 03: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... — unknown, Jul 03 '22 at 17:57

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

1 Answers1

Linked