Chapter 8 - Decoherence-Free/Noiseless Subsystems

Introduction

In the last chapter we saw that it is possible, at least in principle, to detect and correct errors in quantum systems. In this chapter a different method for protecting against errors is explored. This method encodes information into quantum states such that the information avoids errors. The information is encoded in such a way that it is invariant under the errors produced by the system-bath Hamiltonian. This requires the identification of a symmetry and then subsequently taking advantage of that symmetry. It turns out that there is one main advantage to this method of encoding against errors which was not initially a motivation for their study. In some important examples, the states can be used to enable universal quantum computing on a set of encoded states even when it is not possible on the set of physical states. This will be explored in Section 8.6 below, and further applications will be discussed in Chapter 10.

The initial work to find error-avoiding codes involved what are called decoherence-free subspaces. They were later generalized to subsystems. These terms are defined below and reviews may be found in Whaley/Lidar [19] and Byrd/Wu/Lidar [20]. Although there are alternative descriptions of decoherence-free subspaces and the subsystem generalization in terms of master equations (see Whaley/Lidar [19] and references therein), in this chapter the Hamiltonian description is used. This aids in the intuition behind these constructions and, as an introduction, this preferred here.

General Considerations

In what follows, a general quantum system will be assumed to be coupled non-trivially to a bath such that the entire system-bath Hamiltonian is given by

	$H=H_{S}\otimes I_{B}+I_{S}\otimes H_{B}+H_{I},\,\!$	(8.1)

where $H_{S}\,\!$ acts only on the system, $H_{B}\,\!$ acts only on the bath, and

	$H_{I}=\sum _{\alpha }S_{\alpha }\otimes B_{\alpha },\,\!$	(8.2)

is the interaction Hamiltonian with the $S_{\alpha }\,\!$ acting only on the system and the $B_{\alpha }\,\!$ acting only on the bath. The "error algebra" is denoted ${\mathcal {A}}\,\!$ and is the algebra generated by the set $\{H_{S},S_{\alpha }\}\,\!$. (In the words of Paulo Zanardi, these are all the bad things that can happen to the system.) The $S_{\alpha }\,\!$ obviously cause errors because they describe the interaction between the system and the bath. The reason the error algebra contains other terms is that when the system and bath together evolve unitarily, the exponential of the Hamiltonian $H\,\!$ gives products of the $S_{\alpha }\,\!$ with each other and also with $H_{S}\,\!$, and will be present in the unitary evolution. In the case that $H_{S}\,\!$ is identically zero, or we can remove it by changing basis (to a rotating frame), the problem simplifies to the consideration only of the algebra of the $S_{\alpha }\,\!$ or the modified $S_{\alpha }\,\!$ ($S_{\alpha }\,\!$ in the rotating frame) need be considered, respectively.

At this point, the objective is to find a set of states which will be immune to the errors which are present. Such states are identified using the error algebra. The way this is done is to put the algebra in a form which is block-diagonal. This type of algebra is said to be "reducible" which means that one may always block-diagonalize it. (See Appendix D.) Suppose that each element of the algebra can be put into the same block-diagonal form using a particular unitary transformation $U_{dns}\,\!$. Then for any element of the error algebra, $A_{\alpha }\,\!$, $U_{dns}A_{\alpha }U_{dns}^{\dagger }\,\!$ is block-diagonal. If the information is stored in states which are acted upon by these blocks, and only these blocks, then the information is protected because the information stays in the states which are defined by these blocks. If the blocks are $1\times 1\,\!$ blocks, i.e., $1\times 1\,\!$ submatrices, which are just numbers, then the states which make up such a system are called decoherence-free "subspaces". If the blocks are larger, then they are called decoherence-free subsystems, or noiseless subsystems.

In the next few sections, the examples will illustrate this construction and how the states are protected.

DNS Examples

The formal description for a DNS is quite useful for finding a suitable DNS given a particular set of errors. However, several examples are known which not only illustrate how one would use the general methods, but also provide examples of importance to experimental physics for reasons which will become clear later in this chapter. Familiarity with the addition of angular momenta will help understand the examples and then also the general formalism. References are Griffiths' book [4] (introductory) and Arno Bohm's book [21] (more advanced) and Appendix D which provides a basic introduction to group theory. However, the objective here is to provide the ideas and examples that will aid in understanding the key points of the theory.

