Break-even point of the phase-flip error correcting code

Quantum memory, storing qubits for a sufficiently long time, is a key ingredient of almost any application in quantum communication [1], computing [2], and sensing [3]. Designing long-lived quantum memories is one of the recent challenges in the field of quantum technology. It can be achieved by improving the lifetime of each physical qubit and storing the logical quantum information in a collective quantum state of multiple physical qubits. The theory of quantum error correction proves that quantum codes are promising platforms for the fault-tolerant storage of quantum information. Typical quantum memory consists of the following processes: encoding the quantum information into the quantum code, idling time, correction, and recalling the quantum state [4]. (See figure 1). Recalling is the inverse process of encoding when the logical information is refocused onto one physical qubit.

Zoom In Zoom Out Reset image size

A large zoo of quantum codes is applicable for quantum memory [5]. However, only a few were demonstrated experimentally, such as surface code, color code, Bacon–Shor code, and perfect code. One of the most promising platforms is the surface code because, in theory, the logical errors could be reduced by scaling up the size of the system if the physical errors are below a threshold [6, 7]. Moreover, it can be realized on a 2D square grid of physical qubits with connectivity only between the neighbors. However, because of initialization, gate, and measurement errors the break-even point—i.e. preserving an arbitrary quantum state with surface code longer than a single idle qubit's lifetime—was not reached so far [8]. With other codes, such as cat code [9] and a discrete-variable-encoded logical qubit [10] the break-even point has been already reached.

The quantum repetition code is not a real quantum error correction code in the sense that it cannot protect the logical information against any Pauli error. Choosing any one of two types of repetition code (bit-flip code and phase-flip code) makes the quantum information resilient against Pauli X or Z errors, but at the same time, leaves it more vulnerable to the other error type [11]. Nonetheless, mainly due to its simplicity, the repetition code is widely investigated theoretically and used for benchmarking state-of-the-art quantum devices [12–14]. Up to now, the longest repetition code, containing 25 qubits, was implemented on a superconducting platform, and it was operated as a classical memory, where the noise was exponentially suppressed by scaling up the code [8, 15]. However, in the case of repetition code-based quantum memories, any single-qubit errors cannot be overcome by scaling up the system, only by combining the bit-flip and phase-flip quantum codes [16].

The simplicity of the repetition code comes from the fact that it requires only linear connectivity between the qubits, and for the implementation, only three qubits are enough [17, 18]. Thus, it was used in the first error correction experiments based on nuclear magnetic resonance [19], ion traps [20], superconducting circuits [21–24], and NV-centers [25]. Furthermore, repetition code is the only error-correcting code that was realized on semiconductor qubits. Phase-flip code-based quantum memory without mid-circuit measurements was implemented in Ge-based and in Si-based spin-qubit devices, but due to the imperfection of the gates, the lifetime of the logical qubit was smaller than the lifetime of an idle physical qubit [26, 27].

In this work, we aim to analytically determine the parameter regime (gate error, relaxation T₁, and dephasing $T_2^*$), where the repetition code-based quantum memory beats the break-even point. According to our results, it can be achieved by applying phase-flip repetition code in a dephasing time-limited system ($T_1 \gt 2T_2^*$) if the gate errors are below a certain threshold. This result is a generalization of an earlier work, where only relaxation was taken into account [28]. We analytically study how the qubit's lifetime can be increased by repeating the quantum memory cycle sketched in figure 1. The investigated quantum circuit, shown in figure 2, contains no mid-circuit measurements and it is composed of 1-qubit and controlled-NOT gates, or it is composed of 1-qubit, controlled-Z, and controlled-S⁻¹ gates motivated by semiconducting hardware.

Zoom In Zoom Out Reset image size

The rest of the paper is arranged as follows. In section 2, we briefly review the bit-flip and phase-flip repetition codes. The applied analytical methods based on density-matrix calculation are described in section 3. The break-even point of the repetition code is determined without gate errors in section 4 and with gate errors in section 5. The paper is enclosed with concluding remarks related to recent experiments in section 6.

This chapter briefly introduces the two kinds of three-qubit repetition codes, the bit-flip and the phase-flip repetition codes. In these, three physical qubits are used to encode the logical qubit, so that we can detect and correct one bit-flip or one phase-flip error, respectively. First, we discuss the bit-flip repetition code and then compare it with the phase-flip repetition code.

