Toward Constructing a Continuous Logical Operator for Error-Corrected Quantum Sensing ()

Cameron Cianci^{}

Physics Department, University of Connecticut, Storrs, CT, USA.

**DOI: **10.4236/jqis.2023.132004
PDF
HTML XML
79
Downloads
417
Views
Citations

Physics Department, University of Connecticut, Storrs, CT, USA.

Error correction has long been suggested to extend the sensitivity of quantum sensors into the Heisenberg Limit. However, operations on logical qubits are only performed through universal gate sets consisting of finite-sized gates such as Clifford + T. Although these logical gate sets allow for universal quantum computation, the finite gate sizes present a problem for quantum sensing, since in sensing protocols, such as the Ramsey measurement protocol, the signal must act continuously. The difficulty in constructing a continuous logical op-erator comes from the Eastin-Knill theorem, which prevents a continuous sig-nal from being both fault-tolerant to local errors and transverse. Since error correction is needed to approach the Heisenberg Limit in a noisy environment, it is important to explore how to construct fault-tolerant continuous operators. In this paper, a protocol to design continuous logical z-rotations is proposed and applied to the Steane Code. The fault tolerance of the designed operator is investigated using the Knill-Laflamme conditions. The Knill-Laflamme condi-tions indicate that the diagonal unitary operator constructed cannot be fault tolerant solely due to the possibilities of X errors on the middle qubit. The ap-proach demonstrated throughout this paper may, however, find success in codes with more qubits such as the Shor code, distance 3 surface code, [15, 1, 3] code, or codes with a larger distance such as the [11, 1, 5] code.

Share and Cite:

Cianci, C. (2023) Toward Constructing a Continuous Logical Operator for Error-Corrected Quantum Sensing. *Journal of Quantum Information Science*, **13**, 45-55. doi: 10.4236/jqis.2023.132004.

1. Introduction

Quantum sensors have found utility in a variety of fields including commercial applications such as geoscience, mining, and various sensors in industry [1] [2] . There have been many recent studies examining the potential utility of error correction to improve the sensitivity of quantum sensors in noisy environments [3] - [9] . Error correction in quantum sensors promise to surpass the Standard Quantum Limit, where sensitivity scales as
$\frac{1}{\sqrt{t}}$ , and instead approach the Heisenberg Limit, scaling as
$\frac{1}{t}$ where *t *is time [3] . This scaling is the best allowed by the laws of quantum mechanics.

Current studies into quantum error-corrected sensors propose codes which can correct the most prevalent type of noise in a system but are still vulnerable to other local errors [10] . For an example, [7] utilized a code to correct relaxation in a quantum magnetometer, but the sensor designed is still vulnerable to single qubit phase errors. Although the paper proposes mitigating these phase errors by leveraging dynamical decoupling [11] [12] , the designed sensor will realistically still accumulate uncorrected errors over time from random environmental fluctuations in the magnetic field. Therefore, this design will be reduced to the Standard Quantum Limit on time scales dictated by the strength of this environmental noise [3] [13] . This can be addressed by using stronger error-correcting codes such as a distance 3 code, which has the ability to correct single qubit errors. However, codes of distance 3 and above have yet to be used in quantum error-corrected sensors due to the difficulty of constructing a continuous logical operator in these codes. The protocol put forth in this paper begins to address this problem by designing potential logical operators which may be constructed through diagonal commuting gates.

To start, let us consider a common quantum sensing protocol, the Ramsey measurement protocol described below [14] .

1) A sensor qubit begins in the state $|0\rangle $ .

2) A Hadamard gate is applied bringing the state to, $H|0\rangle =|+\rangle $ .

3) The signal is applied to the qubit, giving it a signal dependent phase, ${P}_{L}\left(\varphi \right)|+\rangle ={P}_{L}\left(\varphi \right)\times \frac{1}{\sqrt{2}}\left(|0\rangle +|1\rangle \right)=\frac{1}{\sqrt{2}}\left(|0\rangle +{\text{e}}^{i\varphi}|1\rangle \right)$ .

