Qunet - User contributions [en]

Chapter 13 - Topological Quantum Error Correction

2012-12-12T01:58:13Z

Pieper: /* Introduction */

== Surface Code ==
===Introduction===

Surface codes are topological quantum error-correcting codes in which we can think of qubits being arranged on a 2-D lattice of qubits with only nearest neighbor interactions. This in practice may prove to be a very useful feature, since for many systems interacting qubits that are close to each other is substantially less difficult than ones that are further apart. We can think of physical qubits as being arranged on the edges of a lattice as shown in Figure 1. An example of the surface code are toric code and planar code, the main difference between both of them is the boundary condition. In the toric code, the boundaries are periodic whereas in the case of the planar code, the boundaries are not periodic. In the toric code, the qubits are arranged on a lattice which can be thought of as spread over a surface of a torus, and in a planar code case we think of the data qubits as living on a simple 2-D plane and ancilla qubits on the faces and the intersections.
<center>[[File:lattice.jpg]]</center>
<center>'''Figure 1'''<br>A two-dimensional array implementation of the surface code. Data qubits are open circles, measurements (ancilla) qubits are filled circles.<br>The yellow area is to measure-Z qubits while the green area is to measure-X qubits.</center>

The stabilizer generators for the surface code are the tensor products of ''Z'' on the four data qubits around each face, and the tensor products of ''X'' on
the four data qubits around each intersection. Neighbouring stabilizers share two data qubits ensuring that adjacent ''X'' and ''Z'' stabilizers commute. The qubit ''Z'' eigenstate are called the ground state <math>\left\vert{g}\right\rangle</math> and the excited state <math>\left\vert{e}\right\rangle</math>. The ground state is the ''+1'' eigenstate of ''Z'', with <math>Z\left\vert{g}\right\rangle=+\left\vert{g}\right\rangle</math>, and the excited state is the ''-1'' eigenstate, with <math>Z\left\vert{e}\right\rangle=-\left\vert{e}\right\rangle</math>. It is tempting to think of the qubit as a kind of quantum transistor, with the ground state corresponding to "off" and the excited state to "on". However, in distinct contrast to a classical logical element, a qubit can exist in a superposition of its eigenstate, <math>\left\vert{\psi}\right\rangle=\alpha\left\vert{g}\right\rangle+\beta\left\vert{g}\right\rangle</math>, so a qubit can be both "off" and on" at the same time. A measurment <math>M_Z</math> of the qubit will however return only one of two possible measurement outcomes,''+1'' with the qubit state projected to <math>\left\vert{g}\right\rangle</math>, or ''-1'' with the qubit state projected to <math>\left\vert{e}\right\rangle</math> .

A planar code has four boundaries, two that are called “smooth” and two that are called “rough”. Smooth boundaries have four-term ''Z'' stabilizer generators, and three-term ''X'' stabilizer generators, whereas rough boundaries have four-term ''X'' stabilizer generators and three-term ''Z'' stabilizer generators. A planar code, with two rough and two smooth boundaries can encode a single logical qubit (as in Figure 2). Also look at [[Bibliography#Fowler/et al:12|http://arxiv.org/abs/1208.0928 [42]]] it is an excellent reference as it represents a comprehensive review of the surface code, also written for the absolute beginner.
<center>[[File:boundaries.jpg]]</center>
<center>'''Figure 2'''<br>Examples of smooth and rough boundaries. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|''Phy. Rev. A.'' [43]]]</center>

===Syndrome Extraction and Error Detection===
Detecting errors involves measuring check operators, and observing which ones give a value of ''-1'' (due to anti-commuting with errors). This information helps us guess where errors occurred. In practice, of course, errors do not have to occur on their own, and often one can observe multiple instances next to each other. In these cases, the error operators form error chains throughout the lattice. Since only
the ends of such error chains anti-commute with the check operators, determining where errors occurred often involves guessing the most likely scenario. In the planar case, the chains connect opposite boundaries of the same type (either left to right, or top to bottom), and
in the toric case, chains that span all the way across a given dimension of the lattice. They turn out to the change the encoded, logical
state of the qubit and hence are called logical errors. Two examples are shown Figures 3 and 4. <math>Z_L</math> is a chain of ''Z'' operators that connects two rough boundaries, and <math>X_L</math> chain of ''X'' operators that connects two smooth ones.

<center>[[File:defect.jpg]]</center>
<center>'''Figure 3'''<br>Examples of error syndromes on the Surface code (planar and toric). The state is initialized to the ''+1'' eigenstate of all stabilizers.<br>Shaded qubits indicate locations of ''X'' errors. This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

<center>[[File:error.jpg]]</center>
<center>'''Figure 4'''<br>A planar surface code in which a logical ''Z (X)'' error is a chain of ''Z (X)''
operators that spans the whole lattice, and connects rough (smooth) boundaries.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

<center>[[File:error_toric.jpg]]</center>
<center>'''Figure 5'''<br>We can encode two qubits in a toric code, since there are no boundaries.<br>This shows how logical operations are done on a) the first qubit, and b) the second.<br>In both cases, the logical operations involve applying a set of operators (either ''X'' or ''Z'') in a chain that goes around one of the dimensions of the torus.<br>This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|''Phy. Rev. A.'' [43]]]</center>

The ancilla qubits are used for determining the measurement outcomes of the four-term (and three-term on boundaries) check operators without actually needing to measure them directly. We call these outcomes syndromes, and use them to determine where errors have occurred. A generic circuit capable of determining the sign of a stabilize in Figure 6. The approach consists of initializing the ancilla qubits, performing a collection of CNOT gates with neighboring data qubits, and finally reading out (measuring) the ancillas.

<center>[[File:circuit.jpg]]</center>
<center>'''Figure 6'''<br>a) General circuit determining the sign of a stabilizer S.<br>b) Circuit determining the sign of a stabilizer ''XXXX''.<br>c) Circuit determining the sign of a stabilizer ''ZZZZ''.</center>

The orientation of the CNOT gates is different when dealing with ancilla qubits that are located on the vertices, from the ones that sit on the plaquettes. In the former case, the ancilla qubits play the role of control, while the data qubits are targets. The situation is reversed in the latter scenario. An example of the plaquette readout is shown in Figure 7. The syndrome is now the change in eigenvalues measured between sequential timeslices, just as the syndrome for error-free syndrome extraction likely set of errors that is consistent with the observed syndrome, now in three dimensions: two spatial and one temporal.

<center>[[File:cycle.jpg]]</center>
<center> A syndrome measurement typically involves six steps:<br>ancilla qubit initialization, CNOTs with the four surrounding data qubits fewer on boundaries in a planar code case, and finally ancilla qubit readout.<br>This example shows a temporal order of the CNOT gates of north, west, east, and south. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|''Phy. Rev. A.'' [43]]]</center>

===Error Correction===
After each ancilla is read, its value is checked against a result from the previous iteration, and if the values differ, the syndrome change
location (in time and space) is recorded. Next, a matching of all the syndrome changes collected up to this point is used to guess where errors occurred. An example of this is shown in Figure 8, where we can see that in this particular scenario, a collection of ''X'' errors (shown as ''X''s in blue) after six readout cycles, have led to the given space-time locations of syndrome changes (red dots). We stress that one could get the same readout pattern from a different set of errors, hence the best we can do when guessing where the errors occurred is find a guess that is the most likely scenario.