In the case of the bit-flip repetition code, the logical information $|\Psi\rangle _\textrm{in} = \alpha |0\rangle +\beta |1\rangle$ is encoded as $|\Psi\rangle = \alpha |000\rangle +\beta |111\rangle$, where $|000\rangle$ ($|111\rangle$) means the product-state of three qubits, all being in the ground state $|0\rangle$ (excited state $|1\rangle$). Bit-flips are detected by measuring the parity of the neighboring physical qubits. For this purpose, we perform projective measurement with the stabilizer operators $Z_1Z_2$ and $Z_2Z_3$, where Pauli- Z operator ${Z}_i$ is acting on the ith physical qubit. Applying a majority-vote decoder on measurement outcomes, called error syndromes, one bit-flip error is corrected by acting with an X gate on the faulty qubit chosen by the decoder. After the correction, the qubit is returned to the codespace then, as a final step, the information is recalled from the encoded state.

Two or more bit-flip errors cannot be corrected in the three-qubit repetition code. However, the logical state still becomes more robust to bit-flip errors. On the other hand, this code cannot detect phase-flip errors, and because of the encoding, more qubits are exposed to its harmful effects, thus in bit-flip code, the logical qubit is more vulnerable to phase-flip errors.

Realizing projective measurement with the stabilizers requires two extra ancilla qubits. Moreover, from an experimental point of view, measurements are the most time-consuming and faulty steps in quantum error correction schemes. Therefore, these mid-circuit measurements are sometimes replaced by a three-qubit Toffoli gate. Resonantly-driven Toffoli gates have already been analyzed [29] and realized [27], but even in some recent experiments, Toffoli-gates have been composed of single-qubit and two-qubit gates [26].

In the phase flip repetition code, the initial state $\Psi_\textrm{in}$ is encoded as $|\Psi\rangle = \alpha | - - - \rangle +\beta |+++\rangle$, where $|\pm\rangle = \frac{1}{\sqrt{2}}(|0\rangle\pm|1\rangle)$. Compared with bit-flip code, the role of Pauli-X and Pauli-Z operators are exchanged, then in phase-flip repetition code, we can correct one phase-flip (Z error) by measuring with the stabilizer $X_1X_2$ and $X_2X_3$. The bit-flip code is converted to phase-flip code by acting on every qubit with Hadamard gates before and after transmission through the error channel.

The quantum circuit of the repetition code-based quantum memory is realized in the following way: (1) initially, one qubit holds the information, while the two other ancilla qubits are in their ground state; (2) for the encoding two CNOT gates are applied; (3) only in case of phase-flip code Hadamard-gates are acting on every qubit; (4) errors are acting during the idling time; (5) only in case of phase-flip code Hadamard-gates are acting on every qubit; (6) two other CNOT gates for the recalling; (7) Toffoli gate for the error correction.

The circuit diagram of the phase-flip repetition code is plotted in figures 2(a) and (b), composed of 1-qubit gates and CNOT gates. This decomposition is motivated by experimental platforms, where CNOT gates are easy to implement between any two of the three physical qubits used for the repetition code. For the bit-flip code, one should omit the Hadamard gates in figure 2(a). In figures 2(c) and (d), we show the experimental realization of phase flip code composed of 1-qubit, controlled-Z, and controlled-S⁻¹ gates recently used on semiconducting hardware [26]. In our analytical calculation, we will use these two different decompositions of the phase-flip repetition code.

For the sake of clarity, we give the matrix representation of all the 1-qubit gates

$$\begin{equation} H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1\\ 1 & -1 \end{pmatrix}, \;\; T = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix},\;\; Y^{\pm 1/2} = \frac{1}{2}\begin{pmatrix} 1\pm i & \mp1-i\\ \pm1+i & 1\pm i \end{pmatrix}, \end{equation} \tag{ 1 }$$

and 2-qubit gates