4) A Hadamard gate is applied again, bringing the state to $H\frac{1}{\sqrt{2}}\left(|0\rangle +{\text{e}}^{i\varphi}|1\rangle \right)=\frac{1+{\text{e}}^{i\varphi}}{2}|0\rangle +\frac{1-{\text{e}}^{i\varphi}}{2}|1\rangle $ .

5) Measuring in the z-basis, the probability of obtaining $|1\rangle $ is ${\left|\frac{1-{\text{e}}^{i\varphi}}{2}\right|}^{2}$ , from which $\varphi $ can be inferred.

The continuous phase gate ${P}_{L}\left(\varphi \right)$ is the signal and acts on the computational basis states as,

${P}_{L}\left(\varphi \right)=\left[\begin{array}{cc}1& 0\\ 0& {\text{e}}^{i\varphi}\end{array}\right]$ (1)

The Ramsey measurement protocol requires that there is a continuous symmetry around the z-axis of the qubit for ${P}_{L}\left(\varphi \right)$ to be fault tolerantly applied. As logical gate sets do not typically include any continuous gates, it is not straightforward to apply this protocol directly to an error-corrected logical qubit of distance 3 or larger. Instead, current error-corrected sensing protocols use codes with smaller distances, leaving the logical qubit vulnerable to certain local errors. For example, these sensors often employ codes such as the bit flip or amplitude damping codes [7] [8] [9] . This design choice ultimately allows for transverse operators to generate the signal, for example, magnetic fields in flux tunable superconducting qubits [7] .

The reason for this difficulty in designing error-corrected quantum sensors fault tolerant to single qubit errors comes from the Eastin-Knill theorem. This theorem states that no quantum error-correcting code that can correct local errors can also have a continuous symmetry which acts transversely on the qubits [10] . This is proven by demonstrating that the set of fault tolerant gates on any local error-correcting code is finite and cannot have any continuous symmetries as a continuous symmetry would imply an infinite number of fault tolerant gates. Since a continuous symmetry is required in many sensing protocols such as Ramsey measurement shown above, the Eastin-Knill theorem complicates the design of error-corrected quantum sensors. This is the reason why current error-corrected quantum sensors leave a degree of freedom uncorrected and therefore preserve a continuous symmetry for the signal. However, as was proven in [3] , the presence of any noise along this symmetry will make these sensors revert to the Standard Quantum Limit as they will no longer satisfy the HNLS criterion.

The Eastin-Knill theorem uncovers an interesting question in quantum sensing, is it possible to realize continuous logical operators for error-corrected sensing on a logical qubit? Therefore, in Sections 3 and 4 we will construct a non-transverse logical phase operator, ${P}_{L}\left(\varphi \right)$ , acting on the logical subspace for the purpose of creating quantum error-corrected sensors. The difficulty constructing this operator is likely what has prevented prior exploration into correcting arbitrary local errors in quantum sensors.

2. Arbitrary Diagonal Unitary Gate

One problem in creating a fault tolerant phase operator is that errors may occur between the gates constructing this operator. This would increase the number of possible errors, requiring a larger code which can recognize these new error syndromes. To circumvent this problem, we will consider diagonal unitary operators and demonstrate that they can be built from commuting gates which could be applied simultaneously. Additionally, restricting the operator to be diagonal greatly reduces its complexity from (2* ^{n}*)

This operator can be constructed from a single qubit z-axis rotation gate,
${R}_{Z}\left(\varphi \right)$ , controlled by *n* qubits where
$n\in \left\{\mathrm{0,1,}\cdots ,N\right\}$ with the total number of qubits *N* (ex.
${R}_{{Z}_{1}}\left(\varphi \right)$ ,
${C}_{1}{R}_{{Z}_{2}}\left(\varphi \right)$ ,
${C}_{1}{C}_{3}{R}_{{Z}_{4}}\left(\varphi \right)$ …). As these controlled-phase gates are all diagonal and therefore commute, it may be possible to realize them simultaneously and prevent errors from occurring between these gates. Whether these multi-qubit gates can be created in superconducting quantum circuits is a topic for future investigation, and we will focus only on constructing the logical operators.

