Minimal noise subsystems

(1)

Minimal noise subsystems

A numerical way to minimize decoherence for a qubit

Stanley Kelder

student number: 10313540

June 2017

Report Bachelor Project Physics and Astronomy, 15 EC, conducted between 01-02–2017 and 12-06–2017

Date of submission: 16-06-2017 Daily supervisor: Joris Kattem¨olle Official supervisor: Ben Freivogel Second assessor: Jasper van Wezel Institute: QuSoft

Faculty: FNWI

(2)

Abstract

Qubits are affected by noise from their environment. To avoid this, the qubits are encoded. If the noise possesses a certain symmetry, the qubit can be com-pletely protected by correct encoding. The qubit is then encoded in a noiseless subsystem. If this symmetry is perturbed, such a noiseless subsystem does not exist. We can then still minimize the effect of the noise, encoding it in a minimal noise subsystem. Based on a paper by Wang, Byrd and Jacobs [9], we used a hill climbing algorithm to numerically calculate the encoding for such a minimal noise subsystem. As a check, the algorithm correctly found an encoding in a noiseless subsystem. After this the algorithm found an encoding for a mini-mal noise subsystem for three different perturbations. This physically relevant perturbed noises and their results are shown. The algorithm could be further developed by making it capable to work with more qubits.

(3)

Quantumcomputers lijden aan geheugenverlies

De quantumcomputer is de belofte van de toekomst. Als het lukt om een quan-tumcomputer te maken dan kan die berekeningen doen die alle huidige com-puters bij elkaar nog niet kunnen. Er is alleen nog ´e´en belangrijk probleem dat moet worden opgelost voordat we aan de quantumcomputer kunnen gaan bouwen: het geheugenverlies van de quantumcomputer.

Informatie wordt op een quantumcomputer opgeslagen op een qubit, het equivalent van de bit op de huidige computer. Het probleem van het geheugen-verlies van de quantumcomputer is dat de qubit, die we in een bepaalde waarde opslaan, na een heel korte tijd al van waarde is veranderd. Dit komt doordat de qubit zo gevoelig is dat deze altijd invloeden ondervindt van zijn omgeving. Er is een manier bedacht om deze verandering tegen te gaan. Om de qubit te beschermen nadat we informatie erop hebben opgeslagen, worden er twee extra qubits toegevoegd. Deze twee extra qubits hebben geen informatie en hun enige doel in het leven is het beschermen van onze qubit met informatie. De drie qubits samen worden ge¨encodeerd, op dat moment kan niet meer worden gezien waar de informatie zit. Deze drie ge¨encodeerde qubits worden als geheel aange-tast door hun omgeving. Na een bepaalde tijd decoderen we alles weer en zien we hoe de qubits zijn aangetast. De twee beschermende qubits zijn niet meer belangrijk en gooien we weg, waardoor de qubit met informatie weer als enige over is. Deze qubit is onveranderd gebleven als de twee beschermende qubits alle aandacht van de omgeving naar zich toe weten te trekken. Dit kan lukken met de juiste encodering. Weten we deze encodering te vinden, dan hebben we de qubit goed beschermd en onze informatie goed kunnen opslaan. In dit project is een algoritme gemaakt dat deze juiste encodering vindt.

De juiste encodering bestaat echter alleen als de omgeving aan bepaalde eisen voldoet. In werkelijkheid zal de omgeving niet aan deze eisen voldoen. Hierom is ook een model gemaakt dat meer op de werkelijkheid lijkt. Het al-goritme is zo gemaakt dat het bij dit model nog steeds een goede encodering vindt. De qubit met onze informatie blijft dan niet geheel onveranderd, maar de veranderingen worden wel tot een minimum beperkt.

Verder onderzoek zal ervoor moeten zorgen dat de kleine verandering die nog plaatsvindt wordt gecorrigeerd en dat de qubit langere tijd beschermd kan blijven. Als dat lukt zijn we een aanzienlijke stap dichter bij de realisatie van de quantumcomputer!