$$\begin{equation} CZ = \begin{pmatrix} 1 & 0&0&0\\ 0 & 1&0&0 \\ 0 & 0&1&0 \\ 0 & 0&0&-1 \end{pmatrix}, \;\; CS^{-1} = \begin{pmatrix} 1 & 0&0&0\\ 0 & 1&0&0 \\ 0 & 0&1&0 \\ 0 & 0&0&-i \end{pmatrix}, \;\; CNOT = \begin{pmatrix} 1 & 0&0&0\\ 0 & 1&0&0 \\ 0 & 0&0&1 \\ 0 & 0&1&0 \end{pmatrix}, \;\; \end{equation} \tag{ 2 }$$

which appear in the investigated quantum circuits.

Density-matrix description is a useful tool for handling small quantum systems, such as repetition codes [30, 31], because of the following advantages. (i) We can easily take into account any noise channel described by Kraus operators without any simplification, e.g. Pauli-twirling approximation [32, 33]. (ii) Instead of performing projective measurements and sampling the outcome at the end of each quantum error correction cycle, we derive the density matrix and directly extract the probability density of the measurement from it. (iii) This simulation method opens up the possibility of deriving analytical formulas, for example, for the average fidelity of repetition-code-based quantum memories.

This chapter shows how to build the density matrix calculation for the quantum error correction circuits shown in figure 2. We consider two kinds of errors: independent qubit errors during the idling time and faulty gates. We neglect other potential noise sources. Thus, for example, we assume perfect initialization and reset.

During the idling time, t the qubits are coupled to the environment, which is usually modeled by amplitude and phase damping channels characterized by the relaxation time T₁ and (pure) dephasing time $T_2^*$, respectively. These noisy single-qubit quantum channels are described by a density-matrix evolution:

$$\begin{equation} \rho \rightarrow \sum_{k = 1}^3 E_k\rho E_k^\dagger, \end{equation} \tag{ 3 }$$

where the choice of the E_k Kraus-operators is not unique. We used the following decomposition [34]:

$$\begin{equation} E_1 = \begin{pmatrix} \sqrt{1-\tilde\alpha} & 0 \\ 0 & \sqrt{1-\tilde\gamma} \end{pmatrix}, \; E_2 = \begin{pmatrix} 0 & \sqrt{\tilde\gamma}\\ 0& 0 \end{pmatrix}, \; E_3 = \begin{pmatrix} \sqrt{\tilde\alpha} & 0\\ 0 & 0 \end{pmatrix}. \end{equation} \tag{ 4 }$$

The parameters in the Kraus operators have the form $\tilde\gamma = 1-e^{-t/T_1}$, $\tilde\alpha = 1-e^{-2t/T_2^*}$. Going through the error channel the density matrix of a single qubit is transformed as

$$\begin{equation} \begin{pmatrix} \rho_{00} & \rho_{01}\\ \rho_{10} & \rho_{11} \end{pmatrix} \rightarrow \begin{pmatrix} 1-e^{-t/T_1}\rho_{11} & e^{-t/T_2}\rho_{01}\\ e^{-t/T_2}\rho_{01}^* & e^{-t/T_1}\rho_{11} \end{pmatrix}, \end{equation} \tag{ 5 }$$

where

$$\begin{equation} \frac{1}{T_2} = \frac{1}{T_2^*} + \frac{1}{2T_1}. \end{equation} \tag{ 6 }$$

Pure dephasing ($T_1 = 0$, $T_2^*\gt0$) is an asymmetric depolarization channel where the qubit suffers from a simple Pauli-Z error. However, relaxation, where amplitude damping always goes together with dephasing, cannot be exactly captured by the asymmetric depolarization channel. Therefore, it is usually approximated by the Pauli twirling, with which the relaxation is decomposed into the sum of Pauli X, Y and Z channels [34]. In our work, we use the exact time evolution instead of the Pauli twirling approximation.

The error channel of the faulty gates is taken into account by the depolarizing error model, which is parameterized by the probability p₁ for the single-qubit gates and p₂ for the two-qubit gates. In the case of a single qubit depolarizing channel, after every single-qubit gate the density matrix is mapped as

$$\begin{equation} \rho \rightarrow \left(1-\frac{4p_1}{3}\right)\rho + \frac{2p_1}{3} I_2, \end{equation} \tag{ 7 }$$

where I₂ is a $2\times 2$ identity matrix. The Kraus decomposition of this transformation is given by the following four Kraus operators, $\left\{\sqrt{1-p_1}I_2\right.$, $\sqrt{\frac{p_1}{3}}X$, $\sqrt{\frac{p_1}{3}}Y$, $\left.\sqrt{\frac{p_1}{3}}Z\right\}$. Two-qubit faulty gates are defined by similar transformations after every two-qubit gates