Alternatively, other ways to efficiently create diagonal unitaries have been previously explored [15] . However, these diagonal unitaries are built from non-commuting single and two-qubit gates, increasing the number of distinct errors which can occur.

Next, we will programmatically construct an arbitrary diagonal unitary operator from controlled-phase gates. We begin by noting that, for any given *N*, there are 2* ^{N}* degrees of freedom in a diagonal unitary, and
${2}^{N}-1$ different controlled-phase gates. We will eliminate the first diagonal entry through the application of a global phase, without any loss of generality.

We can now construct an arbitrary diagonal unitary operator through the following protocol.

1) Initialize an array to the Identity, in which we will store the constructed operator, ${U}_{C}=1\text{l}$ .

2) Let the index *i* loop through each diagonal entry of the desired operator
${U}_{d}$ .

a) Convert the current index *i* into binary. This binary representation shows the basis state on which this entry will act (ex.
$i=9\Rightarrow |1001\rangle $ ).

b) Apply a ${R}_{Z}\left(\varphi \right)$ gate to one of the qubits in a $|1\rangle $ state, which is controlled by all other qubits in a $|1\rangle $ state. This gate is given a value such that, when applied to the constructed operator, the current diagonal element will obtain the desired phase, $\left(CC\cdots {R}_{Z}\left(\varphi \right)\times {U}_{C}\right)\left[i\right]\left[i\right]={U}_{d}\left[i\right]\left[i\right]$ .

c) Update the constructed operator with this new gate. ${{U}^{\prime}}_{C}=CC\cdots {R}_{Z}\left(a\right)\times {U}_{C}$ .

3) Return the constructed operator ${U}_{C}$ , and the phases applied at each index.

This protocol will construct any desired diagonal unitary from commuting controlled-phase gates, as the list of applied phases at each index can be used to determine the gates applied. The correctness of this protocol can be proven through induction, as each gate affects only the current and later diagonal entries in the constructed operator. Each diagonal entry has a unique operator which can tune its phase without affecting previously considered entries, except for the first entry which can be removed through an application of a global phase. This unique operator is found by applying a phase gate controlled by the binary representation of the state corresponding to the index of the entry. Therefore, we can simply construct the desired operator by making greedy decisions at each entry. Now that the construction of diagonal unitary operators from commuting gates has been stated, we will put forward a simple example to clarify.

Constructing a Simple Diagonal Unitary Operator

Here is an example of this protocol used to construct the following desired unitary ${U}_{d}$ ,

$\begin{array}{cccc}|00\rangle & |01\rangle & |10\rangle & |11\rangle \end{array}$

$\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& {\text{e}}^{i\varphi}& 0& 0\\ 0& 0& {\text{e}}^{i2\varphi}& 0\\ 0& 0& 0& 1\end{array}\right)$

First we loop through each diagonal entry. For each entry, the value can be changed by the phase gate controlled by the values of $|1\rangle $ in the binary representation of the index.

${U}_{d}|01\rangle ={\text{e}}^{i\varphi}|01\rangle \Rightarrow {R}_{{Z}_{1}}\left(\varphi \right)$ (2)

which in turn gives our constructed operator (previously initialized to $1\text{l}$ ) as,

(3)

Next we find,

${U}_{d}|10\rangle ={\text{e}}^{i2\varphi}|10\rangle \Rightarrow {R}_{{Z}_{2}}\left(2\varphi \right)$ (4)

This makes our constructed operator,

(5)

Lastly, viewing the final entry,

${U}_{d}|11\rangle =|11\rangle $ (6)

Currently, our constructed operator gives the value,

${U}_{C}|11\rangle ={\text{e}}^{i3\varphi}|11\rangle $ (7)