Figure 1: Als er een juiste encodering wordt gevonden dan blijft de qubit met informatie onveranderd.

(4)

Introduction

All of the articles about noiseless subsystems that are quoted in this article agree about the importance of the topic of decoherence in today’s researches on quantum computers. They even all start in the same way. “Defending quantum coherence of a processing device against the environmental interactions is a vi-tal goal for any foreseeable practical application of Quantum Information and Quantum Computation theory” [10], “one problem which particularly plagues quantum computers is ... [the] destruction of the quantum information in the computer through the process known as decoherence” [1] and “decoherence re-mains the most important obstacle to the exploitation of the speedup promised by quantum computers” are just three examples [5].

Decoherence basically comes down to the following: quantum computers suffer from short term memory loss. We want to save something on a quan-tum computer, but when we read out this information after some time to see what we had saved, our previously saved information is not the same anymore. The information we store on our quantum computer changes to something else, which, for the moment, makes saving information on a quantum computer, even for a very short time, undesirable.

The instrument used to save something on a quantum computer is a qubit. A qubit is the basic unit of information in a quantum computer, just like a bit is in a classical computer. Other than a classical bit always being in one of two possible states, a qubit is in a superposition of two states. The state a qubit is in is a linear combination of two states, usually denoted as |0i and |1i with Diracs bra-ket notation [2]. The state of a qubit is then given by |ψi = α |0i + β |1i, where α and β are probability amplitudes, and α2_{+ β}2_{= 1. As time passes by,}

the values of α and β change due to the decoherence of the qubit.

Present day investigations try to solve this problem of decoherence in two different ways, called error correcting and error avoiding. In the area of error correcting people seek for a way to get the qubit back in the same state as it was saved. This is done by keeping track of the changes happening to the qubit, so that the changes can be undone the moment we read out our qubit of information from memory [4].

In this project we are investigating error avoiding. In this area we try to protect a qubit in such a way that it never changes, and thus still has the same state some time after we have saved our information to the qubit. The following scheme briefly shows how this is done:

1. Add two extra qubits to our logical qubit

The qubit we store our information to is called the logical qubit. To this logical qubit we add two extra qubits, which do not have information saved on them. The logical qubit together with the two added extra qubits form our 3-qubit system.

2. Encode the 3-qubit system

(6)

some-one would have a look at our qubits at this moment, he or she would not know what information was saved to the logical qubit.

3. Wait for a while

The information is saved to memory, so we now wait for some time, after which retrieve the information back from memory. While we wait, the environment around the qubits is affecting our 3-qubit system.

4. Decode the 3-qubit system

When we are done waiting we decode the system by rotating and phase-shifting the qubits back the same as we did when encoding the qubits. We can now see how much our 3-qubit system has changed.

5. Remove the two extra added qubits

Since our information is only saved to the logical qubit, we do not care about the changes of the other two qubits. Our goal is to find the logical qubit back in the same state as we have saved it in.

It might seem a bit of a hustle to add two qubits just to throw them away again later on, but these extra two qubits are essential in protecting our logical qubit. If we could just switch off the environment around the qubits we would not have to go through all this effort, but the environment can not be turned off and will always affect our qubits. We thus add the two extra qubits and then encode our 3-qubit system to direct the effect of the environment to this two extra qubits for protection. To do this effectively we need to use an encoding for which all effects from the environment on the system affect the two extra qubits, and the logical qubit remains unaffected.

It is shown that, under certain conditions of symmetry for the environment, it is possible to encode the 3-qubit system in such a way that the logical qubit remains unaffected [8, 9]. In this project we have developed an algorithm to numerically find an effective encoding to protect the logical qubit. Such an algorithm was also created by Wang, Byrd and Jacobs [9], and we were able to verify the results presented by them.

After we had verified that our algorithm was working correctly, we let it search for an encoding in different cases where the conditions of symmetry for the environment were not met. In these cases it is not possible to fully protect the logical qubits from the effects of the environment, but the algorithm was still able to find the optimal encoding to protect the qubit as much as possible for these cases.

Theoretical framework