Phase-Protected Two-Qubit Decoherence-Free Subspace

One of the simplest example of a decoherence-free subspace is a method for using two physical qubits to encode one logical qubit in such a way that the logical qubit is protected against phase errors which operate on both physical qubits in the same way. This is called a collective phase error.

Let us begin by assuming there is no system Hamiltonian and that the two physical qubits in the system are acted upon by the Hamiltonian

	$H_{cpe}=Z^{(1)}\otimes B+Z^{(2)}\otimes B=(Z^{(1)}+Z^{(2)})\otimes B,\,\!$	(8.3)

where $Z^{(i)}\equiv \sigma _{z}^{(i)}\,\!$ is a phase operator which acts on the $i\,\!$th qubit. This Hamiltonian acts the same on each of the two qubits to produce the same phase error on each. If we now choose our logical states to be

	$\left\vert 0_{L}\right\rangle =\left\vert 01\right\rangle ,\;\;\;\left\vert 1_{L}\right\rangle =\left\vert 10\right\rangle ,\,\!$	(8.4)

then our logical states will be given by

	$\left\vert \psi _{L}\right\rangle =a\left\vert 0_{L}\right\rangle +b\left\vert 1_{L}\right\rangle .\,\!$	(8.5)

If we now suppose that the system and bath are initially uncoupled, $\left\vert \Psi _{SB}\right\rangle =\left\vert \psi _{L}\right\rangle \otimes \left\vert \psi _{B}\right\rangle ,\,\!$ then the states, acted upon by the Hamiltonian $H_{cpe}\,\!$ gives

	$H_{cpe}\left\vert \Psi _{SB}\right\rangle =(0)\left\vert \psi _{L}\right\rangle \otimes B\left\vert \psi _{B}\right\rangle ,\,\!$	(8.6)

which gives a decoupled system and bath. This is clear since the exponential of this Hamiltonian gives the unitary evolution of the state. Thus

	$\exp(-iH_{cpe}t/\hbar )\left\vert \Psi _{SB}\right\rangle =(\left\vert \psi _{L}\right\rangle \otimes U_{B}\left\vert \psi _{B}\right\rangle ),\,\!$	(8.7)

where $U_{B}=\exp(-iBt/\hbar )\,\!$. This Hamiltonian acts as the identity on the logical states of the system. To be even more explicit, when one can trace out the bath degrees of freedom to find that the state of the system remains unchanged by this Hamiltonian. Thus the system has been encoded in such a way that this type of error does not adversely affect the state of the system. This allows for perfect storage.

It is perhaps worth emphasizing that this is a simple model of a particular type of decoherence which would ordinarily lead to collective phase errors on the system states. Such noise has also been called "weak decoherence." However, because the information is encoded, it is protected against these types of errors. In the language of a quantum error correcting codes, this is an infinite distance code since the error does not lead to an error no matter how long, or to what extent the error acts. In the next subsection we will see how this can be extended to collective errors acting on a number of qubits in an arbitrary way, not just codes that will protect against phase errors.

Four-Qubit Decoherence-Free Subspace

Consider a Hamiltonian which causes arbitrary collective errors on a collection of four qubits,

	${\begin{aligned}H_{ce4}&=a_{1}(X^{(1)}+X^{(2)}+X^{(3)}+X^{(4)})\otimes B\\&\;\;+a_{2}(Y^{(1)}+Y^{(2)}+Y^{(3)}+Y^{(4)})\otimes B\\&\;\;+a_{3}(Z^{(1)}+Z^{(2)}+Z^{(3)}+Z^{(4)})\otimes B,\end{aligned}}$	(8.8)

where $a_{1},a_{2},a_{3}\,\!$ are arbitrary constants. The standard procedure would be to find irreducible representations of the algebra of errors which is generated by the three collective errors

	${\begin{aligned}S_{x}&=X^{(1)}+X^{(2)}+X^{(3)}+X^{(4)}\\S_{y}&=Y^{(1)}+Y^{(2)}+Y^{(3)}+Y^{(4)}\\S_{z}&=Z^{(1)}+Z^{(2)}+Z^{(3)}+Z^{(4)}.\end{aligned}}$	(8.9)

Here again we are supposing that there is no system Hamiltonian, $H_{S}=0\,\!$.