This indicates that we must apply ${C}_{1}{R}_{{Z}_{2}}\left(-3\varphi \right)$ , giving us the final operator,

(8)

Which is exactly the desired operator, decomposed into two phase gates and one controlled-phase gate. As was discussed previously, these gates commute and could therefore be applied simultaneously to prevent errors from occurring between them.

3. Creating a Logical Phase Gate

Next we want to create a logical phase gate from a diagonal operator. To start, we must consider the code words of the chosen code on which we will be acting. Since our operator must function as a logical z-rotation gate, it must satisfy the two conditions,

${P}_{L}\left(\varphi \right){|0\rangle}_{L}={|0\rangle}_{L}$ (9)

${P}_{L}\left(\varphi \right){|1\rangle}_{L}={\text{e}}^{i\varphi}{|1\rangle}_{L}$ (10)

These constraints are straightforward when applied to a diagonal operator, as we simply must ensure that all diagonal elements which are multiplied by the nonzero basis states in ${|1\rangle}_{L}$ have a value of ${\text{e}}^{i\varphi}$ while all diagonal elements which are multiplied by the nonzero basis states in ${|0\rangle}_{L}$ have a value of $|1\rangle $ .

For an example, if the logical eigenstates of a desired code were,

${|0\rangle}_{L}=|000\rangle +|001\rangle +|000\rangle +|100\rangle =\left[\begin{array}{cccccccc}1& 1& 1& 0& 1& 0& 0& 0\end{array}\right]$

${|1\rangle}_{L}=|101\rangle +|110\rangle +|101\rangle +|011\rangle =\left[\begin{array}{cccccccc}0& 0& 0& 1& 0& 1& 1& 1\end{array}\right]$

These code words would restrict our diagonal logical phase operator to

${P}_{L}\left(\varphi \right)=\left(\begin{array}{cccccccc}1& 0& 0& 0& 0& 0& 0& 0\\ 0& 1& 0& 0& 0& 0& 0& 0\\ 0& 0& 1& 0& 0& 0& 0& 0\\ 0& 0& 0& {\text{e}}^{i\varphi}& 0& 0& 0& 0\\ 0& 0& 0& 0& 1& 0& 0& 0\\ 0& 0& 0& 0& 0& {\text{e}}^{i\varphi}& 0& 0\\ 0& 0& 0& 0& 0& 0& {\text{e}}^{i\varphi}& 0\\ 0& 0& 0& 0& 0& 0& 0& {\text{e}}^{i\varphi}\end{array}\right)$

as this diagonal unitary uniquely results in,

${P}_{L}\left(\varphi \right){|0\rangle}_{L}={|0\rangle}_{L}$ (11)

${P}_{L}\left(\varphi \right){|1\rangle}_{L}={\text{e}}^{i\varphi}{|1\rangle}_{L}$ (12)

Through application of the protocol from Section 2, we find this operator can be realized by the simultaneous application of the gates ${C}_{1}{R}_{{Z}_{2}}\left(\varphi \right)$ , ${C}_{1}{R}_{{Z}_{3}}\left(\varphi \right)$ , ${C}_{2}{R}_{{Z}_{3}}\left(\varphi \right)$ , and ${C}_{1}{C}_{2}{R}_{{Z}_{3}}\left(-2\varphi \right)$ .

Ambiguous Entries

In most codes, however, code words do not include a superposition of every basis state. This leaves ambiguous or unconstrained degrees of freedom in the constructed operator. For an example, consider a code with the code words ${|0\rangle}_{L}=|00\rangle $ and ${|1\rangle}_{L}=|11\rangle $ . This leaves an ambiguous logical phase operator,

${P}_{L}\left(\varphi \right)=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& a& 0& 0\\ 0& 0& b& 0\\ 0& 0& 0& {\text{e}}^{i\varphi}\end{array}\right)$ (13)

We can therefore tune these variables *a* and *b* as needed. For another more applicable example, the Steane code logical states include a superposition of 8 states out of 128 basis states.