To do this, we observe that shorter error chains are more likely than longer ones and therefore use a minimum-weight matching algorithm to match the syndrome change locations and obtain a likely error pattern. Before the matching algorithm can find a minimum-weight solution, however, we need to convert our matching results into something that the matching algorithm can understand. This is done by converting all the syndrome change results into a graph, with the locations of the syndrome changes representing the graph’s nodes, and edges between these nodes having a weight which depends on the distance between them. The edge weight is measured in faces along the spatial dimensions and ancilla qubit readout cycles along the time dimension.

Finally, the corrected lattice is then passed onto error detection routines which can determine whether a logical error has occurred. If it has, then the simulation is stopped and the previous cycle step (at which the simulation was “frozen”) recorded. If no logical error has been detected, the simulation is reverted to the state just before the “perfect readout” cycle began and continues on.

<center>[[File:graph.jpg]]<br>
a) An example of syndrome change locations (red dots) after six readout cycles. The ''X'' operators represent the actual errors that the lattice suffered,<br>which lead to the given syndrome change location pattern. These now have to be matched to obtain a guess as to where the errors happened.<br>b) The matching of syndrome changes gives us information on which errors should be corrected.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

===References===
'''1.''' Austin Fowler, Matteo Mariantoni, John Martinis, Andrew Cleland, http://arxiv.org/abs/1208.0928, Submitted on 4 Aug 2012.<br>
'''2.''' Austin Fowler, Ashley Stephens, and Peter Groszkowski, Phy. Rev. A. '''80''' 052312 (2009).<br>
'''3.''' David Wang, Austin Fowler, and Lloyd Hollenberg, Phy. Rev. A, '''83''', 020302 (2010).<br>
'''4.''' Austin Fowler, David Wang, and Lloyd Hollenberg, Quantum Information & Computation '''11''', 8-18 (2011).<br>
'''5.''' Peter Groszkowski, Master thesis, Waterloo, Ontario, Canada, 2009.<br>

Chapter 13 - Topological Quantum Error Correction

2012-12-12T01:57:42Z

Pieper: /* Syndrome Extraction and Error Detection */

== Surface Code ==
===Introduction===

Surface codes are topological quantum error-correcting codes in which we can think of qubits being arranged on a 2-D lattice of qubits with only nearest neighbor interactions. This in practice may prove to be a very useful feature, since for many systems interacting qubits that are close to each other is substantially less difficult than ones that are further apart. We can think of physical qubits as being arranged on the edges of a lattice as shown in Figure 1. An example of the surface code are toric code and planar code, the main difference between both of them is the boundary condition. In the toric code, the boundaries are periodic whereas in the case of the planar code, the boundaries are not periodic. In the toric code, the qubits are arranged on a lattice which can be thought of as spread over a surface of a torus, and in a planar code case we think of the data qubits as living on a simple 2-D plane and ancilla qubits on the faces and the intersections.
<center>[[File:lattice.jpg]]</center>
<center>'''Figure 1'''<br>A two-dimensional array implementation of the surface code. Data qubits are open circles, measurements (ancilla) qubits are filled circles.<br>The yellow area is to measure-Z qubits while the green area is to measure-X qubits.</center>

The stabilizer generators for the surface code are the tensor products of ''Z'' on the four data qubits around each face, and the tensor products of ''X'' on
the four data qubits around each intersection. Neighbouring stabilizers share two data qubits ensuring that adjacent ''X'' and ''Z'' stabilizers commute. The qubit ''Z'' eigenstate are called the ground state <math>\left\vert{g}\right\rangle</math> and the excited state <math>\left\vert{e}\right\rangle</math>. The ground state is the ''+1'' eigenstate of ''Z'', with <math>Z\left\vert{g}\right\rangle=+\left\vert{g}\right\rangle</math>, and the excited state is the ''-1'' eigenstate, with <math>Z\left\vert{e}\right\rangle=-\left\vert{e}\right\rangle</math>. It is tempting to think of the qubit as a kind of quantum transistor, with the ground state corresponding to "off" and the excited state to "on". However, in distinct contrast to a classical logical element, a qubit can exist in a superposition of its eigenstate, <math>\left\vert{\psi}\right\rangle=\alpha\left\vert{g}\right\rangle+\beta\left\vert{g}\right\rangle</math>, so a qubit can be both "off" and on" at the same time. A measurment <math>M_Z</math> of the qubit will however return only one of two possible measurement outcomes,''+1'' with the qubit state projected to <math>\left\vert{g}\right\rangle</math>, or ''-1'' with the qubit state projected to <math>\left\vert{e}\right\rangle</math> .

A planar code has four boundaries, two that are called “smooth” and two that are called “rough”. Smooth boundaries have four-term ''Z'' stabilizer generators, and three-term ''X'' stabilizer generators, whereas rough boundaries have four-term ''X'' stabilizer generators and three-term ''Z'' stabilizer generators. A planar code, with two rough and two smooth boundaries can encode a single logical qubit (as in Figure 2). Also look at [[Bibliography#Fowler/et al:12|http://arxiv.org/abs/1208.0928 [42]]] it is an excellent reference as it represents a comprehensive review of the surface code, also written for the absolute beginner.
<center>[[File:boundaries.jpg]]</center>
<center>'''Figure 2'''<br>Examples of smooth and rough boundaries. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|Phy. Rev. A. [43]]]</center>

===Syndrome Extraction and Error Detection===
Detecting errors involves measuring check operators, and observing which ones give a value of ''-1'' (due to anti-commuting with errors). This information helps us guess where errors occurred. In practice, of course, errors do not have to occur on their own, and often one can observe multiple instances next to each other. In these cases, the error operators form error chains throughout the lattice. Since only
the ends of such error chains anti-commute with the check operators, determining where errors occurred often involves guessing the most likely scenario. In the planar case, the chains connect opposite boundaries of the same type (either left to right, or top to bottom), and
in the toric case, chains that span all the way across a given dimension of the lattice. They turn out to the change the encoded, logical
state of the qubit and hence are called logical errors. Two examples are shown Figures 3 and 4. <math>Z_L</math> is a chain of ''Z'' operators that connects two rough boundaries, and <math>X_L</math> chain of ''X'' operators that connects two smooth ones.

<center>[[File:defect.jpg]]</center>
<center>'''Figure 3'''<br>Examples of error syndromes on the Surface code (planar and toric). The state is initialized to the ''+1'' eigenstate of all stabilizers.<br>Shaded qubits indicate locations of ''X'' errors. This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

<center>[[File:error.jpg]]</center>
<center>'''Figure 4'''<br>A planar surface code in which a logical ''Z (X)'' error is a chain of ''Z (X)''
operators that spans the whole lattice, and connects rough (smooth) boundaries.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

<center>[[File:error_toric.jpg]]</center>
<center>'''Figure 5'''<br>We can encode two qubits in a toric code, since there are no boundaries.<br>This shows how logical operations are done on a) the first qubit, and b) the second.<br>In both cases, the logical operations involve applying a set of operators (either ''X'' or ''Z'') in a chain that goes around one of the dimensions of the torus.<br>This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|''Phy. Rev. A.'' [43]]]</center>