The standard procedure would be to block-diagonalize the set of $S_{\alpha }\;\!$, which can be done. However, there are at least two other methods for identifying the decoherence-free subspace of states. One is to use the condition that we found in the last subsection that $S_{\alpha }\;\!$ acting on the states will give zero thus ensuring their invariance. This can be done by noticing that collective errors are angular momentum operators and that we could try to identify states which give zero when acted upon by these operators. A little thought would lead one to the conclusion that singlet states do not transform under the angular momentum operators since they have total angular momentum zero as well as the z-component of their angular momenta zero. Another way is to know from previous experience that the addition of angular momenta of four spin-1/2 particles will produce two singlet states. More generally, for collective errors, one may simply note that degeneracies in the representations may be used for the storage and manipulation of information. This allows one to use other techniques, such as the Young Tableaux, to identify such degeneracies. Still, this is a bit unsatisfying to those who are not familiar with any of these methods. For that reason, and also for generalizations, there does exist an algorithm for the identification of these systems which will be discussed later. For now, it will be shown that it is possible to construct states which are immune to this type of noise.

As stated, there are two singlet states in the tensor product of three two-state systems. These can be obtained by using the Wigner-Clebsch-Gordan coefficients for the addition of angular momenta. (There are many good reference for this in standard texts including Griffiths book [4] (introductory) and Arno Bohm's book [21] (more advanced).) The objective is to find linear combinations of the states of the two-state systems which will give singlet states. In standard spin notation the states of the two-state systems include the following basis elements:

	${\begin{aligned}&\left\vert 1/2,1/2,1/2,1/2\right\rangle ,\;\left\vert 1/2,1/2,1/2,-1/2\right\rangle ,\;\left\vert 1/2,1/2,-1/2,1/2\right\rangle ,\;\left\vert 1/2,1/2,-1/2,-1/2\right\rangle ,\\&\left\vert 1/2,-1/2,1/2,1/2\right\rangle ,\;\left\vert 1/2,-1/2,1/2,-1/2\right\rangle ,\;\left\vert 1/2,-1/2,-1/2,1/2\right\rangle ,\;\left\vert 1/2,-1/2,-1/2,-1/2\right\rangle ,\\&\left\vert -1/2,1/2,1/2,1/2\right\rangle ,\;\left\vert -1/2,1/2,1/2,-1/2\right\rangle ,\;\left\vert -1/2,1/2,-1/2,1/2\right\rangle ,\;\left\vert -1/2,1/2,-1/2,-1/2\right\rangle ,\\&\left\vert -1/2,-1/2,1/2,1/2\right\rangle ,\;\left\vert -1/2,-1/2,1/2,-1/2\right\rangle ,\;\left\vert -1/2,-1/2,-1/2,1/2\right\rangle ,\;\left\vert -1/2,-1/2,-1/2,-1/2\right\rangle ,\end{aligned}}\,\!$	(8.10)

which correspond to the computational basis states

	${\begin{aligned}&\left\vert 0,0,0,0\right\rangle ,\;\left\vert 0,0,0,1\right\rangle ,\;\left\vert 0,0,1,0\right\rangle ,\;\left\vert 0,0,1,1\right\rangle ,\\&\left\vert 0,1,0,0\right\rangle ,\;\left\vert 0,1,0,1\right\rangle ,\;\left\vert 0,1,1,0\right\rangle ,\;\left\vert 0,1,1,1\right\rangle ,\\&\left\vert 1,0,0,0\right\rangle ,\;\left\vert 1,0,0,1\right\rangle ,\;\left\vert 1,0,1,0\right\rangle ,\;\left\vert 1,0,1,1\right\rangle ,\\&\left\vert 1,1,0,0\right\rangle ,\;\left\vert 1,1,0,1\right\rangle ,\;\left\vert 1,1,1,0\right\rangle ,\;\left\vert 1,1,1,1\right\rangle .\end{aligned}}\,\!$	(8.11)

In the language of angular momentum, the objective is to change basis to obtain states of a given total angular momentum given by the standard angular momentum addition rules. For our purposes here, the transformation which takes these states to the new basis will be denoted $U_{dns}\,\!$ and is a unitary transformation corresponding to the collection of Wigner-Clebsch-Gordan coefficients. This is the matrix which will block-diagonalize all of the collective operators $S_{\alpha }\,\!$. Explicitly, the singlet states are

	${\begin{aligned}\left\vert s_{0}\right\rangle &={\frac {1}{2}}(\left\vert 0101\right\rangle +\left\vert 1010\right\rangle -\left\vert 1001\right\rangle -\left\vert 0110\right\rangle ),\\\left\vert s_{1}\right\rangle &={\frac {1}{\sqrt {12}}}(2\left\vert 0011\right\rangle +2\left\vert 1100\right\rangle -\left\vert 0110\right\rangle -\left\vert 1001\right\rangle -\left\vert 0101\right\rangle -\left\vert 1010\right\rangle ).\end{aligned}}\,\!$	(8.12)

One can show by explicit computation that

	$S_{\alpha }\left\vert s_{i}\right\rangle =0,\,\!$	(8.13)

for $\alpha =x,y,z\,\!$ and $0,1\,\!$. The two states $\left\vert s_{0}\right\rangle \,\!$ and $\left\vert s_{1}\right\rangle \,\!$ can now be used as logical zero and logical one for a logical qubit state which is immune to any collective error on the four physical qubits.

Three-Qubit Noiseless Subsystem

As stated in Section 8.2, subsystems have a more complex structure than subspaces which are, by definition, one-dimensional. The simplest DNS which protects against collective errors is comprised of three qubits. In this case there is a set of two states which represent the logical zero state and a set of two states which represent the logical one state as will be shown below.

The error operators $S_{\alpha }\,\!$ have the same form as Eq.(8.9), but with only three particles not four. In the language of the addition of angular momentum, total angular momentum states consist of two two-dimensional subsystems and one four-dimensional. The Wigner-Clebsch-Gordan coefficients can again be used as the DNS transformation to put the states into the DNS basis. After block-diagonalization the errors take the form

	$\left({\begin{array}{cc}A&0\\0&B\end{array}}\right),\,\!$	(8.14)

where the zeroes represent $4\times 4\;\!$ matrices of zeroes,

	$A=\left({\begin{array}{cccccccc}-a_{3}&a_{1}+ia_{2}&0&0\\a_{1}-ia_{2}&a_{3}&0&0\\0&0&a_{3}&a_{1}+ia_{2}\\0&0&a_{1}-ia_{2}&-a_{3}\end{array}}\right),\,\!$	(8.15)

and the form of $B\;\!$ is not relevant since it acts on the subspace orthogonal to the code space. The DNS transformation takes the vector of computational basis states

	$\left({\begin{array}{c}000\\001\\010\\011\\100\\101\\110\\111\end{array}}\right),\,\!$	(8.16)

to the new basis states

	$\left({\begin{array}{c}{\frac {1}{\sqrt {2}}}(\left\vert 010\right\rangle -\left\vert 100\right\rangle )\\{\frac {1}{\sqrt {2}}}(\left\vert 011\right\rangle -\left\vert 101\right\rangle )\\{\frac {1}{\sqrt {6}}}(2\left\vert 001\right\rangle -\left\vert 010\right\rangle -\left\vert 100\right\rangle )\\{\frac {1}{\sqrt {6}}}(-2\left\vert 110\right\rangle +\left\vert 011\right\rangle +\left\vert 101\right\rangle )\\\left\vert 000\right\rangle )\\{\frac {1}{\sqrt {3}}}(\left\vert 100\right\rangle +\left\vert 010\right\rangle +\left\vert 001\right\rangle )\\{\frac {1}{\sqrt {3}}}(\left\vert 011\right\rangle +\left\vert 101\right\rangle +\left\vert 110\right\rangle )\\(\left\vert 111\right\rangle )\end{array}}\right).\,\!$	(8.17)