$\begin{array}{c}{|0\rangle}_{L}=\frac{1}{\sqrt{8}}(|0000000\rangle +|1010101\rangle +|0110011\rangle +|1100110\rangle \\ \text{\hspace{0.17em}}\text{\hspace{0.05em}}\text{\hspace{0.05em}}+|0001111\rangle +|1011010\rangle +|0111100\rangle +|1101001\rangle )\end{array}$ (14)

This logical code word restricts only 8 of the 128 diagonal values of the logical operator. The ${|1\rangle}_{L}$ state similarly restricts 8 more leaving 112 tunable values. In the next section, we will consider constraining these values in the Steane code in an attempt to make our logical phase operator fault tolerant through satisfying the Knill-Laflamme conditions.

4. The Fault Tolerance of Designed Logical Phase Gates

Now that we can construct a diagonal logical phase operator for any error-correcting code given its logical code words, we may now test if the constructed logical operator is fault tolerant. This can be done by satisfying the Knill-Laflamme conditions, which are both sufficient and necessary for error correction [16] .

The Knill-Laflamme conditions for a code with code words ${W}_{\sigma}$ fault tolerant to errors ${K}_{i}=\left\{{K}_{1},{K}_{2},\cdots ,{K}_{n}\right\}$ is,

$\langle {W}_{\sigma}|{K}_{l}^{\u2020}{K}_{k}|{W}_{{\sigma}^{\prime}}\rangle ={\alpha}_{lk}{\delta}_{\sigma {\sigma}^{\prime}}$ (15)

The coefficients ${\alpha}_{lk}$ must have no dependence on $\sigma $ or ${\sigma}^{\prime}$ . When considering local errors, the Kraus Operators ${K}_{i}$ are the single qubit Pauli gates ${K}_{i}\in \left\{{X}_{i}\mathrm{,}{Y}_{i}\mathrm{,}{Z}_{i}\mathrm{,}\mathcal{I}\right\}$ .

Assuming we want to make our logical phase operator fault tolerant, we need to expand the Kraus operators such that we account for errors taking place both before and after the application of the logical operator. Since we can construct this operator from simultaneously applied commuting gates as shown in Section 2, we will not consider errors occurring between gates constructing the logical operator.

With ${P}_{L}\left(\varphi \right)$ as a logical operator, we need to expand the Knill-Laflamme conditions to the following four equations.

$\langle {W}_{\sigma}|{P}_{L}^{\u2020}\left(\varphi \right){K}_{l}^{\u2020}{K}_{k}{P}_{L}\left(\varphi \right)|{W}_{{\sigma}^{\prime}}\rangle ={\alpha}_{lk}{\delta}_{\sigma {\sigma}^{\prime}}$ (16)

$\langle {W}_{\sigma}|{K}_{l}^{\u2020}{P}_{L}^{\u2020}\left(\varphi \right){K}_{k}{P}_{L}\left(\varphi \right)|{W}_{{\sigma}^{\prime}}\rangle ={\beta}_{lk}{\delta}_{\sigma {\sigma}^{\prime}}$ (17)

$\langle {W}_{\sigma}|{P}_{L}^{\u2020}\left(\varphi \right){K}_{l}^{\u2020}{P}_{L}\left(\varphi \right){K}_{k}|{W}_{{\sigma}^{\prime}}\rangle ={\beta}_{lk}{\delta}_{\sigma {\sigma}^{\prime}}$ (18)

$\langle {W}_{\sigma}|{K}_{l}^{\u2020}{P}_{L}^{\u2020}\left(\varphi \right){P}_{L}\left(\varphi \right){K}_{k}|{W}_{{\sigma}^{\prime}}\rangle ={\gamma}_{lk}{\delta}_{\sigma {\sigma}^{\prime}}$ (19)

A logical phase gate which satisfies these conditions will additionally be fault tolerant to single qubit errors. The error detection and correction operators can then be derived from the Knill-Laflamme equations [16] .

