I have been working with stabilizer codes and I understand the mathematical way that they are described and how to simulate such in a classical computer in order to check their performance.

However, lately I have been wondering how this class codes would be implemented physically in terms of Clifford gates in an actual quantum computer. I have not found much about such mapping in the literature, and less of an actual general algorithm (most of the things I have found are just examples, and not general algorithms that realize the task). Can anyone give some insight about this circuit synthesis problem? Are there any general algorithms that realize this circuit synthesis? Are there optimized versions?

  • $\begingroup$ Which stabilizers are you thinking of? I thought many stabilizers are implemented in terms of Paulis and are relatively straightforwards $\endgroup$ – C. Kang Aug 8 '20 at 5:44
  • $\begingroup$ Implementing stabilizer circuits in terms of Clifford gates. $\endgroup$ – Josu Etxezarreta Martinez Aug 24 '20 at 7:29
  • $\begingroup$ Yes - what I'm trying to say is that most common stabilizers are already in terms of Paulis / H / CNOT, which are Clifford, so their implementation is already straightforwards. Which stabilizers are you thinking of? $\endgroup$ – C. Kang Aug 24 '20 at 14:55
  • $\begingroup$ What I am thinking of is to create a circuit consisting of H/CNOT/Phase (Clifford group) that does actually transform the input stabilizer (which is trivial as it is uncoded) into the desired stabilizer state. I do not see why you say that it is straightforward, could you give an example? $\endgroup$ – Josu Etxezarreta Martinez Aug 25 '20 at 7:45
  • $\begingroup$ Are we talking about the same stabilizers? For example, the code provided here is just Paulis. $\endgroup$ – C. Kang Aug 25 '20 at 15:10

Well, it seems that the question is still unanswered. In general, there are different ways of encoding, but -- as I understand it -- you are asking for a unitary way of doing it.

Suppose we have a $[[n,k]]$ stabiliser code $C$ with generators $g_1,\dots,g_{n-k}$. This code is Clifford-equivalent to the code $\mathsf{Z}_k:=|0^{n-k}\rangle\otimes (\mathbb{C}^2)^{\otimes k}$ stabilised by $Z_{1},\dots, Z_{n-k}$. The encoding construction is given by a choice of Clifford unitary mapping $\mathsf{Z}_k$ to $C$.

In general, this Clifford unitary $U$ is not unique since we can redefine it by any Clifford $V$ which acts trivially on $\mathsf{Z}_k$ (or $C$ respectively). However, any choice of stabiliser basis of $C$ induces a $U$. This is simply because a choice of logical basis $|\bar x\rangle$ corresponds to a maximal completion $g_1,\dots,g_{n-k},g_{n-k+1},\dots,g_n$ of the generators and the logical basis is determined by the eigenvalues of $g_{n-k+1},\dots,g_n$. The Clifford unitary $U$ is defined by the following equations: $$ U Z_i U^\dagger = g_i, \qquad \forall i = 1,\dots,n. $$ Since the Paulis on the left and right hand side are maximally commuting sets, this indeed defines a Clifford unitary $U$. It is straightforward to check that any input state is transformed as $$ |0^{n-k}\rangle\otimes |\psi\rangle = \sum_{x\in\mathbb F_2^{k}} \psi_x |0^{n-k}\rangle\otimes |x\rangle \stackrel{U}{\longmapsto} \sum_{x\in\mathbb F_2^{k}} \psi_x |0^{n-k}\rangle\otimes |\bar{x}\rangle. $$

Final remarks:

  1. The binary/symplectic description of the global Clifford unitary $U$ is evident from the definition.
  2. This can be used to compile $U$ into generators via standard methods.

As narrowed down in the comments, the focus of my answer is on the process of encoding an arbitrary state, so that when an error occurs it may be corrected. (Source for the diagrams / info)

My understanding is that the Hamming parity check matrix is used to determine the encoding unitary. Consider the [[7, 1, 3]] Steane code, which has the following parity matrix:

Parity matrix

And the associated circuit:

Circuit for encoding scheme of [[7, 1, 3]]

So, the first three qubits correspond with the first three columns of the parity check matrix. This enables us to yield a superposition where the first three qubits range from 0-3, and the last four qubits have maintained their parity.

One open question for me remains, namely in the necessity for the repetition code to begin with. Answers/edits on this front appreciated!

  • $\begingroup$ Yeah, that is an example of what I am asking about. However, it is a particular circuit for a particular code. The real question is if there is a general algorithm that takes the parity check matrix (i.e. the stabilizers) of any stabilizer code as input and outputs an encoding circuit in terms of Clifford gates. $\endgroup$ – Josu Etxezarreta Martinez Aug 27 '20 at 7:54
  • $\begingroup$ This is the one: you need to reframe the parity check matrix so that the first few columns are the unit vectors. Then, CNOT from those unit vector bits to the main body bits $\endgroup$ – C. Kang Aug 27 '20 at 17:08
  • $\begingroup$ What about the rotation gates and the first cNOT? Additionally, the parity check matrix you put is classical, if you see the quantum parity check matrix of the Steane code, it is constructed as a CSS code with such $H$ parity check matrix used twice. $\endgroup$ – Josu Etxezarreta Martinez Aug 28 '20 at 8:08
  • $\begingroup$ The CNOT gates are cliffords, and the rotation gates stated are explained as Hadamards in the paper $\endgroup$ – C. Kang Aug 28 '20 at 15:32
  • $\begingroup$ For your second question, it does seem like that even though the classical matrix is repeated in the quantum parity check matrix, that the single classical check is used for the encoding process $\endgroup$ – C. Kang Aug 28 '20 at 15:42

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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