From one logical qubit to a 3-qubit system

The state of our logical qubit, the qubit to which we save our information, is given by |ψi = α |0i + β |1i, where α and β are probability amplitudes, and α2+ β2= 1. We get the density matrix of this state by taking the outer product with its Hermitian conjugate ρs= |ψi hψ|. We now have a 2-dimensional state

(7)

ρq from one qubit and wish to save this state to memory.

We now add two extra qubits, which we call the ancilla system. Since no information will be saved to our ancilla qubits, we can choose the initial state they are in. For the ancilla qubits we choose α = 1 and β = 0. The state of our ancilla system, the two ancilla qubits combined, is then ψa = |0i ⊗ |0i =

|00i. The density matrix ρa = |00i h00| for this ancilla system is 4-dimensional

and adding it to our 2-dimensional state of our logical qubit will yield an 8-dimensional system given by

ρs= ρq⊗ |00i h00| . (1)

As said, this system ρsis inevitably coupled to some exterior environment.

The total Hilbert space is therefore given by the Hillbert space of the system and the Hillbert space of its environment combined:

Htot= HS⊗ HE, (2)

where HS is the Hillbert space of the system ρsand HE is the Hillbert space of

the environment [1]. Noise on the system space

As time passes by there is some influence from the environment on the initital state ρs. This so called noise evolves the initial state of the system to a new

state at time t: ρs(0) → ρs(t). The operator-sum representation (OSR) is used

to describe such an evolution: ρs(t) =

X

i

Ai(t)ρs(0)Ai(t)† (3)

where the operators Ai are constrained by

X

i

Ai(t)†Ai(t) = 1. (4)

The operators Ai(t) are called Kraus operators and the operator-sum

represen-tation is sometimes called the Kraus represenrepresen-tation [1, 7]. The challenge of decoherence

In the ideal world ρs(t) would be the same as ρs(0), or ρs(t) − ρs(0) = 0, since

then we could just simply read out the state we have saved to memory and we do not have to worry about anything. Unfortunately, this could only be the case if all operators Ai do not affect the system space. Since our system is coupled

to the environment this can not be the case, which means ρs(t) − ρs(0) 6= 0.

But this is not the entire story. In this ideal world just sketched it would be rather cumbersome to add an ancilla system to our qubit, because in the end we are only interested in the state of the qubit. To know what actually happened to our original qubit we should trace out the ancilla system

(8)

Since we trace out the ancilla system, this means that, as long as the operators Ai act only on the ancilla system, we could still have that nothing happened

to our original state ρq. Unfortunately we do not control the environment and

we are not free to choose the operators Ai. This means that in practice we still

have ρq(t) 6= ρq(0). The process of this time-evolution on the original qubit

is called decoherence and is one of the most important obstacles to overcome before we could build an effective quantum computer [5]. Dave M. Bacon even called this decoherence “the pain of isolating quantum information”[1].

Noiseless subsystems

There is a way around this decoherence. We can not freely choose the opera-tors in (3), but for a given set of operaopera-tors we can try to find an encoding for ρs(0) so that the set of operators only affects the ancilla system and not the

logical qubit. If we have a unitary encoding operator U , our encoded state of the system will be

ρe= U ρsU† (6)

and its evolution will be given by ρe(t) =

X

i

Ai(t)U ρs(0)U†Ai(t)†. (7)

If we decode the evolved state again, using the same operator U , we have ρs(t) =

X

i

U†Ai(t)U ρs(0)U†Ai(t)†U. (8)

The state of the qubit is then ρq(t) = tra(ρs(t)) =

X

i

tra[U†Ai(t)U ρs(0)U†Ai(t)†U ]. (9)

We want to find an operator U for which the system is encoded in such a way that the environment only affects the ancilla system. If we find a U that does this exactly, it means that we find our original state after we trace out the ancilla system

ρq(t) = ρq(0) , for perfect U . (10)

In such a case ρq is set to be in a noiseless subsystem or NS [6].

Hope for nothing1