The ancilla qubits are used for determining the measurement outcomes of the four-term (and three-term on boundaries) check operators without actually needing to measure them directly. We call these outcomes syndromes, and use them to determine where errors have occurred. A generic circuit capable of determining the sign of a stabilize in Figure 6. The approach consists of initializing the ancilla qubits, performing a collection of CNOT gates with neighboring data qubits, and finally reading out (measuring) the ancillas.

<center>[[File:circuit.jpg]]</center>
<center>'''Figure 6'''<br>a) General circuit determining the sign of a stabilizer S.<br>b) Circuit determining the sign of a stabilizer ''XXXX''.<br>c) Circuit determining the sign of a stabilizer ''ZZZZ''.</center>

The orientation of the CNOT gates is different when dealing with ancilla qubits that are located on the vertices, from the ones that sit on the plaquettes. In the former case, the ancilla qubits play the role of control, while the data qubits are targets. The situation is reversed in the latter scenario. An example of the plaquette readout is shown in Figure 7. The syndrome is now the change in eigenvalues measured between sequential timeslices, just as the syndrome for error-free syndrome extraction likely set of errors that is consistent with the observed syndrome, now in three dimensions: two spatial and one temporal.

<center>[[File:cycle.jpg]]</center>
<center> A syndrome measurement typically involves six steps:<br>ancilla qubit initialization, CNOTs with the four surrounding data qubits fewer on boundaries in a planar code case, and finally ancilla qubit readout.<br>This example shows a temporal order of the CNOT gates of north, west, east, and south. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|''Phy. Rev. A.'' [43]]]</center>

===Error Correction===
After each ancilla is read, its value is checked against a result from the previous iteration, and if the values differ, the syndrome change
location (in time and space) is recorded. Next, a matching of all the syndrome changes collected up to this point is used to guess where errors occurred. An example of this is shown in Figure 8, where we can see that in this particular scenario, a collection of ''X'' errors (shown as ''X''s in blue) after six readout cycles, have led to the given space-time locations of syndrome changes (red dots). We stress that one could get the same readout pattern from a different set of errors, hence the best we can do when guessing where the errors occurred is find a guess that is the most likely scenario.

To do this, we observe that shorter error chains are more likely than longer ones and therefore use a minimum-weight matching algorithm to match the syndrome change locations and obtain a likely error pattern. Before the matching algorithm can find a minimum-weight solution, however, we need to convert our matching results into something that the matching algorithm can understand. This is done by converting all the syndrome change results into a graph, with the locations of the syndrome changes representing the graph’s nodes, and edges between these nodes having a weight which depends on the distance between them. The edge weight is measured in faces along the spatial dimensions and ancilla qubit readout cycles along the time dimension.

Finally, the corrected lattice is then passed onto error detection routines which can determine whether a logical error has occurred. If it has, then the simulation is stopped and the previous cycle step (at which the simulation was “frozen”) recorded. If no logical error has been detected, the simulation is reverted to the state just before the “perfect readout” cycle began and continues on.

<center>[[File:graph.jpg]]<br>
a) An example of syndrome change locations (red dots) after six readout cycles. The ''X'' operators represent the actual errors that the lattice suffered,<br>which lead to the given syndrome change location pattern. These now have to be matched to obtain a guess as to where the errors happened.<br>b) The matching of syndrome changes gives us information on which errors should be corrected.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

===References===
'''1.''' Austin Fowler, Matteo Mariantoni, John Martinis, Andrew Cleland, http://arxiv.org/abs/1208.0928, Submitted on 4 Aug 2012.<br>
'''2.''' Austin Fowler, Ashley Stephens, and Peter Groszkowski, Phy. Rev. A. '''80''' 052312 (2009).<br>
'''3.''' David Wang, Austin Fowler, and Lloyd Hollenberg, Phy. Rev. A, '''83''', 020302 (2010).<br>
'''4.''' Austin Fowler, David Wang, and Lloyd Hollenberg, Quantum Information & Computation '''11''', 8-18 (2011).<br>
'''5.''' Peter Groszkowski, Master thesis, Waterloo, Ontario, Canada, 2009.<br>

Chapter 13 - Topological Quantum Error Correction

2012-12-12T01:56:50Z

Pieper: /* Error Correction */

== Surface Code ==
===Introduction===

Surface codes are topological quantum error-correcting codes in which we can think of qubits being arranged on a 2-D lattice of qubits with only nearest neighbor interactions. This in practice may prove to be a very useful feature, since for many systems interacting qubits that are close to each other is substantially less difficult than ones that are further apart. We can think of physical qubits as being arranged on the edges of a lattice as shown in Figure 1. An example of the surface code are toric code and planar code, the main difference between both of them is the boundary condition. In the toric code, the boundaries are periodic whereas in the case of the planar code, the boundaries are not periodic. In the toric code, the qubits are arranged on a lattice which can be thought of as spread over a surface of a torus, and in a planar code case we think of the data qubits as living on a simple 2-D plane and ancilla qubits on the faces and the intersections.
<center>[[File:lattice.jpg]]</center>
<center>'''Figure 1'''<br>A two-dimensional array implementation of the surface code. Data qubits are open circles, measurements (ancilla) qubits are filled circles.<br>The yellow area is to measure-Z qubits while the green area is to measure-X qubits.</center>

The stabilizer generators for the surface code are the tensor products of ''Z'' on the four data qubits around each face, and the tensor products of ''X'' on
the four data qubits around each intersection. Neighbouring stabilizers share two data qubits ensuring that adjacent ''X'' and ''Z'' stabilizers commute. The qubit ''Z'' eigenstate are called the ground state <math>\left\vert{g}\right\rangle</math> and the excited state <math>\left\vert{e}\right\rangle</math>. The ground state is the ''+1'' eigenstate of ''Z'', with <math>Z\left\vert{g}\right\rangle=+\left\vert{g}\right\rangle</math>, and the excited state is the ''-1'' eigenstate, with <math>Z\left\vert{e}\right\rangle=-\left\vert{e}\right\rangle</math>. It is tempting to think of the qubit as a kind of quantum transistor, with the ground state corresponding to "off" and the excited state to "on". However, in distinct contrast to a classical logical element, a qubit can exist in a superposition of its eigenstate, <math>\left\vert{\psi}\right\rangle=\alpha\left\vert{g}\right\rangle+\beta\left\vert{g}\right\rangle</math>, so a qubit can be both "off" and on" at the same time. A measurment <math>M_Z</math> of the qubit will however return only one of two possible measurement outcomes,''+1'' with the qubit state projected to <math>\left\vert{g}\right\rangle</math>, or ''-1'' with the qubit state projected to <math>\left\vert{e}\right\rangle</math> .