$$\begin{equation} \rho \rightarrow \left(1-\frac{16p_2}{15}\right)\rho + \frac{4p_2}{15} I_4. \end{equation} \tag{ 8 }$$

The Kraus decomposition of this two-qubit channel is given by sixteen Kraus operators, $\left\{\sqrt{1-p_2}I_4\right.$, $\sqrt{\frac{p_2}{15}}I_2X$, $\sqrt{\frac{p_2}{15}}I_2Y$, $\sqrt{\frac{p_2}{15}}I_2Z$, $\sqrt{\frac{p_2}{15}}XX$, $\left.\dots, \sqrt{\frac{p_2}{15}}ZZ\right\}$, where the tensor products of the Pauli-matrices $\left\{I_2,X,Y,Z\right\}$ have appeared. The first (second) Pauli-matrix in the Kraus operator is acting on the first (second) output of the two-qubit quantum gate. No Pauli-matrix is acting on the qubit, which was not involved in the two-qubit operation. For simplicity, the errors of all the single-qubit (two-qubit) gates are characterized by the same parameter p₁ (p₂).

The use of the depolarizing channel for faulty gates is a simplifying assumption, but it is widely used in simulations and theoretical analyses because it keeps low the number of parameters in the calculation.

Here, the quantum error correction cycle operates as a quantum memory, therefore, the longest step in figure 1 is the idling time t between the encoding and the correction. Based on this, gate operation times are neglected, and the length of the quantum error correction cycle is assumed to be t. If we repeat the error correction cycles N times, then the total storage time is $t_\textrm{tot} = Nt$. We will investigate this repetition with and without the reset of the ancilla qubits. In the case of the former one, after the recalling and correction, the two ancilla qubits are instantaneously set to their ground state, which can experimentally be achieved by using two new, already relaxed ancilla qubits. If there is no reset of the ancilla qubits, then the outcome of the error correction cycle will be the three-qubit input state of the next cycle. In our scheme, encoding, recalling, and correction (Toffoli-gate) must be done in every round.

At the end of the quantum information storage procedure, we trace over the degrees of freedom of the ancilla qubits and obtain a $2\times2$ density matrix ρ_out. The efficiency of the quantum memory is characterized by the fidelity, which measures the closeness of the initial state $\Psi_\textrm{in}$ and the output density matrix ρ_out in the following way, $F = \langle\Psi_\textrm{in}|\rho_\textrm{out}|\Psi_\textrm{in}\rangle$. It depends on the initial state, and we want to store arbitrary quantum states. Therefore the fidelity is integrated over the Bloch sphere to calculate the average of the fidelity

$$\begin{equation} \mathcal{F} = \int\langle\Psi_\textrm{in}|\rho_\textrm{out}|\Psi_\textrm{in}\rangle \;d\Psi_\textrm{in}, \end{equation} \tag{ 9 }$$

where $d\Psi_\textrm{in}$ is the Haar measure. The average fidelity $\mathcal{F}$ is a simple quantity to characterize the accuracy of the quantum storage, hence the main goal of this paper is to calculate it for different quantum code-based memories as a function of relaxation and dephasing time, gate errors, idling time, and the number of error correction cycles. We should note, that $\mathcal{F}$ is the same as the average gate fidelity for an identity gate.

To determine the parameter range required for reaching the break-even point, we need to compare the accuracy of a quantum code-based memory and a single idle qubit. Hence, first of all, we calculate the average fidelity of a single qubit suffering from dephasing and relaxation for a time t,

$$\begin{equation} \mathcal{F}_\textrm{idle} = \frac{1}{6}\left(3 +e^{-\frac{t}{T_1}}+2e^{-\frac{t}{T_2}} \right). \end{equation} \tag{ 10 }$$

This is the same formula as equation (1) in [35]. In this chapter, the main goal is to calculate the average fidelity without gate errors ($p_1 = p_2 = 0$) for a bit-flip and a phase-flip repetition code-based quantum memory, $\mathcal{F}_\textrm{bit}$ and $\mathcal{F}_\textrm{phase}$, respectively, and compare these values with $\mathcal{F}_\textrm{idle}$. The definition of beating the break-even point is that the condition $\mathcal{F}_\textrm{bit/phase}\gt\mathcal{F}_\textrm{idle}$ is fulfilled for a certain storage time.