The question then is how to find a U for which ρq is encoded in an NS. There is

a way to write the OSR such that A0 corresponds to the identity. In that case

the OSR can be rewritten as

ρ(t) = p0ρ(0) +

X

i6=0

Ai(t)ρ(0)Ai(t)†, (11)

(9)

where p0 denotes the chance of nothing happening with 0 ≤ p0≤ 1.

We are interested in the case where nothing is happening to our original qubit. To be able to calculate this we expand A0_i(t) as

A0i(t) = X i,j cijσ (q) i ⊗ σ (a) j , (12) with cij = tr[σ (q) i ⊗ σ (a) j A 0 i(t)], (13)

where A0_i(t) = U†Ai(t)U , and σ(q) and σ(a) are the set of generalized

Pauli-matrices or generalized Gell-Mann Pauli-matrices acting on the space of the qubit and the space of the ancilla system respectively and σ0 is the normalized identity

operator. These sets are orthonormal:

tr(σiσj) = δij. (14)

Because we are interested in the situation where nothing is happening to the qubit, we set i = 0. If we then insert (12) and (13) into (9) and compare this to (11), we find an expression for p0:

p0= 1 4 X i,j,j0 tr[1(q)⊗ σ(a)_j A0i(t)] tr∗[1(q)⊗ σ (a) j0 A 0 i(t)] h00| σ (a) j σ (a) j0 |00i . (15)

If we can find a U such that p0 = 1, we have found a way to encode our

system in such a way that nothing is happening to our original logical qubit. In that case we can save information to our qubit and we do not have to worry about the saved information being changed over time.

Minimal noise subsystems

Finding an encoding into an NS is not always possible. For there to exist an NS there must be a certain symmetry in the coupling of the system and the environment [5, 9, 10]. If this symmetry does not exist, or if it is perturbatively broken, we could still maximize p0. The qubit is then not said to be in a noiseless

subsystem, but in a Minimal Noise Subsystem or MNS [9]. In an MNS, the sys-tem is encoded in such a way that the environment least affects the logical qubit.

Methods

The noise

The goal of this project is to develop an algorithm to numerically maximize p0 when the symmetry of the noise is perturbed. To make sure the algorithm

works correctly it is first checked on a noise with symmetry, to see if the results are as expected. After all, we know that for such a noise p0 should maximize to

the value 1.

(10)

operators Ek in the OSR, denoting the ‘error’ on the system. This means the

OSR from (3) will now be ρs(t) =

X

k

Ek(t)ρs(0)E†k(t). (16)

Based on the paper by Wang, Byrd and Jacobs [9], we initially choose these error-operators to be E3= √ tSz E2= √ tSy E1= √ tSx (17) E0= 1 − E32 2 − E22 2 − E12 2 ,

where Sz, Sy and Sxare the total spin in the z, y and x direction respectively.

The total spin operators act the same on all three qubits in the system, mak-ing this errors in accordance with the symmetry condition for the environment. And indeed we know that for this set of operators there exists an NS [8, 9].2

The error-operators in (17) are based on the Lindblad operators and hold for infinitesimal t [9]. We should thus maximize p0at a time t that is small enough

for these error-operators to hold, but at the same time big enough for the error to take place. To comply to both these constraints we have set t = 1

1024 in this project.3

Calculating the chance of nothing happening

To be able to do the calculations some preparation was needed. Using the pack-ages numpy, to be able to do different sorts of mathematical calculations, and QuTip, to be able to calculate the tensor product and the partial trace, it was possible to introduce the total spin, the generalized Gell-Mann matrices and the error operators to the calculation. For a given encoding matrix U , p0could

then be calculated in p0= 1 4 X k,j,j0 tr[1(q)⊗ σ(a)_j E_k0(t)] tr∗[1(q)⊗ σ(a) j0 E 0 k(t)] h00| σ (a) j σ (a) j0 |00i , (18)

where E_k0(t) = U†Ek(t)U . (This is the same equation as (15), but the operators

Ai are replaced for the error-operators, see (15) for an explanation of all

sym-bols.)