We must now return our attention to the tunable elements of the logical phase unitary noted in Section 3.1. We will attempt to satisfy the Knill-Laflamme conditions shown in Equations (16)-(19) by using these values.

Consider the simple example explored in section 3.1 with code words ${|0\rangle}_{L}=|00\rangle $ and ${|1\rangle}_{L}=|11\rangle $ , in the presence of ${X}_{1}$ errors, ${K}_{i}=\left\{{X}_{1}\right\}$ . Equations (16)-(19) require $a=1$ and $b={\text{e}}^{i\varphi}$ , making the following logical phase gate tolerant to these ${X}_{1}$ errors,

${P}_{L}\left(\varphi \right)=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& {\text{e}}^{i\varphi}& 0\\ 0& 0& 0& {\text{e}}^{i\varphi}\end{array}\right)$ (20)

As can be seen by applying the protocol from section 2, this is simply a z-axis rotation gate on the second qubit ${R}_{{Z}_{2}}\left(\varphi \right)$ . Now we will attempt to apply this approach to a more powerful error-correcting code, the Steane Code.

5. Results in the Steane Code

The Steane Code is one of the simplest and most well-studied error-correcting codes of distance 3, meaning it can correct any single local error [17] . Since this code can correct local errors, the Eastin-Knill theorem requires the signal to be non-transverse. However, the approach designed in Sections 2, 3, and 4 is not restricted to transverse operators, and therefore is not forbidden from creating a fault tolerant continuous operator. We will now apply our process for making logical phase gates to the Steane Code.

Using the code words of the Steane code (shown below), we restrict the corresponding diagonal elements of our operator as shown in Section 3.

$\begin{array}{c}{|0\rangle}_{L}=\frac{1}{\sqrt{8}}(|0000000\rangle +|1010101\rangle +|0110011\rangle +|1100110\rangle \\ \text{\hspace{0.17em}}\text{\hspace{0.05em}}\text{\hspace{0.05em}}+|0001111\rangle +|1011010\rangle +|0111100\rangle +|1101001\rangle )\end{array}$ (21)

$\begin{array}{c}{|1\rangle}_{L}=\frac{1}{\sqrt{8}}(|1111111\rangle +|0101010\rangle +|1001100\rangle +|0011001\rangle \\ \text{\hspace{0.17em}}\text{\hspace{0.05em}}\text{\hspace{0.05em}}+|1110000\rangle +|0100101\rangle +|1000011\rangle +|0010110\rangle )\end{array}$ (22)

The diagonal elements of the desired logical operator ${U}_{d}$ must behave as,

${U}_{d}{|0\rangle}_{L}={|0\rangle}_{L}$ (23)

${U}_{d}{|1\rangle}_{L}={\text{e}}^{i\varphi}{|1\rangle}_{L}$ (24)

This leaves 112 unconstrained degrees of freedom in the logical phase operator. However, when applying the Knill-Laflamme conditions as shown in Section 4, it is found that the following condition is unsatisfiable.

$\langle {W}_{0}|{X}_{4}{P}_{L}^{\u2020}\left(\varphi \right){X}_{4}{P}_{L}\left(\varphi \right)|{W}_{0}\rangle =\langle {W}_{1}|{X}_{4}{P}_{L}^{\u2020}\left(\varphi \right){X}_{4}{P}_{L}\left(\varphi \right)|{W}_{1}\rangle $ (25)

This can be interpreted as an error on the middle qubit of the Steane code before ${P}_{L}\left(\varphi \right)$ , which is indistinguishable from an error after the application of ${P}_{L}\left(\varphi \right)$ when restricting ${P}_{L}\left(\varphi \right)$ to be diagonal.