A planar code has four boundaries, two that are called “smooth” and two that are called “rough”. Smooth boundaries have four-term ''Z'' stabilizer generators, and three-term ''X'' stabilizer generators, whereas rough boundaries have four-term ''X'' stabilizer generators and three-term ''Z'' stabilizer generators. A planar code, with two rough and two smooth boundaries can encode a single logical qubit (as in Figure 2). Also look at [[Bibliography#Fowler/et al:12|http://arxiv.org/abs/1208.0928 [42]]] it is an excellent reference as it represents a comprehensive review of the surface code, also written for the absolute beginner.
<center>[[File:boundaries.jpg]]</center>
<center>'''Figure 2'''<br>Examples of smooth and rough boundaries. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|Phy. Rev. A. [43]]]</center>

===Syndrome Extraction and Error Detection===
Detecting errors involves measuring check operators, and observing which ones give a value of ''-1'' (due to anti-commuting with errors). This information helps us guess where errors occurred. In practice, of course, errors do not have to occur on their own, and often one can observe multiple instances next to each other. In these cases, the error operators form error chains throughout the lattice. Since only
the ends of such error chains anti-commute with the check operators, determining where errors occurred often involves guessing the most likely scenario. In the planar case, the chains connect opposite boundaries of the same type (either left to right, or top to bottom), and
in the toric case, chains that span all the way across a given dimension of the lattice. They turn out to the change the encoded, logical
state of the qubit and hence are called logical errors. Two examples are shown Figures 3 and 4. <math>Z_L</math> is a chain of ''Z'' operators that connects two rough boundaries, and <math>X_L</math> chain of ''X'' operators that connects two smooth ones.

<center>[[File:defect.jpg]]</center>
<center>'''Figure 3'''<br>Examples of error syndromes on the Surface code (planar and toric). The state is initialized to the ''+1'' eigenstate of all stabilizers.<br>Shaded qubits indicate locations of ''X'' errors. This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|Master thesis [46]]]</center>

<center>[[File:error.jpg]]</center>
<center>'''Figure 4'''<br>A planar surface code in which a logical ''Z (X)'' error is a chain of ''Z (X)''
operators that spans the whole lattice, and connects rough (smooth) boundaries.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|Master thesis [46]]]</center>

<center>[[File:error_toric.jpg]]</center>
<center>'''Figure 5'''<br>We can encode two qubits in a toric code, since there are no boundaries.<br>This shows how logical operations are done on a) the first qubit, and b) the second.<br>In both cases, the logical operations involve applying a set of operators (either ''X'' or ''Z'') in a chain that goes around one of the dimensions of the torus.<br>This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|Phy. Rev. A. [43]]]</center>

The ancilla qubits are used for determining the measurement outcomes of the four-term (and three-term on boundaries) check operators without actually needing to measure them directly. We call these outcomes syndromes, and use them to determine where errors have occurred. A generic circuit capable of determining the sign of a stabilize in Figure 6. The approach consists of initializing the ancilla qubits, performing a collection of CNOT gates with neighboring data qubits, and finally reading out (measuring) the ancillas.

<center>[[File:circuit.jpg]]</center>
<center>'''Figure 6'''<br>a) General circuit determining the sign of a stabilizer S.<br>b) Circuit determining the sign of a stabilizer ''XXXX''.<br>c) Circuit determining the sign of a stabilizer ''ZZZZ''.</center>

The orientation of the CNOT gates is different when dealing with ancilla qubits that are located on the vertices, from the ones that sit on the plaquettes. In the former case, the ancilla qubits play the role of control, while the data qubits are targets. The situation is reversed in the latter scenario. An example of the plaquette readout is shown in Figure 7. The syndrome is now the change in eigenvalues measured between sequential timeslices, just as the syndrome for error-free syndrome extraction likely set of errors that is consistent with the observed syndrome, now in three dimensions: two spatial and one temporal.