On the first try it took the algorithm about 5 seconds to calculate p0 for

2_{Joris also analytically calculated an encoding matrix which encodes ρ}

qin an NS for this

set of error-operators.

3_{Because computers work on bits, calculations with powers of 2 tend to be more exact and}

(11)

a given U . Since p0 was going to be maximized, it was going to be

calcu-lated a lot of times and thus needed to be calcucalcu-lated fast. The calculation of p0 was optimized first by removing all combination of j and j0 for which

h00| σ(a)_j σ_j(a)0 |00i = 0 in (18). Then the calculation was optimized further by

using smarter code to do all calculations. After all optimizations p0, for a given

U , was calculated in 4 · 10−4 seconds.

The encoding matrix

To maximize p0 we want iterate over different U ’s. To this goal we want to

parameterize U . The parameterization from [3] is used to get a parameteriza-tion in terms of 1

2N (N + 1) phase variables and 1

2N (N − 1) angle variables.

4

Now that we have N2 real parameters, we can iterate over this parameters to perform a gradient search and that way try to find a maximum value for p0.

Pseudocode

The way the program maximizes p0is described in the following pseudocode.

create random set of phase and angle variables for some time do

take biggest step up if p0not increased then

try smaller stepsize end if

end for

Where the biggest step is calculated each time by the following part of the al-gorithm:

for all variables do

adjust variable by small step create new U

calculate p0 with new U

if p0increased then

save new p0

save list with new variable as best list end if

end for Hill climber

In other words: the algorithm looks around in the space of U and moves in the direction were the gradient upward is steepest for a certain step size. If all gradients are downward, a smaller step size is tried. The algorithm stops after a

(12)

certain amount of iterations or when the step size gets smaller than 1 210.

5 _This

type of algorithm is called a hill climber.

The advantage of using a hill climber is that they converge to a maximum relatively fast. The downside of using a hill climber is that it can get stuck in a local maximum. There exist other algorithms that minimize the chance of getting stuck in a local maximum. However, these algorithms have to do more calculations, which is not desirable for the space of 64 dimensions we are working with.

Since we know that p0 maximizes to 1 for the set of error-operators in (17)

we can check whether the algorithm seems likely to find the global maximum. In this regard the algorithm was run multiple times with different randomly generized U ’s. In all cases p0 maximized to 0.9999 < p0< 1. Based on this we

assume that there is a high degeneracy in U . This assumption is also backed by [9].

Perturbing the noise

Now we want to see if the algorithm finds such an MNS. And we want to see what happens to p0 if we break the symmetry of the noise by perturbing it.

As said, the encoding for this MNS should yield a higher chance of nothing happening when the noise is perturbed than if the encoding found for the NS is used for the perturbed noise.

The perturbations are added as an extra noise operator in (17). The extra noise operator E4 is also added to the equation of E0, which becomes

E0= 1 − E2 4 2 − E2 3 2 − E2 2 2 − E2 1 2 . (19)

In this project there are three perturbations being investigated.6 _{The first}

perturbation is an Ising-like effect and resembles the interaction of the spins in the z-direction for the qubits lying on a line and is

√t(σz1σz2+ σz2σz3). (20)

The second perturbation resembles the Heisenberg nearest neighbor interaction for qubits lying on a line:

√t(σz1σz2+ σz2σz3+ σy1σy2+ σy2σy3+ σx1σx2+ σx2σx3). (21)

The third perturbation resembles the effect of an electromagnetic wave passing by and is

√t(σz1− σz2+ σz3). (22)

In these equations denotes the strength of the effect of the perturbation on the noise, σx,y,z denote the pauli-x, y, z matrices, where the extra subscript of

1, 2 or 3 specifies the qubit it acts on, and t denotes the time.

5_{The algorithm never got to the point it tried a step size this small.}

(13)

Results

For each perturbation the algorithm maximized p0 for every =

n

10, for n an integer from 1 up to 15. The results are plotted below.

There are four lines in each plot. One line shows the values of p0 for the

case where a different U for each = n

