3
$\begingroup$

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

Improve this question
$\endgroup$
4
  • 1
    $\begingroup$ 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...) $\endgroup$
    – DaftWullie
    Jun 3, 2022 at 6:43
  • $\begingroup$ 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). $\endgroup$
    – unknown
    Jun 4, 2022 at 2:23
  • $\begingroup$ @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. $\endgroup$
    – Ian Gershon Teixeira
    Jun 4, 2022 at 13:15
  • $\begingroup$ @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. $\endgroup$
    – unknown
    Jun 4, 2022 at 15:01

1 Answer 1

Reset to default
1
$\begingroup$

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
Improve this answer
$\endgroup$
7
  • $\begingroup$ I would prefer an example which is error correcting (distance 3) not just error detecting (distance 2) if that's possible $\endgroup$
    – Ian Gershon Teixeira
    Jun 30, 2022 at 18:14
  • 1
    $\begingroup$ I edited the answer to add a d>2 example $\endgroup$
    – unknown
    Jul 2, 2022 at 17:42
  • 1
    $\begingroup$ 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. $\endgroup$
    – unknown
    Jul 2, 2022 at 21:26
  • 1
    $\begingroup$ 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$. $\endgroup$
    – unknown
    Jul 3, 2022 at 3:08
  • 1
    $\begingroup$ I added the logicals to the answer; this is just $H^\perp - H$; the weight is $5$ which is another check of the distance... $\endgroup$
    – unknown
    Jul 3, 2022 at 17:57

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.