More precisely, the value of $\beta $ in $\langle {W}_{\sigma}|{X}_{4}{P}_{L}^{\u2020}\left(\varphi \right){X}_{4}{P}_{L}\left(\varphi \right)|{W}_{{\sigma}^{\prime}}\rangle =\beta {\delta}_{\sigma {\sigma}^{\prime}}$ changes sign based on the value of $\sigma $ and ${\sigma}^{\prime}$ . This indicates that an ${X}_{4}$ error before ${P}_{L}\left(\varphi \right)$ changes the state differently than an ${X}_{4}$ error after ${P}_{L}\left(\varphi \right)$ , but both errors are recognized by the same error syndromes and are indistinguishable. Therefore, this approach unfortunately does not succeed in creating a logical phase operator in the Steane code.

6. Conclusions and Future Directions

In this paper a protocol for designing fault tolerant continuous logical operators from diagonal unitary gates is proposed and tested. This protocol greatly reduces the complexity of the potential fault tolerant operator by restricting it to be a diagonal unitary, reducing its degrees of freedom from ${\left({2}^{N}\right)}^{{}^{2}}$ to ${2}^{N}$ . This restriction also has the added benefit that the designed operator may be constructed from simultaneous application of commuting diagonal gates, and therefore errors between gates constructing the logical operator can be disregarded.

Current error-corrected quantum sensor designs are limited to codes of distance less than 3 due to the Eastin-Knill theorem. The protocol introduced here may be able to overcome this limitation as the designed operator is non-transverse. Although this protocol is unable to create a fault tolerant operator in the Steane code due to *X* errors on the middle qubit of the code, this protocol may be able to design Heisenberg limited quantum sensors when applied to larger codes, or codes with a larger distance. Additionally, a continuous logical operator may have other benefits, such as a logarithmic speedup in fault tolerant quantum computation.

The [11, 1, 5] code is typically tolerant to two qubit errors and may still be tolerant to a single local error when designing a continuous logical operator. Due to the increased code distance, it is possible that even if an error propagates through the multi-qubit gates of the logical operator, the larger distance of this code may still be able to correct these errors.

Additionally, the Shor Code and the distance 3 surface code [18] [19] have a higher qubit count, which may be able to accommodate more error syndromes and correct more errors than the Steane code. Therefore, diagonal operators in these codes may still be fault tolerant.

Also, as the Solovay-Kitaev theorem allows for universal computation to be achieved from Clifford + T gates in $O\left(m{\mathrm{log}}^{c}\left(m/\epsilon \right)\right)$ [20] , a logarithmic speedup may be possible using a continuous operator instead of the T gate. However, a logarithmic speedup is not often significant compared to the quadratic or exponential speedups commonly provided by quantum algorithms.

One of the most interesting outcomes may be that it is impossible to construct a fault tolerant continuous logical operator in error-correcting codes that can be decomposed into physically realizable gates. If this is the case, it would potentially indicate the presence of new and interesting theorems for error correction and quantum sensing.

Conflicts of Interest

The author declares no conflicts of interest regarding the publication of this paper.

[1] | Foley, C. (2014) SQUID Use for Geophysics: Finding Billions of Dollars in APS March Meeting Abstracts 2014 (Mar.), F23.004. |

[2] |
De Luna, F.D., da Silva, A.G. and dos Santos Vianna Junior, A. (2020) The Influence of Geometry on the Fluid Dynamics of Continuous Settler. Open Journal of Fluid Dynamics, 10, 164-183. https://doi.org/10.4236/ojfd.2020.103011 |

[3] | Zhou, S., et al. (2019) Error-Corrected Quantum Sensing. Optical, Opto-Atomic, and Entanglement-Enhanced Precision Metrology, Vol. 10934, 109341J. |

[4] |
Kessler, E.M., Lovchinsky, I., Sushkov, A.O. and Lukin, M.D. (2014) Quantum Error Correction for Metrology. Physical Review Letters, 112, Article ID: 150802. https://doi.org/10.1103/PhysRevLett.112.150802 |

[5] |
Shettell, N., Munro, W.J., Markham, D. and Nemoto, K. (2021) Practical Limits of error Correction for Quantum Metrology. New Journal of Physics, 23, Article ID: 043038. https://doi.org/10.1088/1367-2630/abf533 |