Under collective noise the two states representing the logical zero, which are the first two states in the column, can be mixed together, as well as the two which represent the logical one in the next two entries in the column. However, the two sets, in other words the logical zero states and logical one states do not get mixed with each other. The last four states in the column are often referred to as the orthogonal subspace (to the code) which is denoted ${\mathcal {C}}^{\perp }\,\!$. In this case the states are not annihilated by the Hamiltonian as was the case in the first two examples above. However, the information is still able to be reliably stored in the subsystems without loss of information.

The next question which one might naturally ask is, how can one perform quantum computing on these states?

Quantum Computing on a DNS

It is perhaps surprising that one of the most intriguing and promising uses of a DNS encoding is for universal quantum computing rather than for avoiding noise. In some important cases, executing a complete set of universal quantum gates on physical qubits is impractical. However a DNS encoding can be used to enable universal quantum computing on the logical subsystem even when it is practical, or even not possible, on the physical qubits. In this section a general criterion and several examples are given to show exactly how this works.

Before proceeding, it is important to note that another use for DNS is as part of a comprehensive treatment of noise which involves other error prevention methods as well. Thus the DNS is not used as a method for the complete elimination of noise since noises are not often only collective and designing a DNS for noise which is not collective is difficult. Thus a DNS may be used to eliminate noise, and/or for encoded universality, while other noises are treated with other error prevention methods. (This is discussed more thoroughly in Chapter 10.) When quantum computing on a DNS, it is important to preserve the subsystem structure. Gating operations which preserve the subsystem structure do not take the states out of the protected subsystem during computation. Such operations are called compatible transformations. Before presenting explicit examples, a general criterion for how to construct gating operations on a DNS is given. (This result is from Kempe, et al. [23])