After one cycle of the error correction in a three-qubit bit-flip repetition code model, the average fidelity is given by the formula

$$\begin{equation} \mathcal{F}_\textrm{bit} = \frac{1}{6}\left(3 +2 e^{-\frac{3t}{T_2}}-2e^{-\frac{3t}{T_1}} + 3e^{-\frac{2t}{T_1}}\right). \end{equation} \tag{ 11 }$$

For arbitrary values of storage, relaxation, and dephasing time, $\mathcal{F}_\textrm{bit}$ is always smaller or equal to $\mathcal{F}_\textrm{idle}$, hence the break-even point cannot be reached by the bit-flip code. The qualitative understating of this statement is the following, a bit-flip code cannot correct pure dephasing (Pauli-Z) error. Relaxation is approximately a combination of Pauli-X and Z errors, and only the first of them, the Pauli-X error is mitigated, meanwhile, the information becomes more vulnerable to the Pauli-Z error. As a consequence, the lifetime of a qubit cannot be enhanced by a bit-flip repetition code, therefore further on, we focus on only the phase-flip repetition codes.

After one cycle of 3-qubit phase flip code-based quantum error correction, the average fidelity reads

$$\begin{equation} \mathcal{F}_\textrm{phase} = \frac{1}{12}\left[6 +2 e^{-\frac{3t}{T_1}}-2e^{-\frac{3t}{T_2}}+3e^{-\frac{t}{T_2}}\left(1+e^{-\frac{2t}{T_1}}\right)\right]. \end{equation} \tag{ 12 }$$

This value is larger than $\mathcal{F}_\textrm{idle}$, if $T_1 \gt 2T_2^*$ and the storage time t is below a threshold value. This statement is visualized in figure 3, the white region shows the parameter range, where the single qubit performs better $\mathcal{F}_\textrm{idle}\gt\mathcal{F}_\textrm{phase}$, while in the colorful region (yellow–orange–purple–black) the quantum code performs better $\mathcal{F}_\textrm{phase}\gt\mathcal{F}_\textrm{idle}$.

Zoom In Zoom Out Reset image size

The phase-flip repetition code mitigates (amplifies) the fidelity reduction due to the pure dephasing (relaxation), therefore, the break-even point is beaten only in a dephasing-time limited system, where $T_1 \gt 2T_2^*$.

In the rest of the paper, we focus on the 3-qubit repetition codes, but now in this single paragraph, we investigate longer ones. In an n-qubit phase-flip code, where n is an odd number, the logical information is encoded via the superposition of collective states of n qubits , all being in the state $|+\rangle$ or all being in the state $|-\rangle$. After the measurement with the stabilizer operators, which are products of two Pauli-X operators acting on the neighboring qubits, we can detect and also correct $(n-1)/2$ phase-flip errors. Calculation of the average fidelity after one cycle of the error correction using n-qubit phase-flip repetition code is analytically tractable and leads to the following

$$\begin{equation} \mathcal{F}_\textrm{phase,n} = \frac{1}{3} + \frac{1}{3}\frac{1}{2^n} \sum_{k = 0}^{\frac{n-1}{2}} \binom{n}{k} \left[\left(1- e^{-\frac{t}{T_2}}\right)^k \left(1+ e^{-\frac{t}{T_2}}\right)^{n-k}\right.+\left. \left(e^{-\frac{t}{T_1}}- e^{-\frac{t}{T_2}}\right)^k \left(e^{-\frac{t}{T_1}}+ e^{-\frac{t}{T_2}}\right)^{n-k}\right]. \end{equation} \tag{ 13 }$$

Substituting n = 1 and n = 3 into this formula, we get back equations (10) and (12), respectively. The dephasing error can be overcome by scaling up the system, but the relaxation error cannot, in fact, relaxation causes an increasingly harmful effect. Therefore, it is not worth increasing the size of the repetition code beyond all limits. The optimal length of the phase-flip code is determined by finding the n value, which maximizes the average fidelity equation (13) at a given value of t, T₁ and T₂. In figure 3 we plot the length of the optimal phase-flip code as well as three iso-fidelity contours as a function of relaxation and idling times. For example, the yellow (orange) region shows the range of parameters, where the 3-qubit (5-qubit) phase-flip code gives the maximal average fidelity. The iso-fidelity lines show the range of parameters, where the average fidelity at the optimal length is a certain value.