[6] |
Rojkov, I., Layden, D., Cappellaro, P., Home, J. and Reiter, F. (2022) Bias in Error-Corrected Quantum Sensing. Physical Review Letters, 128, Article ID: 140503. https://doi.org/10.1103/PhysRevLett.128.140503 |

[7] |
Herrera-Marti, D.A., Gefen, T., Aharonov, D., Katz, N. and Retzker, A. (2015) Quantum Error-Correction-Enhanced Magnetometer Overcoming the Limit Imposed by Relaxation. Physical Review Letters, 115, Article ID: 200501. https://doi.org/10.1103/PhysRevLett.115.200501 |

[8] |
Matsuzaki, Y. and Benjamin, S. (2017) Magnetic-Field Sensing with Quantum Error Detection under the Effect of Energy Relaxation. Physical Review A, 95, Article ID: 032303. https://doi.org/10.1103/PhysRevA.95.032303 |

[9] |
Reiter, F., Sorensen, A.S., Zoller, P. and Muschik, C.A. (2017) Dissipative Quantum Error Correction and Application to Quantum Sensing with Trapped Ions. Nature Communications, 8, Article No. 1822. https://doi.org/10.1038/s41467-017-01895-5 |

[10] |
Eastin, B. and Knill, E. (2009) Restrictions on Transversal Encoded Quantum Gate Sets. Physical Review Letters, 102, Article ID: 110502. https://doi.org/10.1103/PhysRevLett.102.110502 |

[11] |
Viola, L., Lloyd, S. and Knill, E. (1999) Universal Control of Decoupled Quantum Systems. Physical Review Letters, 83, 4888-4891. https://doi.org/10.1103/PhysRevLett.83.4888 |

[12] |
Bylander, J., et al. (2011) Noise Spectroscopy through Dynamical Decoupling with a Superconducting Flux Qubit. Nature Physics, 7, 565-570. https://doi.org/10.1038/nphys1994 |

[13] |
Wang, S. (2022) Does Design Thinking Run Counter to Design? Art and Design Review, 10, 41-46. https://doi.org/10.4236/adr.2022.101004 |

[14] |
Degen, C., Reinhard, F. and Cappellaro, P. (2017) Quantum Sensing. Reviews of Modern Physics, 89, Article ID: 035002. https://doi.org/10.1103/RevModPhys.89.035002 |

[15] |
Welch, J., Greenbaum, D., Mostame, S. and Aspuru-Guzik, A. (2014) Efficient Quantum Circuits for Diagonal Unitaries without Ancillas. New Journal of Physics, 16, Article ID: 033040. https://doi.org/10.1088/1367-2630/16/3/033040 |

[16] |
Girvin, S.M. (2023) Introduction to Quantum Error Correction and Fault Tolerance. https://doi.org/10.21468/SciPostPhysLectNotes.70 |

[17] |
(1996) Multiple-Particle Interference and Quantum Error Correction. Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 452, 2551-2577. https://doi.org/10.1098/rspa.1996.0136 |

[18] |
Fowler, A.G., Mariantoni, M., Martinis, J.M. and Cleland, A.N. (2012) Surface Codes: Towards Practical Large-Scale Quantum Computation. Physical Review A, 86, Article ID: 032324. https://doi.org/10.1103/PhysRevA.86.032324 |

[19] |
Krinner, S., et al. (2022) Realizing Repeated Quantum Error Correction in a Distance-Three Surface Code. Nature, 605, 669-674. https://doi.org/10.1038/s41586-022-04566-8 |

[20] | Nielsen, M.A. and Chuang, I.L. (2000) Quantum Computation and Quantum Information. Cambridge University Press, Cambridge. |

Journals Menu

Contact us

+1 323-425-8868 | |

customer@scirp.org | |

+86 18163351462(WhatsApp) | |

1655362766 | |

Paper Publishing WeChat |

Copyright © 2024 by authors and Scientific Research Publishing Inc.

This work and the related PDF file are licensed under a Creative Commons Attribution 4.0 International License.