Let us consider an encoded state $\Psi \,\!$. If this state is in the DNS code space, then a stabilizer of the code, ${\mathcal {S}},\,\!$ can be defined for the subspace. This is the set of operations which leave a state unchanged. In the case of an encoded subsystem, the set of elements which leave the state unchanged is exactly the noise operators. This is due to the fact that the encoded states are chosen to avoid exactly that noise. Let a basis for the noise operators be $\{\Lambda _{i}\}\,\!$. The a stabilizer element $S\in {\mathcal {S}}\,\!$ can be parametrized using

	$S=\exp \left(\sum _{i}a_{i}\Lambda _{i}\right),\,\!$	(8.18)

for some parameters $a_{i}\,\!$. Since the stabilizer elements fix the code words, then

	$S\left\vert \Psi \right\rangle =\left\vert \Psi \right\rangle .\,\!$	(8.19)

For a unitary transformation to be compatible with the code, the unitary must not take the state out of the code space, which implies, for any $S_{1},S_{2}\in {\mathcal {S}}\,\!$,

	$US_{1}\left\vert \Psi \right\rangle =S_{2}U\left\vert \Psi \right\rangle ,\,\!$	(8.20)

so that acting before or after the transformation with any element of the stabilizer should give another state in the code space. For this to be true for $U=\exp(-iHt)\,\!$ all times $t\,\!$, a sufficient, but not necessary condition is given by

	$[H,S]=0,\,\!$	(8.21)

for all $S\in {\mathcal {S}}\,\!$. Though this is only a sufficient condition and therefore not the most general case, it is surprisingly useful as will be shown in the following examples.

Quantum Computing on a Collective DNS

Collective DNS are important for a variety of reasons. As mentioned above, they are useful for enabling universal quantum computing on a subspace when it is not possible on the entire physical Hilbert space. They are useful for describing motions of systems of particles in the so-called Dicke states. They are also useful for a particles which share a quantum channel (all particles travel down the same channel and are thus acted upon by the same noise) or for two people who are communicating without a shared reference frame. Thus having the ability to manipulate such systems is an important tool in the prevention of errors.

There is a nice analytic method for determining the compatible transformations on a collective DNS due to Bishop, et al [36]. We fist note that, according to Eq.(8.21) the Hamiltonian for the gating operations should commute with the stabilizer of the code. In this case, it means the collective errors because they leave the code fixed by design. It is interesting to note that if the collective errors include all types of errors (i.e. a complete basis) then they also form a representation of the algebra. It is known that operators which commute with all elements of an irreducible representation of the algebra (See Appendix D.) are the Casimir invariants of the group. The construction of such invariants for single particles, and for the fundamental irrep of the group is given by Gruber and O'Raifeartaigh [37].

Here we will use their construction but note that a linear combination of invariants is also invariant. Therefore, we will use their construction for the mutliparticle collective errors and then extract the single particle invariants. What is left is a multiparticle operator which will commute with the algebraic elements (collective errors) but act non-trivially on a subset. In this way, it is possible to construct all transformations which are compatible with collective errors regardless of the number of particles or whether they are qubits, qutrits, or qudits.

Let us first recall the form of the Casimir invariants for single particles. The most familiar is the quadratic Casimir, which for irreps of SU(2) is the square of the total angular momentum. This is usually written as

	$C_{2}=\sum _{\alpha }\lambda _{\alpha }\lambda _{\alpha },\,\!$	(8.22)