10 maximized p0. This resembles the case where the perturbation of the noise is known beforehand. As expected, the chance of nothing happening is higher when the perturbation is known before-hand than when the perturbation is unknown.

The second line resembles a line where an encoding U is used that maxi-mized p0 for = 1. With this same U the chance of nothing happening is then

calculated for other values of .

The third and fourth line resemble encoding U ’s that maximized p0 in case

of no perturbation on the error. One of these lines is for a U that is numerically calculated by the algorithm, the other one is for the U that was calculated an-alytically.

Ising-like nearest neighbor interaction and electromagnetic wave

Figure 2: Plots for Ising-like nearest neighbor interaction and an electromagnetic wave passing by.

The shapes of the plots for the Ising-like model and the electromagnetic wave passing by are similar. We see that the encoding for an NS found by the algo-rithm has a slightly higher chance of nothing happening than the analytically determined encoding. As expected, the chance of nothing happening is higher when a new U is found by maximizing p0 for a perturbed noise.

When we know the perturbation, the algorithm can find us an encoding so that we can maximize the chance of nothing happening to the qubit. However, if we know there is some perturbation on the error, but we do not know how strong this perturbation is, we could still be better off using an encoding for an MNS than if we would stick with the encoding for the NS. As we see in the plots, the encoding U for = 1 does not only perform better than the encoding

(14)

U for the NS at = 1, but also around that point. For all values of > 0.5, the encoding U for = 1 performs better than the encoding U for the NS.

Heisenberg nearest neighbor interaction7

Figure 3: Plot for the Heisenberg nearest neighbor interaction.

We would expect the plot of the Heisenberg nearest neighbor interaction to have the same shape as the plots for the Ising nearest neighbor interaction and the electromagnetic wave, but we see that this is not the case. It appears that the algorithm got stuck in a local maximum.

Of course, it should not be possible that the encoding U for = 1 has a bigger chance of nothing happening on = 0.8 and = 0.9 than when p0 is

maximized at these points. A reason that this did happen for this perturbation could be that the algorithm was run only once for each maximization, whereas multiple different starting points should be tried to avoid local maxima. What the algorithm did for this plot was using the encoding U for the NS ( = 0) as a starting point to find a new U for = 0.1, then using that newly found U for = 0.1 to find a U for = 0.2 and so on. The assumption this was based on is that the encoding matrix would not change much when the perturbation is only slightly increased. Because it took the algorithm eight hours to maximize p0 for every , there has not been enough time to try different starting points.

The line for U maximized at = 1 was made with the value found for = 1 while maximizing for each . We expect this line to also lie higher in reality, since it is not likely that the chance of nothing happening at = 1 is lower than the chance of nothing happening at = 1.1. The algorithm should be run more times to verify whether these expectations are true.

7_{The analytical U and the numerical U for the NS lie on top of each other, which makes}

(15)

No encoding

The following plot shows that the value of p0 clearly remains higher when the

system is encoded, compared to when the system is not encoded. The plot shows the lines for the different encoding U ’s as in the plots before and a U = 1 resembling no encoding. The plot shows what happens to the chance of nothing happening in case of the Ising-like perturbation.

Figure 4: Plot to compare the effect of encoding to no encoding. Performance of MNS

Looking at the plots it might seem that, when the noise is perturbed, the dif-ference between the chance of nothing happening for the U for the NS and the U for the MNS is small. However, one should note that these plots are for t = 1

1024, which means the error has not had much time to act on the system. As the time t gets larger, we can expect the differences to grow.

Another way to look at this is to look at the chance of something happening. The chance of nothing happening dependens on a factor t and can be written as p0= 1 − at, neglecting the higher order t dependencies. Here a denotes the

factor for the chance of something happening. This factor for the chance of something happening is thus given by a = 1 − p0

t .

The plot below shows this factor for the Ising-like perturbation. We see for = 1 that for the U of the MNS the chance of something happening is about twice as low as for the U for the NS.

(16)

Figure 5: Plot of the factor for something happening.

Conclusion