<center>[[File:cycle.jpg]]</center>
<center> A syndrome measurement typically involves six steps:<br>ancilla qubit initialization, CNOTs with the four surrounding data qubits fewer on boundaries in a planar code case, and finally ancilla qubit readout.<br>This example shows a temporal order of the CNOT gates of north, west, east, and south. This figure has been copied with a permission from the authors of [[Bibliography#Fowler/et al:09|Phy. Rev. A. [43]]]</center>

===Error Correction===
After each ancilla is read, its value is checked against a result from the previous iteration, and if the values differ, the syndrome change
location (in time and space) is recorded. Next, a matching of all the syndrome changes collected up to this point is used to guess where errors occurred. An example of this is shown in Figure 8, where we can see that in this particular scenario, a collection of ''X'' errors (shown as ''X''s in blue) after six readout cycles, have led to the given space-time locations of syndrome changes (red dots). We stress that one could get the same readout pattern from a different set of errors, hence the best we can do when guessing where the errors occurred is find a guess that is the most likely scenario.

To do this, we observe that shorter error chains are more likely than longer ones and therefore use a minimum-weight matching algorithm to match the syndrome change locations and obtain a likely error pattern. Before the matching algorithm can find a minimum-weight solution, however, we need to convert our matching results into something that the matching algorithm can understand. This is done by converting all the syndrome change results into a graph, with the locations of the syndrome changes representing the graph’s nodes, and edges between these nodes having a weight which depends on the distance between them. The edge weight is measured in faces along the spatial dimensions and ancilla qubit readout cycles along the time dimension.

Finally, the corrected lattice is then passed onto error detection routines which can determine whether a logical error has occurred. If it has, then the simulation is stopped and the previous cycle step (at which the simulation was “frozen”) recorded. If no logical error has been detected, the simulation is reverted to the state just before the “perfect readout” cycle began and continues on.

<center>[[File:graph.jpg]]<br>
a) An example of syndrome change locations (red dots) after six readout cycles. The ''X'' operators represent the actual errors that the lattice suffered,<br>which lead to the given syndrome change location pattern. These now have to be matched to obtain a guess as to where the errors happened.<br>b) The matching of syndrome changes gives us information on which errors should be corrected.<br>This figure has been copied with a permission from the authors of [[Bibliography#Groszkowski:09|''Master thesis'' [46]]]</center>

===References===
'''1.''' Austin Fowler, Matteo Mariantoni, John Martinis, Andrew Cleland, http://arxiv.org/abs/1208.0928, Submitted on 4 Aug 2012.<br>
'''2.''' Austin Fowler, Ashley Stephens, and Peter Groszkowski, Phy. Rev. A. '''80''' 052312 (2009).<br>
'''3.''' David Wang, Austin Fowler, and Lloyd Hollenberg, Phy. Rev. A, '''83''', 020302 (2010).<br>
'''4.''' Austin Fowler, David Wang, and Lloyd Hollenberg, Quantum Information & Computation '''11''', 8-18 (2011).<br>
'''5.''' Peter Groszkowski, Master thesis, Waterloo, Ontario, Canada, 2009.<br>

Bibliography

2012-12-12T01:56:22Z

Pieper:

# <div id="Mermin:qcbook"> N. David Mermin. ''Quantum Computer Science: An Introduction''. Cambridge University Press, (2007).</div>
# <div id="NielsenChuang:book"> M.A. Nielsen and I.L. Chuang. ''Quantum Computation and Quantum Information.'' Cambridge University Press, Cambridge, UK, (2000).</div>
# <div id="Gaitan:book"> Frank Gaitan. ''Quantum Error Correction and Fault Tolerant Quantum Computing.'' CRC Press, Boca Raton, FL, (2008). </div>
# <div id="Griffiths:qmbook"> David J. Griffiths. ''Introduction to Quantum Mechanics'', Second Edition. Pearson Prentice Hall, (2005).</div>
# <div id="Preskill:notes"> J. Preskill. Lecture Notes for Course on Quantum Computation. Caltech, Pasadena, CA, (2005). http://www.theory.caltech.edu/people/preskill/ph229/#lecture </div>
# <div id="Cecile:book"> Y. Choquet.-Bruhat, C. Dewitt-Morette. ''Analysis, Manifolds and Physics''. North-Holland, The Netherlands, (1991).</div>
# <div id="qcrequirements"> D.P. DiVincenzo. <nowiki>''The Physical Implementation of Quantum Computation''</nowiki>. ''Fortschritte der Physik'', '''48''':771, (2000). quant-ph/0002077.</div>
# <div id="nocloning"> W.K. Wootters and W.H. Zurek. <nowiki>''A single quantum cannot be cloned''</nowiki>. ''Nature'', '''299''', 802 (1982).</div>
# <div id="HornNJohnsonI"> Roger A Horn and Charles R. Johnson. ''Matrix Analysis''. Cambridge University Press, (1990).</div>
# <div id="HornNJohnsonII"> Roger A Horn and Charles R. Johnson. ''Topics in Matrix Analysis''. Cambridge University Press, (1991).</div>
# <div id="SMR"> E. C. G. Sudarshan, P. M. Mathews and J. Rau. <nowiki>"Stocashtic Dynamics of Quantum-Mechanical Systems",</nowiki> ''Phys. Rev.'', '''121''', 920, (1961).</div>
# <div id="Kraus:83"> K. Kraus. ''States, Effects and Operations''. Fundamental Notions of Quantum Theory. Academic, Berlin, (1983).,</div>
# <div id="Schumacher:96a"> B. Schumacher. <nowiki>"Sending entanglement through noisy quantum channels"</nowiki>. ''Phys. Rev. A'', '''54''':2614, (1996).</div>
# <div id="Lidar:CP01"> D.A. Lidar, Z. Bihary, and K.B. Whaley. <nowiki>"From Completely Positive Maps to the Quantum Markovian Semigroup Master Equation".</nowiki> ''Chem. Phys.'', '''68''':35, (2001).</div>
# <div id="cryptorev"> N. Gisin, G. Ribordy, W. Tittle, and H. Zbinden. <nowiki>"Quantum Cryptography".</nowiki> ''Rev. Mod. Phys.'', '''74''':145, (2002).</div>
#<div id="Moore'sLaw:article"> Gordon E. Moore. <nowiki>"Cramming more components onto integrated circuits."</nowiki> ''Electronics'', '''Volume 38''', Number 8, (1965).</div>
#<div id="Shor:QECC"> Peter W. Shor. <nowiki>"A method for reducing decoherence in quantum memory."</nowiki> ''Physical Review A'', '''52''', R2493 (1995).</div>
#<div id="Caves:QECC"> Carlton M. Caves. <nowiki> "Quantum Error Correction and Reversible Operations."</nowiki> ''Superconductivity'', '''12''', Number 6, 707 (1999).</div>
#<div id="Lidar/Whaley:03">D.A. Lidar and K.B. Whaley,<nowiki>"Decoherence-Free Subspaces and Subsystems"</nowiki>, ''Irreversible Quantum Dynamics'', Springer-Verlag, Berlin (2003).</div>
#<div id="Byrd/Wu/Lidar:04">M.S. Byrd, L.-A. Wu, and D.A. Lidar, <nowiki>"Overview of Quantum Error Prevention and Leakage Elimination"</nowiki>, ''Journal of Modern Optics'', Vol. '''51''', page 2449, (2004).</div>
#<div id="Bohmqm">Arno Bohm, ''Quantum Mechanics: Foundations and Applications'', 3rd Ed., Springer, New York, New York (1993).</div>
#<div id="Tinkham:gpthbook"> Michael Tinkham. ''Group Theory and Quantum Mechanics''. McGraw-Hill, New York, New York, (1964).</div>
#<div id="Kempeetal:01"> Kempe, J., Bacon, D., Lidar, D.A. and Whaley, K.B.,<nowiki>"Theory of Decoherence-Free, Fault-Tolerant, Universal Quantum Computation"</nowiki> ''Physical Review A'', '''63''', 042307 (2001).</div>
#<div id="Blanes/etal:08">S. Blanes, F. Casas, J.A. Oteo, J. Ros, <nowiki>"The Magnus expansion and some of its applications"</nowiki>, ''Physics Reports'', '''470''', 151 (2009).
#<div id="LoeppNWootters"> Susan Loepp and William K. Wootters. ''Protecting Information: From Classical Error Correction to Quantum Cryptography''. Cambridge University Press, (2006).</div>
#<div id="LoPopescuSpiller"> Hoi-Kwong Lo, Sandu Popescu, Tim Spillier. ''Introduction to Quantum Computation and Information''. World Scientific, Singapore (1998).</div>
#<div id="GottDiss"> Daniel Gottesman ''Stabilizer Codes and Quantum Error Correction'', http://arxiv.org/abs/quant-ph/9705052.</div>
#<div id="quantiki"> Encyclopedia of quantum information: http://www.quantiki.org/wiki/Category:Handbook_of_Quantum_Information.</div>
#<div id="Nielsen/etal"> M. A. Nielsen, Carlton M. Caves, Benjamine Schumacher, and Howard Barnum, ''Information-theoretic approach to quantum error correction and reversible measurement.'' http://arxiv.org/abs/quant-ph/9706064 </div>
#<div id="Gottesman:rev09"> D. Gottesman, "An Introduction to Quantum Error Correction and Fault-Tolerant Quantum Computation," in ''Quantum Information Science and Its Contributions to Mathematics, Proceedings of Symposia in Applied Mathematics'' '''68''', pp. 13-58 (Amer. Math. Soc., Providence, Rhode Island, 2010), http://arxiv.org/abs/0904.2557</div>
#<div id="CalderbankNShor"> A.R. Calderbank and P.W. Shor, "Good quantum error-correcting codes exist," ''Phys. Rev. A'' '''54''', 1098 (1996).</div>
#<div id="Steane:prl"> A.M. Steane, "Error correcting codes in quantum theory," ''Phys. Rev. Lett.'' '''77''', 793 (1996).</div>
#<div id="Steane:prsl"> A.M. Steane, "Multiple particle interference, " ''Proc. Roy. Soc. London A'' '''452''', 2551 (1996).</div>
#<div id="Preskill:prsl"> J. Preskill, "Reliable Quantum Computers," ''Proc. Roy. Soc. London A'' '''454''', 385-410 (1998).</div>
#<div id="Lidar/et al:99"> D.A. Lidar, D. Bacon, K.B. Whaley, ''Phys. Rev. Lett.'' '''82''' (1999) 4556-4559.
#<div id="Bishop/etal:11"> C. Allen Bishop, Mark S. Byrd, Lian-Ao Wu, "Casimir Invariants for Systems Undergoing Collective Motion", ''Phys. Rev. A'' '''83''', 062327 (2011).</div>
#<div id="GruberNO"> B. Gruber and L. O'Raifeartaigh, ''J. Math. Phys.'' '''5''', 1796, (1964).</div>
#<div id="Macfarlane/etal"> A.J. Macfarlane, A. Sudbery and P.H. Weisz, ''Commun. Math. Phys.'' '''11''', 77 (1968).
#<div id="Byrd/Lidar:02"> Mark S. Byrd and D. A. Lidar, ''Phys. Rev. Lett.'' '''89''', 047901 (2002).
#<div id="Byrd/Lidar:ebb"> Mark S. Byrd and D. A. Lidar, ''Phys. Rev. A.'' '''67''', 012324 (2003).
#<div id="Zanardi:99a"> Paolo Zanardi, ''Phys.Lett. A'' '''258''' 77 (1999).
#<div id="Fowler/et al:12"> Austin Fowler, Matteo Mariantoni, John Martinis, Andrew Cleland, "Surface codes: Towards practical large-scale quantum computation," "http://arxiv.org/abs/1208.0928", Submitted on 4 Aug 2012
#<div id="Fowler/et al:09"> Austin Fowler, Ashley Stephens, and Peter Groszkowski, ''Phy. Rev. A.'' '''80''', 052312 (2009)
#<div id="Wang/et al:10"> David Wang, Austin Fowler, and Lloyd Hollenberg, ''Phy. Rev. A.'' '''83''', 020302 (2010)
#<div id="Fowler/et al:11"> Austin Fowler, David Wang, and Lloyd Hollenberg, "Quantum Information & Computation", '''11''', 8-18 (2011)
#<div id="Groszkowski:09"> Peter Groszkowski, ''Master thesis'', Waterloo, Ontario, Canada, 2009

2012-12-12T01:28:03Z

Pieper:

Notation

2012-12-12T01:25:29Z

Pieper:

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:21:42Z

Pieper: /* Operator Quantum Error Correction */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/et al:99|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct for such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is only one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem, not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:20:36Z

Pieper: /* Quantum Error Correcting Codes and DFS/NS */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/et al:99|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct for such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is only one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Notation

2012-12-12T01:19:11Z

Pieper:

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:16:24Z

Pieper: /* Quantum Error Correcting Codes and DFS/NS */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/et al:99|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct for such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:15:29Z

Pieper: /* Quantum Error Correcting Codes and DFS/NS */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/et al:99|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:14:55Z

Pieper: /* Quantum Error Correcting Codes and DFS/NS */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#"Lidar/et al:99"|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:08:14Z

Pieper: /* Quantum Error Correcting Codes and DFS/NS */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar, Bacon, et al:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:06:41Z

Pieper: /* Dynamical Decoupling for Decoupling Logical Qubits */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and the references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:04:43Z

Pieper: /* Dynamical Decoupling for Decoupling Logical Qubits */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls, as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:03:19Z

Pieper: /* Dynamical Decoupling for Decoupling Logical Qubits */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space (i.e., the code space dynamics will be decoupled. QED).

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T01:00:18Z

Pieper: /* Dynamical Decoupling for Decoupling Logical Qubits */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G,</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:58:27Z

Pieper: /* Dynamical Decoupling for Creating Symmetry */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case, the elimination of some but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:57:48Z

Pieper: /* Dynamical Decoupling for Creating Symmetry */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, we can simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:57:23Z

Pieper: /* Dynamical Decoupling for Creating Symmetry */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling.''' Rather than ''eliminate'' a Hamiltonian coupling between the system and bath, can we simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:55:22Z

Pieper: /* General Principles for Combining Error Prevention Methods */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]) can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling''', rather than ''eliminate'' a Hamiltonian coupling between the system and bath, can we simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:54:14Z

Pieper: /* General Principles for Combining Error Prevention Methods */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling''', rather than ''eliminate'' a Hamiltonian coupling between the system and bath, can we simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:52:20Z

Pieper: /* Introduction */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter, a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS, it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling''', rather than ''eliminate'' a Hamiltonian coupling between the system and bath, can we simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Chapter 11 - Hybrid Methods of Quantum Error Prevention

2012-12-12T00:51:27Z

Pieper: /* Introduction */

===Introduction===

One of the first proposals for combining error prevention methods was due to [[Bibliography#Lidar/et al:99|D.A. Lidar, D. Bacon, and K.B. Whaley [35]]]. However, a great deal more work has been done since that time to provide methods for combining these seemingly very different methods of error prevention -- quantum error correcting codes ([[Chapter 7 - Quantum Error Correcting Codes#Chapter 7 - Quantum Error Correcting Codes|Chapter 7]]), decoherence-free/noiseless subsystems ([[Chapter 8 - Decoherence-Free/Noiseless Subsystems#Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]]), and dynamical decoupling controls ([[Chapter 9 - Dynamical Decoupling Controls#Chapter 9 - Dynamical Decoupling Controls|Chapter 9]]). In this chapter a few general guiding principles are provided for combining these error prevention methods into hybrid methods of error prevention. Beyond that, a few very specific examples are given which are promising for error prevention and control of quantum systems for quantum information processing.

===General Principles for Combining Error Prevention Methods===

Perhaps it is not surprising that group theory can be used to describe the error prevention methods and their combinations. In the case of DFS/NS, it is clear that there is a symmetry involved in the process of identifying and utilizing the method. The stabilizer formalism, leads to the connection between both the classical error correction, where group theory is used, and also the Pauli group. Dynamical decoupling can be seen as averaging away errors, but averaging is creating a symmetry as seen in the group-theoretical description of the dynamical decoupling condition.

====Dynamical Decoupling for Creating Symmetry====

From [[Chapter 9 - Dynamical Decoupling Controls#Extensions|Section 9.6]] we know that dynamical decoupling can produce a Hamiltonian which will commute with an error implying a symmetry. From [[Chapter 8 - Decoherence-Free/Noiseless Subsystems|Chapter 8]] we know that a decoherence-free or noiseless subsystem can be utilized if there is a symmetry in the system-bath Hamiltonian. Therefore, one is led to the question, can we create the conditions for a decoherence-free or noiseless subsystem by using dynamical decoupling controls? In other words, can we remove an asymmetry from the Hamiltonian in order to create a symmetry which will enable a DFS encoding to protect against noise? (See [[Bibliography#Zanardi:99a|Zanardi:99a [41]]] for an early discussion.)

Notice that this provides a '''new target for dynamical decoupling''', rather than ''eliminate'' a Hamiltonian coupling between the system and bath, can we simply ''modify'' the Hamiltonian to be compatible with a certain class of errors. This is true for QECCs as well as DFS. In each case the elimination of some, but not all errors, using dynamical decoupling can yield a set of correctable or avoidable errors.

One way to do this is to directly use the group-theoretical averaging technique presented in [[Chapter 9 - Dynamical Decoupling Controls#Groups of Transformations|Section 9.6.1]].

====Dynamical Decoupling for Decoupling Logical Qubits====

''Theorem:'' Symmetrization with respect to the set of logical operations on a code space, which forms a group <math>G</math> suffices to completely decouple the dynamics of the encoded sub-space from the bath.

''Proof:'' Symmetrization takes any system-bath Hamiltonian and projects it onto the centralizer of the group generated by the group <math>G</math> of logical operations (i.e., the set of elements that commute with all elements of this group). By irreducibility of the representation of <math>G</math>, it follows, from Shur’s Lemma, that the BB-modified system-bath Hamiltonian is proportional to identity on the code space. I.e., the code space dynamics will be decoupled. QED.

The importance of this theorem is two-fold. First, it states that only logical operations are required to remove all the errors using dynamical decoupling controls. One need not apply controls to individual physical qubits. This potentially saves many decoupling controls and means that the time scales involved are those of the logical, not physical, qubit.

Second, one assumes that there exists good and fast logical controls as are required by the assumptions for quantum computing. Therefore, the required controls are available and need only be tested for time scale constraints. One sometimes encodes in a DFS in order to enable universal quantum computing because not all controls on individual qubits are available in experiment. Note also that this theorem can be used for any logical qubit.

For the original references, consult [[Bibliography#Byrd/Lidar:02|Byrd/Lidar:02 [39]]] and [[Bibliography#Byrd/Lidar:ebb|Byrd/Lidar:ebb [40]]] and references therein.

====Quantum Error Correcting Codes and DFS/NS====

One way to combine these two methods of error prevention is through concatenation [[Bibliography#Lidar/etal:01|Lidar, Bacon, et al. [35]]]. Suppose that a set of physical qubits is encoded into a DFS/NS. If the noise protection is imperfect, i.e., the symmetry which gives the protection is not exact, then there will be some "leakage" from the DFS/NS to states outside the protected subsystem. To correct or such leakage errors, one can take the DFS/NS encoded qubits and use those to encode the information redundantly into a quantum error correcting code (QECC). Let <math> \left| 0_d\right\rangle\,\!</math> be an encoded DFS/NS zero state (a DFS/NS encoded <math> \left| 0\right\rangle\,\!</math>) state and <math> \left| 1_d\right\rangle\,\!</math> be the corresponding DFS/NS encoded one state (a DFS/NS encoded <math> \left| 1\right\rangle\,\!</math>). Then one could use these to encode the information redundantly using a QECC. For example, the three qubit, bit-flip-protected code would be
{{Equation|<math>\begin{align}
\left| 0_L\right\rangle &= \left| 0_d\right\rangle\left| 0_d\right\rangle\left| 0_d\right\rangle = \left| 0_d 0_d 0_d\right\rangle, \\
\left| 1_L\right\rangle &= \left| 1_d\right\rangle \left| 1_d\right\rangle \left| 1_d\right\rangle =\left| 1_d 1_d 1_d\right\rangle.
\end{align}\,\!</math>|11.1}}
Of course this is one example. Any quantum error correcting code and any DFS could possibly be used to encode in these layers. Furthermore, concatenation is still possible for the QECC with essentially no modification.

====Operator Quantum Error Correction====

An interesting combination of a QECC and a DFS/NS is the one referred to as operator quantum error correction (OPEC). OPEC combines a QECC and DFS/NS in the following way. Suppose we encode in a QECC which has, as its target for correction, a state which is encoded into a DFS/NS. Then, to correct an error, one need only correct the error up to an operation which leaves the DFS/NS invariant. In other words, we only need to implement the error correction operator which takes us into the subsystem and not to the original state. The new state may differ by the old state by an operation which puts the system into another DFS/NS-encoded state.

This situation is describable by using two different systems often referred to as the system and gauge system. These can be denoted by <math> \left| \psi \right\rangle_S \,\!</math> and <math> \left| \phi\right\rangle_G\,\!</math>. Then an error <math> \mathcal{E}\,\!</math> and error recovery operation <math> \mathcal{R}\,\!</math> results in the following sequence
{{Equation|<math>
\left| \psi\right\rangle_S \left| \phi\right\rangle_G \overset{\mathcal{E}}{\longrightarrow} \left| \psi^\prime\right\rangle_S\left| \phi^\prime\right\rangle_G \overset{\mathcal{R}}{\longrightarrow} \left| \psi\right\rangle_S\left| \phi^{\prime\prime}\right\rangle_G,
\,\!</math>|11.2}}
and we say the recovery has been accomplished.

The error correcting code condition, analogous to the Knill-Laflamme condition from QECC [[Chapter 7 - Quantum Error Correcting Codes#eq7.14|Eq.(7.14)]], is
{{Equation|<math>
\left\langle i \right| \left\langle k \right| A^\dagger_\alpha A_\beta \left|j\right\rangle \left|l\right\rangle = \delta_{ij}c_{kl\alpha\beta}.
\,\!</math>|11.3}}
Thus we see the final state of the gauge system may be changed by our error and/or recovery operation, but the encoded information can still be retrieved.

===Examples of Hybrid Error Prevention===

Several examples are given here which show just some of the ways these methods can be combined.

====Leakage Elimination Operators====

When a set of states is encoded into a logical state for the purposes of error prevention, that state is protected due to the fact that it is encoded. If an operation occurs which takes it out of the protected subspace, that operation is particularly bothersome because the state then loses its error prevention abilities. Such an operator is called a "leakage" operator. Removing those interactions which cause such errors is referred to as "leakage elimination" and is achieved using dynamical decoupling controls.

=====Example 1: Preserving a two-qubit DNS code=====

=====Example 2: Preserving a three-qubit DNS code=====

=====Example 3: Preserving a four-qubit DNS code=====

====Quantum Error Prevention for Quantum Dots====

Notation

2012-12-12T00:48:15Z

Pieper:

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:45:38Z

Pieper: /* Concatenated Codes */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for each example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So, for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding, using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages to this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced, assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:44:24Z

Pieper: /* Concatenated Codes */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for each example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So, for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding, using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages to this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:43:55Z

Pieper: /* Concatenated Codes */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for each example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So, for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding, using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:42:31Z

Pieper: /* Concatenated Codes */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for each example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So, for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:41:42Z

Pieper: /* 5. Check the Measurement */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for each example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:41:07Z

Pieper: /* 4. Verifying the Ancilla */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked for errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Notation

2012-12-12T00:38:51Z

Pieper:

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:36:03Z

Pieper: /* 3. Carefully Prepare the Ancilla */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings);
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked fro errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:35:42Z

Pieper: /* 3. Carefully Prepare the Ancilla */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state (one example of the special preparation of an ancilla state which is the superposition of all even weighted strings) ;
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by ;
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked fro errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:35:05Z

Pieper: /* 3. Carefully Prepare the Ancilla */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.

1) Shor proposed state, is one example of the special preparation of an ancilla state which is the superposition of all even weighted strings,
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked fro errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==

Chapter 10 - Fault-Tolerant Quantum Computing

2012-12-12T00:34:49Z

Pieper: /* 3. Carefully Prepare the Ancilla */

==Introduction==

As the name implies, fault-tolerant quantum computing means that quantum computations can be performed in spite of errors in the computation. To ensure that a computation is reliable, one must be able to prevent errors from accumulating. This could happen, for example, if a small error occurs on one qubit and propagates to many others before it is fixed. What are all the ways in which an error can occur and how can they be prevented from accumulating to produce erroneous results? In this chapter, these questions are addressed.

==Requirements for Fault-Tolerance==

As Preskill puts it in [[Bibliography#LoPopescuSpiller|Lo, Popescu, and Spiller [26]]], one needs to "...sniff out all the ways in which a recovery failure could result from a single error, ..." Then, in a [[Bibliography#Preskill:prsl|Proc. Roy. Soc. London article [34]]], he gives five laws for reliable quantum computing, as he reviews the results obtained for avoiding failure. Here, a slightly modified list is discussed. The list is
# Be careful not to propagate errors,
# Copy errors not data,
# Carefully prepare ancilla,
# Verify ancilla,
# Verify the syndrome,
# Take care with measurements.

All of these require some explanation. Let us take them in order.

===1. Propagation of Errors===

The general statement is that an error should not propagate within a code block and errors should not accumulate. If there is an error probability of <math> \epsilon\,\!</math> for one physical qubit, then the objective is to ensure that the block error is reduced by a power. For protection against one error, the block error should be <math> \epsilon^2\,\!</math>, and when encoding against <math> t\,\!</math> errors, the block error should be <math> \epsilon^{t+1}\,\!</math>. If an error propagates within a block, the block error becomes <math> \epsilon\,\!</math> and the encoding has lost all its benefit.

For example, one should be careful when qubits are reused because error correction procedures can actually propagate errors. Consider the syndrome measurement in [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. In that circuit, one of the ancillary qubits is used twice to check the parity of a pair of qubits in the bit-flip code. This, however, can propagate a single error in the ancilla to two qubits in the code block. However, this code can only detect and correct one error. Thus such an event would lead to failure.

<center>
<div id="Figure 10.1"><big>'''Figure 10.1'''</big></div>
{|
|-
| [[File:SyndromeNFT.jpg|center|300px]]
|    
| [[File:SyndromeFT.jpg|center|300px]]
|}
Figure 10.1: Two different syndrome extraction circuits for the three-qubit quantum error correcting code. The figure on the left is not fault-tolerant. It is the same as [[Chapter 7 - Quantum Error Correcting Codes#Figure 7.2|Figure 7.2]]. The figure on the right is fault-tolerant. However, as explained in the text, it cannot be used.
</center>

At first this may not seem likely. After all, the target bit is the one that is affected. However, as shown in [[#Figure 10.1|Figure 10.1]] errors can actually propagate from the target to the source, not just from the source to the target, in the CNOT operation.

<center>
<div id="Figure 10.2"><big>'''Figure 10.2'''</big></div>
{|
| [[File:CNOTgateid1.jpg|center|400px]]
|}
Figure 10.2: The above circuit identity was used by Preskill to show that errors can propagate in not-so-obvious ways. In this particular case, an error can propagate from the source qubit as well as propagating to the target qubit in a CNOT gate.
</center>

===2. Copy Errors Not Data===

One ancilla for each physical qubit in the encoded block gives too much information about the state. If there is one ancilla for each qubit and all are measured, the superposition of <math>\alpha\,\!</math> and <math>\beta\,\!</math> will be destroyed. This is because the information obtained will result in a <math>|000\rangle \,\!</math> or <math>|111\rangle \,\!</math> state of the system. The data, not just the error, has been extracted leaving only classical information. This is clearly unacceptable for quantum information where the details of the state must never be revealed during the computation. Therefore, another method for ancilla preparation and syndrome extraction must be used.

===3. Carefully Prepare the Ancilla===

In the previous section, the fault-tolerant method extracted too much information. So what can be done? The answer is that a different recovery procedure should be used. Rather than using single qubit ancilla, the ancillary system can composed of several qubits in a special state.

Here are two examples for the Steane code.
1) Shor proposed state, is one example of the special preparation of an ancilla state which is the superposition of all even weighted strings,
{{Equation|<math>
|\mbox{Shor}\rangle_{\text{anc}}=\frac{1}{\sqrt{8}}\sum_{\text{even } v} |v\rangle_{\text{anc}}.
\,\!</math>|10.1}}
In this case, one computes the syndrome by performing four CNOT gates and then measure the ancilla state. Since the ancilla state is a superposition of all even weighted states, the result will project onto an even weighted string if there is no error and a superposition of odd weight states if there is an error. Thus giving the syndrome information. The parity of the ancillary system indicates whether or not there is an error, but without revealing the state of the system.

The second example was given by Steane. The ancilla state is given by
{{Equation|<math>
|\text{Steane}\rangle_{\text{anc}}=\frac{1}{\sqrt{4}}\sum_{\text{Hamming}} |v\rangle_{\text{anc}}.
\,\!</math>|10.2}}
In this case the ancilla are measured directly and the classical Hamming code is used to diagnose the errors using the parity check matrix for the classical code.

The differences between the two are as follows:

Shor: 6 syndrome bits, 24 ancilla, 24 CNOT gates

Steane: 14 ancilla, 14 CNOT, the ancilla state is more difficult to prepare.

===4. Verifying the Ancilla===

Since the ancilla is so important, and can propagate an error to the logical qubit (encoded block), it must be carefully prepared and checked fro errors. If there is an error, the ancilla must be thrown away and another ancilla prepared. This must be repeated until the probability for error in the ancilla is sufficiently low.

===5. Check the Measurement===

Checking the measurement, by measuring more than once for example, is necessary since error correction during the computation is not useful if the output of the computation is flawed.


==Concatenated Codes==

Concatenating a code means that a quantum error correcting code is used to encode the set of qubits in a code. That is, each qubit in a code is also an encoded qubit. One can continue so that the next set of qubits is also a set of encoded qubits. So for example, in the bit-flip code, one would use three qubits to encode one logical one. But if each of the qubits used in the encoding is also an encoded qubit, using three qubits, then there are a total of 9. Continuing will lead to a code which uses <math>L\,\!</math> levels of encoding using <math>n\,\!</math> qubits, say, which will produce a total overhead of <math>n^L\,\!</math> qubits to encode one logical one.

There are several advantages of this. One, the measurement and recovery can (in principle) be carried out in parallel for the different levels. Thus ''error correction can be performed more efficiently'' than if the code were simply to be encoded using more qubits in each block. (In other words, simply increasing the distance can increase the error correction recovery procedure.)

Two, due to this, the scaling of the gate error rate it better. The gates do not need to be implemented in sequence and the error probability can be reduced assuming the error rate per elementary (physical) gate is low enough.

==Fault-Tolerant Quantum Computing for the Steane Code==

Once a code is concatenated, gates will need to be performed.

Gates that can be performed bit-wise:

<math>H, X, CNOT, P \,\!</math>, where
<center>
<math>P = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right) \,\!</math>
</center>

However, these are not universal. So they need to be supplemented with another gate.

Solution: Prepare an ancilla state, check it, and use it to implement a gate using gates from the fault-tolerant set.

This sets up a timing problem. How can the ancilla state be prepared at the right time since it is thrown out if it is bad? One cannot wait until it is needed to prepare it. If one did wait, the original state is stored while this one is created.

<math> \,\!</math>

==Fault-Tolerant Quantum Computing for Stabilizer Codes==