where the $\lambda _{\alpha },\,\!$ are elements of the Lie algebra. (For angular momenta these would be $J_{\alpha }^{(i)},\,\!$ and $i,\,\!$ is the spin of the particle.)

The higher dimensional Casimir operators are

	$C_{3}=\sum _{\alpha ,\beta ,\gamma }d_{\alpha ,\beta ,\gamma }\lambda _{\alpha }\lambda _{\beta }\lambda _{\gamma },\,\!$	(8.23)

where the $d_{\alpha ,\beta ,\gamma }\,\!$ are given in Eq.(D.21). The pattern follows from

	$C_{4}=\sum _{\alpha ,\beta ,\gamma }d_{\alpha ,\beta ,\gamma }d_{\gamma ,\delta ,\epsilon }\lambda _{\alpha }\lambda _{\beta }\lambda _{\delta }\lambda _{\epsilon },\,\!$	(8.24)

.

Now the collective error operators are given by

	$S_{\alpha }=\sum _{j}\lambda _{\alpha }^{(j)},\,\!$	(8.25)

where the sum is over the particles which are being acted upon by the collective noise.

The $\lambda _{\alpha },\,\!$ are now replaced in the Casimir construction by the $S_{\alpha },\,\!$. Then one extracts the single particle invariants, and/or all lower order invariants from the Casimirs constructed from these collective error operators to arrive at the compatible transformations. The first few lowest-order are given by

	${\begin{aligned}T_{2}^{(i,j)}&=\sum _{\alpha }\lambda _{\alpha }^{(i)}\lambda _{\alpha }^{(j)}\\T_{3}^{(i,j,k)}&=\sum _{\alpha ,\beta ,\gamma }f_{\alpha \beta \gamma }\lambda _{\alpha }^{(i)}\lambda _{\beta }^{(j)}\lambda _{\gamma }^{(k)},\\T_{3}^{(i,j,k)}&=\sum _{\alpha ,\beta ,\gamma }d_{\alpha \beta \gamma }\lambda _{\alpha }^{(i)}\lambda _{\beta }^{(j)}\lambda _{\gamma }^{(k)},\end{aligned}}\,\!$	(8.26)

where again the $i,\,\!$ is the particle index, and $d_{\alpha ,\beta ,\gamma }\,\!$, $f_{\alpha ,\beta ,\gamma }\,\!$ are given in Eq.(D.21).

Certainly the two-body interactions are more important for experimental implementations of quantum information processing. However, this provides us with a description of all transformations which commute with collectives noise independent of the number of particles or the dimensions of the subsystems. Therefore, as stated in the introduction, these transformations have a wide range of uses.

An Algorithm for Finding Compatible Gates

Here an algorithm is given which will ensure that Hamiltonians, if they exist, will be found that satisfy Eq.(8.21). The algorithm can be used to with any dimension of the input states and also any number of particles. It can easily be coded into a numerical algorithm on any system or analytical calculations can be done on Mathematica.

Let us begin with notation. $H\,\!$ is the Hamiltonian. $\mu _{ijk}\,\!$ is a complete set of Hermitian matrices in terms of which any Hermitian matrix can be expanded. The $S_{i},\,\!$ form a basis for the stabilizer of the system, and $\sum _{i}g_{i}S_{i},\,\!$ is an arbitrary linear combination of those stabilizer elements. $a_{ijk}\,\!$ is a set of real numbers.

1. Expand $H\,\!$ in terms of the complete set of Hermitian matrices $\mu _{ijk}\,\!$ described above: $H=\sum _{ijk}a_{ijk}\mu _{ijk}\,\!$.
2. Determine the commutator of the general Hamiltonian $H\,\!$ and a generic collective error $\sum _{i}g_{i}S_{i},\,\!$ where the $g_{i}\,\!$ are arbitrary coefficients. In other words, calculate $[H,\sum _{i}g_{i}S_{i}].\,\!$
3. Find the projection of $\left[H,\sum _{i}g_{i}S_{i}\right]\,\!$ onto a component $\mu _{ijk}\,\!$ by taking the trace of the basis element $\mu _{ijk}\,\!$ with the result of (2). In other words, calculate ${\text{Tr}}\left(\left[H,\sum _{i}g_{i}S_{i}\right]\mu _{ijk}\right)\,\!$ for each $\mu _{ijk}.\,\!$
4. Set all of the projections equal to zero and then solve the system of linear equations for the expansion coefficients $a_{ijk}\,\!$ which satisfy these relations, thereby determining the $H\,\!$ which will commute with $\sum _{i}g_{i}S_{i}.\,\!$