If we would like to store the quantum information for a time $t_\textrm{tot}$, then we can execute one error correction cycle as it was discussed so far in this chapter, or we can repeat the cycles N times one after another. Assuming uniform time step, every cycle has a duration $t_\textrm{tot}/N$. Repetition is executed with or without the reset of the ancilla qubits between the error correction cycles. In the former case, the values of two ancilla qubits are instantaneously reset to their original ground state. The average fidelity after N rounds of the error correction reads

$$\begin{equation} \mathcal{F}_\textrm{phase}^\textrm{reset}\left(N\right) = \frac{1}{6}\left\{3 + e^{-\frac{3t_\textrm{tot}}{T_1}}+\frac{1}{2^N}e^{-\frac{3t_\textrm{tot}}{T_2}} \left[\left(3 e^{\frac{2t_\textrm{tot}}{NT_2}}-1\right)^N+\left(3 e^{\frac{2t_\textrm{tot}}{NT_2}}e^{\frac{-2t_\textrm{tot}}{NT_1}}-1\right)^N \right]\right\}. \end{equation} \tag{ 14 }$$

It can be proven that $\mathcal{F}_\textrm{phase}^\textrm{reset}(N)$ is a monotonically increasing function of N. Therefore, in this simple model, where gate errors are neglected, the lifetime of the logical qubit in a phase-flip code-based quantum memory can be enhanced by increasing the number of error correction cycles. If we repeat the cycles infinitely many times, the errors due to the pure dephasing disappear, however, the average fidelity

$$\begin{equation} \lim_{N \to \infty} \mathcal{F}_\textrm{phase}^\textrm{reset}\left(N\right) = \frac{1}{3}\left(2+e^{-\frac{3t_\textrm{tot}}{T_1}}\right) \end{equation} \tag{ 15 }$$

is decreasing in time because of the relaxation.

In the other case, we repeat the cycles without resetting the ancilla qubits. It means, that the 3-qubit outgoing state of an error correction cycle will be the initial state of the next one. Only for clarification, we note, that the ancilla qubits are not measured in our scheme. The average fidelity after two cycles of error correction with total time $t_\textrm{tot}$ reads

$$\begin{equation} \mathcal{F}_\textrm{phase}^{\textrm{no-reset}} \left(N = 2\right) = \frac{1}{24}\left[12 +4 e^{-\frac{3t_\textrm{tot}}{T_1}}-2e^{-\frac{3t_\textrm{tot}}{T_2}}+5e^{-\frac{t_\textrm{tot}}{T_2}}\left(1+e^{-\frac{2t_\textrm{tot}}{T_1}}\right)\right], \end{equation} \tag{ 16 }$$

and it is always smaller than equation (12), which is the average fidelity after one cycle with the same storage time. This result implies, that even without gate errors, it is not worthwhile to repeat the error correction cycles if we are not capable of resetting the ancilla qubits.

In this chapter, we calculate the average fidelity in the presence of gate errors. These results depend on the gate decomposition of the error correction cycles, therefore, we choose two special ones which are investigated further on. These two quantum circuits, the CNOT-based and the CS-CZ-based have already been introduced in figure 2.

We assume that the gate errors are small, $\left\{p_1,p_2\right\}\ll1$, therefore the drop in the average fidelity is linearized in the variables of p₁ and p₂. The average fidelity after one error correction cycle reads as

$$\begin{equation} \mathcal{F}_\textrm{phase}^\textrm{error} = \mathcal{F}_\textrm{phase} - p_1 f_1 - p_2 f_2, \end{equation} \tag{ 17 }$$

where the average fidelity without gate errors $\mathcal{F}_\textrm{phase}$ is formulated in equation (12), furthermore, f₁ is slightly different for the CNOT-based quantum circuit

$$\begin{equation} f_1^{\,\,\textrm{CNOT}} = \frac{4}{3}\left(2e^{-\frac{3t}{T_1}}-2e^{-\frac{3t}{T_2}}+2e^{-\frac{t}{T_2}}+3e^{-t\left(\frac{1}{T_2}+ \frac{2}{T_1}\right)} \right) \end{equation} \tag{ 18 }$$