The results show that the algorithm not only successfully finds an encoding ma-trix to encode our system in an NS, but is also able to find an encoding mama-trix to encode the system in an MNS when the noise is perturbed. Imagine someone is building a quantum computer and is experiencing some noise. If the builder knows what the noise is that is affecting its computer, this algorithm could be used to know what encoding to use to minimize the effect of this noise.8

To be able to find such an encoding for a physically relevant noise is an im-provement over the findings of Wang, Byrd and Jacobs [9]. Whereas they were able to numerically find an encoding for a noise with some random perturbation, we have showed that our algorithm finds encodings for perturbations that are physically relevant. We have thus not only verified the results from Wang, Byrd and Jacobs, but also improved them.

Discussion

A way the algorithm could be improved even more is to avoid having a depen-dence on the time in the equation of nothing happening (18). That way we would not have to worry about choosing some very small t. Also the differences between the chances of nothing happening for different encoding matrices U would be better visible, as was seen in figure 5.

The algorithm could then be extended to be able to work for multiple qubits.

8_{Technically, for this specific algorithm the quantum computer will have to exist of no}

(17)

However, if the exact same approach would be used, the running time for the algorithm would grow exponentially with the number of qubits, since U has 26N dimensions, with N the amount of qubits. To avoid running times getting too long, we should try to find a smarter way to add more qubits to the algorithm. One idea that could be explored is to encode each individual system of one qubit with its ancilla system in their own MNS, adding the interaction between the different qubits as an extra perturbation to the noise.

Something else that could be explored is the relation between the change of the parameters in U and the change of . If some pattern can be found we could predict what encoding would be needed for a certain and that way both avoid local maxima and lower the running time of the algorithm.

Finally we should combine these results on error avoiding with results found in other research on error correcting to even further minimize the chance of something happening to our qubit [4]. Ideally the error avoiding encoding min-imizes the errors on the qubit, after which the error correcting method corrects the errors that slipped through the error avoiding encoding. We then read out our qubit in the same state as we saved it in. If we succeed in this, we are making a step forward in realizing the building of a quantum computer.

(18)

I would like to thank Ben and Joris for all their help, for thinking with me and criticizing my work when needed. They have been very patient with me through the entire project.

(19)

References

[1] D Bacon. “Decoherence, control, and symmetry in quantum computers”. In: arXiv preprint quant-ph/0305025 (2003).

[2] P. A. M. Dirac. “A new notation for quantum mechanics”. In: Mathe-matical Proceedings of the Cambridge Philosophical Society 35.3 (1939), pp. 416–418. doi: 10.1017/S0305004100021162.

[3] P Dita. “Factorization of unitary matrices”. In: Journal of Physics A: Mathematical and General 36.11 (2003), p. 2781.

[4] Lu-Ming Duan and Guang-Can Guo. “Quantum error avoiding codes verses quantum error correcting codes”. In: Physics Letters A 255.4 (1999), pp. 209–212.

[5] Daniel A Lidar, Isaac L Chuang, and K Birgitta Whaley. “Decoherence-free subspaces for quantum computation”. In: Physical Review Letters 81.12 (1998), p. 2594.

[6] Daniel A Lidar and K Birgitta Whaley. “Decoherence-free subspaces and subsystems”. In: Irreversible Quantum Dynamics. Springer, 2003, pp. 83– 120.

[7] DM Tong et al. “Operator-sum representation of time-dependent den-sity operators and its applications”. In: Physical Review A 69.5 (2004), p. 054102.

[8] Lorenza Viola et al. “Experimental realization of noiseless subsystems for quantum information processing”. In: Science 293.5537 (2001), pp. 2059– 2063.

[9] Xiaoting Wang, Mark Byrd, and Kurt Jacobs. “Minimal noise subsys-tems”. In: Physical review letters 116.9 (2016). doi: 10.1103/PhysRevLett. 116.090404.

[10] Paolo Zanardi. “Stabilizing quantum information”. In: Physical Review A 63.1 (2000), p. 012301.

Minimal noise subsystems