The resulting Hamiltonian will commute with the stabilizer elements and so can be used for compatible gating operations. Note that these are sufficient conditions, but not necessary conditions and that we are not guaranteed to obtain a universal set of gating operations.

QC Examples

In quantum dot quantum computing proposals, single qubit rotations are much slower than two-qubit operations which use the Heisenberg exchange interaction. Therefore any quantum computing proposal which could use only exchange and forgo the much slower single physical qubit rotations would be a great advantage. Here, several examples are given which do just this, therefore saving a great deal of time by enabling operations which are much faster than would otherwise be required.

Phase-Protected DFS

Recall the phase-protected DNS which was discussed in Section 3.1,

$\left\vert 0_{L}\right\rangle =\left\vert 01\right\rangle ,\;\;\;\left\vert 1_{L}\right\rangle =\left\vert 10\right\rangle .\,\!$

Logical operations on this subspace can be performed using

	$H_{xy}^{1,2}=X_{1}X_{2}+Y_{1}Y_{2},\,\!$	(8.27)

where $X_{1}\,\!$ is the Pauli x-operation on the first qubit and similarly for the other operators. The logical $X\,\!$ operation, denoted ${\bar {X}}\,\!$, is given by

	${\bar {X}}=\exp(-i\pi H_{xy}).\,\!$	(8.28)

A logical $Z\,\!$ is given by

	${\bar {Z}}=Z_{1}-Z_{2},\,\!$	(8.29)

which is a Zeeman splitting which can be always on and is due to an external magnetic field. Given ${\bar {X}},\,\!$ and ${\bar {Z}},\,\!$, any single qubit rotation may be implemented using the Euler angle parametrization. A logical two-qubit entangling gate, ${\bar {ZZ}},\,\!$ can be implemented using the same Hamiltonian $H_{xy}.\,\!$ Suppose physical qubits 1 and 2 are used to encode logical qubit 1 and physical qubits 3 and 4 are used to encode logical qubit 2, then

	${\bar {ZZ}}=Z_{2}Z_{3}.\,\!$	(8.30)

The corresponding diagram is shown in Fig. 8.1.

Figure 8.1: Diagram showing the two-qubit DFS encoded states. Each circle contains one physical qubit. Each solid ellipse shows one logical qubit comprised of two physical qubits. The dotted ellipse shows the action of a logical two qubit gate which would act between neighboring physical qubits and simultaneously between two logical qubits.

Four-Qubit DFS

The Heisenberg exchange interaction Hamiltonian between two qubits labelled $i\,\!$ and $j\,\!$ is

	$H_{ex}^{i,j}=X_{i}X_{j}+Y_{i}Y_{j}+Z_{i}Z_{j},\,\!$	(8.31)

where, again $X_{i}\,\!$ is the Pauli x-operation on the $i\,\!$th qubit and similarly for the other operators. The exponential of the exchange operation between qubits $i\,\!$ and $j\,\!$ for a time $\pi /4\,\!$ gives an operator $E_{ij}=I+X_{i}X_{j}+Y_{i}Y_{j}+Z_{i}Z_{j},\,\!$ which acts to swap the states $E_{ij}\left\vert i\right\rangle \left\vert j\right\rangle =\left\vert j\right\rangle \left\vert i\right\rangle \,\!$. Logical operations can then be given in terms of this operator. The logical $X\,\!$ operator is given by

	${\bar {X}}={\frac {1}{\sqrt {3}}}(E_{23}-E_{13})\,\!$	(8.32)

and the logical $Z\,\!$ is given by

	${\bar {Z}}=-E_{12}.\,\!$	(8.33)

From these, the logical $Y\,\!$ operation can be obtained by commutation or using an Euler angle parametrization.

Three-Qubit NS

Again, using $E_{ij},\,\!$ the logical $X\,\!$ operation can be written as

	${\bar {X}}={\frac {1}{\sqrt {3}}}(E_{23}-E_{13}),\,\!$	(8.34)

and the logical $Z\,\!$ operation can be written as

	${\bar {Z}}={\frac {1}{3}}(E_{13}+E_{23}-2E_{12}).\,\!$	(8.35)

Continue to Chapter 9 - Dynamical Decoupling Controls