and for the CS-CZ-based quantum circuit

$$\begin{align} f_1^{\,\,\textrm{CS-CZ}} = \frac{4}{9}\left(4e^{-\frac{3t}{T_1}}-6e^{-\frac{3t}{T_2}}+5e^{-\frac{t}{T_2}}+7e^{-t\left(\frac{1}{T_2}+ \frac{2}{T_1}\right)} \right). \end{align} \tag{ 19 }$$

Surprisingly, the prefactor of the two-qubit gate error

$$\begin{align} f_2 = \frac{8}{45}\left(8e^{-\frac{3t}{T_1}}-8e^{-\frac{3t}{T_2}}+11e^{-\frac{t}{T_2}}+12e^{-t\left(\frac{1}{T_2}+ \frac{2}{T_1}\right)} \right) \end{align} \tag{ 20 }$$

is the same for the two realizations. If the relaxation and dephasing errors are negligible, the average fidelity is dropped by $184p_2/45$ due to the faulty two-qubit gates and dropped by $10p_1/3$ or $40p_1/9$ due to the faulty single-qubit gates in the case of CNOT-based or in the case of CS-CZ-based quantum circuit, respectively. The gate errors (p₁, p₂) required to reach the break-even point can be determined for any parameter point of the colored region in figure 3 by fulfilling the inequality $\mathcal{F}_\textrm{phase}^\textrm{error}\gt\mathcal{F}_\textrm{idle}$.

It was shown in the previous section, that in the case of perfect gates and reset, the average fidelity can be maximized by repeating the error correction cycles as often as possible. These changes due to gate errors, and a finite number of repetitions is the optimal choice, which is demonstrated in figure 4, where the number of error correction cycles for the maximal average fidelity as well as three iso-fidelity contours are plotted as the function of the relaxation time and the two-qubit gate errors for storage time $t_\textrm{tot} = 0.1T_2^*$ in figure (a), and $t_\textrm{tot} = T_2^*$ in figure (b). In these plots, we investigate a scenario, where the two-qubit gates are noisy, but the single-qubit gates are perfect, $p_1 = 0$. The parameter range where the single idle qubit is an optimal choice against the phase-flip code-based quantum memory is colored white. In the colorful region, the break-even point is beaten, and it is worthwhile to repeat cycles more often if the two-qubit gate errors can be reduced.

Zoom In Zoom Out Reset image size

In this chapter, we discuss the relevance of the above-derived analytical results in light of current experiments. Recently developed quantum processing units with the largest qubit numbers utilize superconducting architectures, and therefore, first we discuss the performance of the phase-flip code-based quantum memory on these platforms. In table 1 we collect the mean value of relaxation and decoherence times, and we calculate the pure dephasing times from them according to equation (6) for a few superconducting quantum processors. In these systems, the qubit lifetime is limited by the relaxation because the T₁ relaxation time is shorter or approximately the same as the pure dephasing time $T_2^*$. Except for the ibm_jakarta, all the other quantum chips do not fit the condition $T_1 \gt 2T_2^*$ required to reach the break-even point. In the case of the ibm_jakarta, if the waiting time t is smaller than 11 $\mu s$ and the gates are perfect, then $\mathcal{F}_\textrm{idle}\lt\mathcal{F}_\textrm{phase}$. However, due to the imperfect operations, the mean CNOT error is around $8\cdot10^{-3}$ for ibm_jakarta [36], hence we cannot demonstrate the break-even point. In conclusion, these superconducting quantum chips are unsuitable platforms for implementing an efficient phase-flip code-based quantum memory.

Table 1. The mean value of the relaxation, decoherence and dephasing times for different superconducting quantum computers.

Superconducting architectures
Quantum chip	T1 (µs)	T2 (µs)	$T_2^*$ (µs)
Google Sycamore [8]	20	30	120
IBM ibm_washington [36]	96	81	140
IBM ibm_montreal [36]	101	64	94
IBM ibm_nairobi [36]	114	76	114
IBM ibm_jakarta [36]	125	38	45
Rigetti Aspen M-2 [37]	33	19	27
Rigetti Aspen M-3 [37]	22	24	53

The lifetime of qubits in semiconductor quantum devices is typically limited by the dephasing, and not by the relaxation, i.e. $T_1\gg T_2^*$ as shown in table 2. Dephasing time is mitigated by a Hahn-echo experiment, which technique is also compatible with the quantum memory scheme. In this case, an inverse pulse is applied in the middle of the idling time. Even after the Hahn-echo experiment $T_1\gg T_2^\textrm{Hahn}$, therefore semiconductor quantum devices are promising platforms to demonstrate the efficiency of the phase-flip code-based quantum memory.

Table 2. The relaxation, pure dephasing and spin-echo dephasing times for a few semiconductor quantum devices. Phase-flip code has already been implemented on the 3-qubit Si and 4-qubit Ge devices.

Semiconductor devices
Platform	$T_1 (\textrm{ms})$	$T_2^*$ (µs)	$T_2^\textrm{Hahn}$(µs)
3-qubit Si [27]	22	1.8	43
4-qubit Ge [26, 38]	1–16	0.15–0.4	3–5
2-qubit SiGe [39]	24–48	1.7–2.3	23–100
6-qubit Si [40]	$\gg$ 1	3–5	14–27

After substituting equations (10), (12), (17), (19), and (20) into the inequality $\mathcal{F}_\textrm{idle}\lt\mathcal{F}_\textrm{phase}^\textrm{error}$ we define the range of the single- and two-qubit gate errors for which the break-even point is reached. For example, after an idling time $t = 0.1T_2^\textrm{Hahn}$, the average fidelity of a single idle qubit is dropped to 0.97. It is enhanced by one cycle of error correction with phase-flip code if the single- and two-qubit gate errors satisfy the condition

$$\begin{equation} p_2<0.0067-1.1p_1. \end{equation} \tag{ 21 }$$

Similarly, after an idling time $t = T_2^\textrm{Hahn}$, which is a time 40 µs and 4 µs in experiments [27] and [26], respectively, the average fidelity of a single idle qubit is dropped to 0.79. It is enhanced by one cycle of error correction with phase-flip code if

$$\begin{equation} p_2<0.019-1.3p_1. \end{equation} \tag{ 22 }$$

We should note that these calculations are valid for the experiments [26], but give only a rough estimation for the experiment [27], because there the Toffoli gate was implemented by resonant driving and not by the decomposition into single- and two-qubit gates. It is also worth noticing that our analytical results are accurate if the idling time is much larger than the time duration of the gate sequence, which is around 0.5–1 µs in both experiments. According to equation (22), gate errors of around 1%–2% are required to demonstrate the break-even point with a phase-flip code.

The above results are obtained in the presence of a depolarizing channel, which is an oversimplified estimation of the gate errors. For a hardware-specific description, we need to consider real noise sources, such as coherent errors, crosstalks, time-correlated errors, etc which could be tasks for a future work.

To summarize, we collect all the necessary ingredients to hit the break-even point with a repetition code-based quantum memory.

• Apply phase-flip repetition code.
• Apply on a dephasing time-limited platform, where $T_1 \gt 2T_2^*$.
• The idling time should be below a threshold value, as it is shown in figure 3.
• The gate errors should be below a threshold value, but the exact condition depends on the gate decomposition of the code. For two kinds of decomposition, the average fidelity was analytically calculated in equations (17)–(22).
• Repeat the error correction cycles only if you can reset the ancilla qubits. The optimal number of repetitions depends on the gate errors, as shown in figure 4.

We envision that our results will foster the design and interpretation of future experiments on repetition code-based quantum memories.

We acknowledge helpful discussions and correspondence with J K Asbóth, A Pályi, P Boross, and Z György. Project No. C1790232 has been implemented with the support provided by the Ministry of Culture and Innovation of Hungary from the National Research, Development and Innovation Fund, financed under the KDP-2021 funding. This research was supported by the Ministry of Culture and Innovation, and the National Research, Development and Innovation Office within the Quantum Information National Laboratory of Hungary (Grant No. 2022-2.1.1-NL-2022-00004), by the János Bolyai Research Scholarship of the Hungarian Academy of Science and by the NKFIH through the OTKA Grants FK 132146 and FK 134437.

All data that support the findings of this study are included within the article (and any supplementary files).