Mitigating Coherent Noise Using Pauli Conjugation

TL;DR

This paper introduces Pauli conjugation as a method to improve quantum error correction by leveraging noise coherence, outperforming traditional twirling in logical fidelity and threshold improvements across various quantum codes.

Contribution

It demonstrates that optimal Pauli conjugation can enhance logical fidelity over twirling, providing a new noise mitigation technique in quantum error correction.

Findings

Optimal Pauli conjugation improves logical fidelity.

Conjugation schemes outperform twirling in thresholds.

Method is robust against gate errors.

Abstract

Coherent noise can be much more damaging than incoherent (probabilistic) noise in the context of quantum error correction. One solution is to use twirling to turn coherent noise into incoherent Pauli channels. In this Article, we show that some of the coherence of the noise channel can actually be used to improve its logical fidelity by simply sandwiching the noise with a chosen pair of Pauli gates, which we call Pauli conjugation. Using the optimal Pauli conjugation, we can achieve a higher logical fidelity than using twirling and doing nothing. We devise a way to search for the optimal Pauli conjugation scheme and apply it to Steane code, 9-qubit Shor code and distance-3 surface code under global coherent $Z$ noise. The optimal conjugation schemes show improvement in logical fidelity over twirling while the weights of the conjugation gates we need to apply are lower than the average weight of the twirling gates. In our example noise and codes, the concatenated threshold obtained using conjugation is consistently higher than the twirling threshold and can be up to 1.5 times higher than the original threshold where no mitigation is applied. Our simulations show that Pauli conjugation can be robust against gate errors. With the help of logical twirling, the undesirable coherence in the noise channel can be removed and the advantages of conjugation over twirling can persist as we go to multiple rounds of quantum error correction.

Equations

$$\rho$$

$$\Rightarrow |\rho ⟩⟩$$

$$⟨⟨G|\rho ⟩⟩=\frac{1}{\sqrt{2^n}}\text{Tr}(G\rho )$$

$$\mathcal{E}=\sum _{G,G^{\prime }\in \mathbb{G}}|G^{\prime }⟩⟩⟨⟨G^{\prime }|\mathcal{E}|G⟩⟩⟨⟨G|$$

$${\mathcal{E}}_{G^{\prime }G}=⟨⟨G^{\prime }|\mathcal{E}|G⟩⟩=⟨⟨G^{\prime }|\mathcal{E}(G)⟩⟩=\frac{1}{2^n}\text{Tr}(G^{\prime }\mathcal{E}(G)).$$

$${\Pi }_{\vec{m}}=\prod _{i=1}^{\text{absolutevalue}\tilde{\mathbb{S}}}\frac{\left(1+(-1{)}^{m_i}{\tilde{S}}_i\right)}{2}.$$

$$\left(\overbracket{A}+\overbracket{B}\right)\rho =A\rho A^{†}+B\rho B^{†},$$

$$\mathcal{C}=\sum _{\vec{m}}\overbracket{R_{\vec{m}}{\Pi }_{\vec{m}}}=\sum _{\vec{m}}\overbracket{{\Pi }_0{R}_{\vec{m}}}$$

$${\overline{\mathcal{N}}}_0$$

$$=\sum _{\vec{m}}\sum _{G,G^{\prime }\in \mathbb{G}}|{\overline{G}}^{\prime }{\Pi }_0⟩⟩⟨⟨{\overline{G}}^{\prime }{\Pi }_0|\overbracket{{\Pi }_0{R}_{\vec{m}}}\mathcal{N}|\overline{G}{\Pi }_0⟩⟩⟨⟨\overline{G}{\Pi }_0|$$

$$=\sum _{\vec{m}}\sum _{G,G^{\prime }\in \mathbb{G}}|{\overline{G}}^{\prime }{\Pi }_0⟩⟩⟨⟨{\overline{G}}^{\prime }{\Pi }_0|{\overbracket{R}}_{\vec{m}}\mathcal{N}|\overline{G}{\Pi }_0⟩⟩⟨⟨\overline{G}{\Pi }_0|$$

$$=\mathcal{RN}$$

$$\mathcal{T}(\mathcal{N})$$

$${\overline{\mathcal{N}}}_T$$

$$=\frac{1}{\text{absolutevalue}\mathbb{W}}\sum _{W\in \mathbb{W}}\mathcal{R}\overbracket{W}\mathcal{N}\overbracket{W}.$$

$$\overline{\mathcal{N}}(W)=\mathcal{R}\overbracket{W}\mathcal{N}\overbracket{W}$$

$${\overline{\mathcal{N}}}_0$$

$${\overline{\mathcal{N}}}_T$$

$$F(W)$$

$$F_0$$

$$F_T$$

$$F(W_{max})$$

$$AB=\eta (A,B)BA.$$

$$\tilde{\mathbb{W}}=\tilde{\mathbb{G}}=\tilde{\mathbb{S}}+\tilde{\mathbb{E}}+\widetilde{\overline{\mathbb{G}}}$$

$$⟨⟨{\overline{\rho }}^{\prime }|\mathcal{R}\overbracket{S}\mathcal{N}\overbracket{S}|\overline{\rho }⟩⟩$$

$$\tilde{\mathbb{W}}=\tilde{\mathbb{E}}+\widetilde{\overline{\mathbb{G}}}$$

$$F_0$$

$$=\int ⟨⟨\overline{\rho }|\overbracket{\overline{G}}\mathcal{RN}\overbracket{\overline{G}}|\overline{\rho }⟩⟩\text{differential}\overline{\rho }$$

$$F_0$$

$$=F(\overline{G})\forall G\in \mathbb{G}$$

$$\tilde{\mathbb{W}}=\tilde{\mathbb{E}}$$

$$\mathcal{N}=\sum _N\overbracket{N}.$$

$$\overbracket{W}\overbracket{N}\overbracket{W}$$

$$\overbracket{W}\mathcal{N}\overbracket{W}$$

$$\tilde{\mathbb{W}}=\{W\in \tilde{\mathbb{E}}|\exists N\eta (W,N)\ne e^{i\varphi },\varphi \in \mathbb{R}\}$$

Full text

I Introduction

The quantum fault-tolerant threshold theorem states that when the error rate of the physical components is below a certain threshold value for a given quantum error correction code, we can reduce the error rate of the logical qubits indefinitely by scaling up our code Aharonov and Ben-Or (1997); Knill et al. (1998); Aliferis et al. (2006). Thus for a given code, its threshold value is the target hardware error rate the experimentalists will aim for. The threshold error rate is defined using the worst case error rate like the diamond distance since it is related to the rate of error accumulation. However, experimentally we can only measure the average error rate like the fidelity efficiently. For Pauli channels, the worst case error rate is similar to the average case error rate. However, for coherent (unitary) errors, their worst case error rate can scale as the square root of the average error rate, making them potentially more damaging to quantum error correction codes due to a faster rate of error accumulation Sanders et al. (2015); Gutiérrez and Brown (2015); Kueng et al. (2016); Bravyi et al. (2018); Greenbaum and Dutton (2018); Iyer and Poulin (2018); Huang et al. (2019).

At the physical qubit level, coherent noise can be mitigated using dynamical decoupling Lidar (2014); Suter and Álvarez (2016), however there are limitations due to imperfect control pulses and finite pulse durations and intervals. In the context of quantum error correction, local physical coherent noise will be decohered at the logical level as the code scale up Beale et al. (2018). Their damage to the encoded state can be mitigated by using better decoders Chamberland et al. (2017). Gate-level coherent errors in quantum error correction circuit can be mitigated by splitting the stabiliser check into two oppositely rotating halves Debroy et al. (2018) with some requirements on the gates available to the given architecture. A more general solution would involve using Pauli twirling to turn the coherent noise into a Pauli channel Bennett et al. (1996a, b); Knill et al. (2008); Emerson et al. (2007), which as mentioned before can be much less damaging to the fault-tolerant threshold. Twirling generally involves using all possible Pauli gates to sandwich the noise channel and averaging over the results. The average weight of the extra twirling gates we need to apply scales with the total number of qubits, thus the gate errors introduced by the twirling gates are not negligible.

In this Article, instead of using twirling to combat coherent errors, we propose to deterministically sandwich the noise channel using a chosen pair of Pauli gates, which we call Pauli conjugation. We start by introducing some background concepts in Section II. In Section III, we find ways to reduce the search space for the optimal Pauli conjugation scheme. This is then used in Section IV to compare the logical fidelity and concatenated threshold of Pauli conjugation to those of twirling for several quantum error correction codes under global $Z$ rotation noise. In Section V, we discuss the extension of our technique to multiple rounds of error corrections and conjugations. This is followed by conclusion and discussion of possible future directions in Section VI.

II Logical Fidelity in Quantum Error Correction

II.1 Pauli Transfer Matrix Formalism

In the Pauli transfer matrix formalism Greenbaum (2015), the density operators are written in vector form by decomposing into Pauli basis $G\in\mathbb{G}$:

[TABLE]

where we have defined the inner product as:

[TABLE]

We have added a scaling factor $\frac{1}{\sqrt{2^{n}}}$ when we use the Pauli operators as basis, where $n$ is the number of qubits. This is to ensure the normalisation of the basis set $\{\lvert G\rangle\!\rangle\}$.

In such a way, a general quantum channel $\mathcal{E}$ can be written in matrix form:

[TABLE]

with the matrix elements given by

[TABLE]

II.2 Quantum Error Correction

For a code defined by the set of stabilisers $\mathbb{S}$, we will denote the stabiliser generators as $\widetilde{\mathbb{S}}$. In this Article, the generator of a set is denoted using $\widetilde{\quad}$. When we talk about the generators for a Pauli set, the composition operation we used in the generation will ignore all the phase factors in front.

We will do stabiliser measurements for all $\widetilde{S}_{i}\in\widetilde{\mathbb{S}}$ to extract the error syndrome $\vec{m}$ whose element $m_{i}\in\{0,1\}$ is the measurement outcome of the stabiliser generator $\widetilde{S}_{i}$. This will project the noisy state into the corresponding $\vec{m}$-syndrome subspace using the syndrome projection operators

[TABLE]

For each measured syndrome $\vec{m}$, we will apply the corresponding recovery operator $R_{\vec{m}}$, which is usually chosen to be the most likely Pauli error that leads to the given syndrome. Using $\overbracket{\quad}$ to denote a super-operator

[TABLE]

the overall quantum error correction process can be written as:

[TABLE]

where we have used $\Pi_{\vec{m}}=R_{\vec{m}}\Pi_{0}R_{\vec{m}}$.

If we start within the logical subspace, the error correction process $\mathcal{C}$ will always project the state back to the logical subspace even after going through a noisy channel $\mathcal{N}$. Thus, the effective channel $\mathcal{N}_{0}=\mathcal{C}\mathcal{N}$ will be a error channel that takes one logical state to another, i.e. it is a logical noise channel. The effective logical noise channel $\overline{\mathcal{N}}_{0}$ is defined to be the average over all logically equivalent starting and final states:

[TABLE]

where $\mathcal{R}=\sum_{\vec{m}}{\overbracket{R}}_{\vec{m}}$ 111Note that here we have abused the notation of $\mathcal{R}\mathcal{N}$ assuming it will only act on the logical Pauli basis $\{\lvert\overline{G}\Pi_{0}\rangle\!\rangle\}$ instead on all of the physical Pauli basis..

II.3 Twirling and Conjugation

Twirling is a technique for converting an arbitrary error channel into a Pauli channel Bennett et al. (1996b, a); Geller and Zhou (2013), which is carried out by taking the average of the error channel conjugated with different gates chosen from a set of Pauli gates $\mathbb{W}\subseteq\mathbb{G}$ that we call the twirling set. Conventionally, twirling is carried out using the full set of Pauli gates as the twirling set: $\mathbb{W}=\mathbb{G}$. However, it is possible to find a smaller $\mathbb{W}$ that is equivalent to the full Pauli set as we will see later (also shown in Cai and Benjamin (2019)).

Twirling a noise channel $\mathcal{N}$ is just

[TABLE]

Twirling can decohere the Pauli components in the noise channel and turn it into a Pauli channel. This will correspond to removing the off-diagonal elements of the Pauli transfer matrix of the channel.

Using (1) and (2), the effective logical channel after twirling is:

[TABLE]

Instead of averaging over all twirling gates, if we deterministically conjugate the noise process with a given twirling gate $W$, the effective logical channel can be written as

[TABLE]

which we will call Pauli conjugation.

Then we have:

[TABLE]

The logical fidelity of $\overline{\mathcal{N}}(W)$ is

[TABLE]

where $\overline{\rho}$ is a logical state and the integral is over the pure state surface using the Haar measure.

Since the fidelity $F$ is a linear function of the noise process $\overline{\mathcal{N}}$, we can similarly obtain the original logical fidelity $F_{0}$ and the twirled logical fidelity $F_{T}$:

[TABLE]

There exists a $W_{max}\in\mathbb{W}$ such that $F(W_{max})$ is the maximum $F(W)$ that we can achieve. By definition we have

[TABLE]

Thus if we can find such $W_{max}$ and deterministically apply it to the noise instead of doing nothing or randomly applying all $W\in\mathbb{W}$, we can obtain a higher fidelity $F(W_{max})$ than the original fidelity $F(I)$ and the twirled fidelity $F_{T}$.

II.4 Mechanism of Conjugation

Let us first consider the case when we perform quantum error correction on a unitary (completely coherent) noise channel and obtain the [math]-syndrome ($m_{i}=0\quad\forall i$). The resultant effective noise channel will contain an error-free components representing by the coherent superposition of the stabiliser operators $\sum_{i}\alpha_{i}S_{i}$. When acting on a logical state, the effective amplitude corresponding to the logical identity will then be $\sum_{i}\alpha_{i}$.

Now if we apply Pauli conjugation using the operator $W$ to the error channel, the error-free components will become $\sum_{i}\alpha_{i}WS_{i}W$, which corresponds to an amplitude of $\sum_{i}\eta(W,S_{i})\alpha_{i}$ for the logical identity. Here $\eta(A,B)$ is the commutator between operators $A$ and $B$:

[TABLE]

Thus Pauli conjugation will change the sign of the Pauli components of the error channel, changing the way the Pauli components interfere. For the [math]-syndrome case, if we can choose a conjugation operator $W$ such that $\sum_{i}\eta(W,S_{i})\alpha_{i}\geq\sum_{i}\alpha_{i}$, i.e. the error-free components (the stabilisers) interfere more constructively with conjugation than without, it will lead to an increase in the logical fidelity of the channel using conjugation. The normalisation of the channel also means that the logical error components of the channel will interfere more destructively when using conjugation. Similar arguments can be made for the non-zero-syndrome cases.

Hence for a given noise channel, as long as there is some coherent superposition of its Pauli components corresponding to the same logical operators for a given syndrome, Pauli conjugation should be able to improve its logical fidelity by changing the relative signs between the components and alter the way they interfere. One case for which Pauli conjugation will not be able to help is when the identity is the optimal conjugation gate $W_{max}=I$, i.e. the noise Pauli components are interfering in the optimal ways for the given code, which should be unlikely unless we have hand-picked our code to exactly fit the noise process.

III Finding the optimal conjugation gate

The usual Pauli twirling will have $\mathbb{W}=\mathbb{G}$. For $n$ qubits, this means that there are $4^{n}$ elements in $\mathbb{W}$ that we need to search over to find $W_{max}$, which is exponentially difficult for large $n$. Hence, we first need to reduce the size of $\mathbb{W}$ in order to find $W_{max}$ effectively.

Rather than dealing with the twirling set $\mathbb{W}$, we will first be working with its generator $\widetilde{\mathbb{W}}$. The reason we can work with the generators for our later purposes is outlined in Appendix C.

The generators of the conventional twirling set is just $\widetilde{\mathbb{W}}=\widetilde{\mathbb{G}}$. For a given quantum error correction code, the generators of the Pauli basis $\widetilde{\mathbb{G}}$ can be divided into the following partitions:

• •

Stabiliser generators $\widetilde{\mathbb{S}}$: the set of Pauli operators that define the stabiliser checks of the code.

• •

Logical generators $\widetilde{\overline{\mathbb{G}}}$: together with the stabiliser generators, they generate the set of logical operators $\overline{\mathbb{G}}$, which is just the normaliser of the set of stabilisers $\mathbb{S}$.

• •

Error generators $\widetilde{\mathbb{E}}$: All the remaining generators needed to generate the whole Pauli set. Each error generator $\widetilde{E}$ anti-commutes with a different subset of stabiliser generators and thus will produce a different syndrome.

Hence, we have

[TABLE]

Note that we have used the label ‘error generators’ since each such element creates a code violation, but physical error process can give rise to elements of any of these sets, and in particular those in $\widetilde{\overline{\mathbb{G}}}$ which create undetectable logical errors.

III.1 Removing Stabilisers and Logical Operators

$\mathcal{R}$ and $\overbracket{S}$ commute because they are both Pauli channels which are diagonal in the form of Pauli transfer matrix. Hence, for any channel $\mathcal{N}$, and logical states $\lvert\overline{\rho}\rangle\!\rangle$ and $\lvert\overline{\rho}^{\prime}\rangle\!\rangle$, we have:

[TABLE]

which means that conjugation using stabilisers on any noise channel has a trivial effect on the effective logical channels. Hence, we can remove all stabilisers from the twirling generator set and reduce it to:

[TABLE]

Now if we are calculating the logical fidelity, we are integrating over all the logical pure state using the unitary Haar measure, which is by definition invariant under any unitary transformation. Thus we have:

[TABLE]

$\mathcal{R}$ and $\overbracket{\overline{G}}$ again commute since they are both Pauli channel. Hence we have:

[TABLE]

Hence, when calculating the logical fidelity, conjugation with logical Pauli operators also acts trivially and can be removed from the twirling generating group. The remaining non-trivial twirling generators are:

[TABLE]

The way to construct a $\widetilde{\mathbb{E}}$ consists of only single-qubit $X$ and $Z$ gates is outlined in Appendix A.

III.2 Twirling Set Reduction Using the Structure of the Noise

Two super-operators $\overbracket{A}$ and $\overbracket{B}$ will commute if their commutator $\eta(A,B)=e^{i\phi}$, i.e. their commutator is some phase factor.

We will write our noise channel $\mathcal{N}$ in terms of its noise elements $\overbracket{N}$:

[TABLE]

Now if a twirling generator $W$ satisfies $\eta(W,N)=e^{i\phi}\ \forall N$, then

[TABLE]

i.e. it act trivially on noise $\mathcal{N}$ and hence can be removed.

After such reduction, the twirling generating set now becomes:

[TABLE]

III.3 Symmetry in Code and Noise

The twirling set $\mathbb{W}$ can be generated from $\widetilde{\mathbb{W}}$ following Appendix B. Based on the symmetry existing in both the code and the noise, we can prove the equivalence between different elements in $\mathbb{W}$.

Suppose we manage to find a Clifford operation $U$ such that the code state basis $\Pi_{\vec{0}}\overline{G}$ and the physical noise channel $\mathcal{N}$ are invariant under its transformation:

[TABLE]

we can prove that (see Appendix D)

[TABLE]

i.e. the effective logical channel conjugated with $W$ is the same as that with $U^{\dagger}WU$. All of such $U$ will form a group $\mathbb{U}$.

Hence, we can define an equivalence relation:

[TABLE]

In such a way, conjugacy with elements in $\mathbb{U}$ will split $\mathbb{W}$ into several equivalence classes. The elements in the same equivalence class will produce the same logical fidelity when used to conjugate the noise.

The simplest type of Clifford transformation to consider is qubit permutation, for which $U$ consists of swap gates. Permutation symmetry of quantum error correction codes has been studied in Huang et al. (2019) and Chamberland et al. (2017). Note that qubit permutation will preserve the weights of the operators, thus it is crucial to construct $\mathbb{W}$ to have the elements with the lowest weight possible (see Appendix B), so that more of them can be proven to be in the same equivalence class.

If a code has one logical qubit and its logical Pauli gates consist of applying physical Pauli gates to all the qubits, then such transversal logical Pauli gates are invariant 222More precisely, we can find at least one physical representation of logical $\overline{G}$ out of all of its logically equivalent counter-parts that satisfy this symmetry condition. under any qubit permutation $U$, i.e. $\left[U,\overline{G}\right]=0\quad\forall G\in\mathbb{G}$. For such codes, we only need to further make sure that the set of stabilisers are invariant under the given qubit permutation $U$:

[TABLE]

to ensure the code symmetry requirement in (3) is satisfied. Furthermore, if some of the stabilisers commute with the noise, then these stabilisers will have trivial effect in the error correction process and thus can be safely ignored. In such a case, we will only need to consider the symmetry of the stabilisers that do not commute with the noise. For example, for a pure $Z$ noise, we can safely ignore the $Z$ stabilisers when we are considering code symmetry.

IV Mitigating coherent $Z$ noise using Pauli conjugation

In this Section we will try to find the optimal Pauli conjugation gate for different quantum error correction codes under the global $Z$ rotation noise:

[TABLE]

where $J$ is the number of qubit. This noise is a coherent superposition of all possible $Z$ operators (tensor products of $I$ and $Z$). The weight-$n$ $Z$ operators in the superposition will have the amplitude $\left(-i\sin\theta\right)^{n}\left(\cos\theta\right)^{J-n}$.

Of course if we are allowed to flip all the qubits right in the middle of the channel, we can flip the direction of the rotation and cancel the coherent error, which is just a simple example of dynamical decoupling. However, if we look at for example high frequency global $Z$ noise, in which the direction of the global $Z$ rotation may flip after a very short time interval in a random walk fashion, dynamical decoupling cannot be applied. In such a case, we have discussed how Pauli conjugation can be used to mitigate such noise in Appendix K. It builds from our discussion in this section, in which we will be looking at the coherent global $Z$ rotation noise described in (6) without allowing gates to be performed in the middle of the channel.

Since the noise only consists of $Z$ components, all pure $Z$ twirling generators will act trivially on the noise, thus can be removed. This noise is symmetric under any qubit permutation. Hence, any permutation symmetry of the quantum error correction code will also exist for the noise.

For all the codes that we will discuss in this section, their logical Pauli gates consist of applying physical Pauli gates to all the qubits. Thus the code symmetry condition in Section III.3 can be reduced into (5). Along with the fact that we have pure Z noise, we only need to focus on the symmetry of the $X$ stabilisers in this section when we talk about the symmetry of a code, except for the five-qubit code. Global logical Pauli gates also mean that $N(\frac{\pi}{2})$ will be the $Z$ logical operator. Thus the logical fidelity curve against different $\theta$ will have a rotational symmetry about $\theta=\frac{\pi}{4}$ (see Appendix E), which means that we only need to look at $0\leq\theta\leq\frac{\pi}{4}$ to see the effect of the noise on logical fidelity.

IV.1 Steane Code

In the Steane Code, we have

• •

Stabiliser generators $\widetilde{\mathbb{S}}$: $X$ or $Z$ checks on plaquettes $(1,4,6,7)$, $(2,4,5,7)$ and $(3,5,6,7)$.

• •

Logical generators $\widetilde{\overline{\mathbb{G}}}$: $X$ or $Z$ on all qubits.

Following Section III.1, we can construct our twirling generators to be

[TABLE]

Since the noise only consists of $Z$ components, all pure $Z$ twirling generators will act trivially on the noise, thus can be removed, we then have:

[TABLE]

which generates the twirling set:

[TABLE]

Note that here we have transformed the error operators to their lowest weight equivalence that produce the same error syndromes.

The Steane code has the same symmetry as the Fano plane Huang et al. (2019), whose permutation symmetry group will be denoted as $\mathbb{U}$. Since our noise model is symmetric under any qubit permutation, all $U\in\mathbb{U}$ satisfied (3).

Now for every pair of single-qubit $X$ operators $X_{i},X_{j}\in\mathbb{W}$, we can find at least one $U\in\mathbb{U}$ such that

[TABLE]

Hence, using (4) we know that all the remaining single-qubit $X$ twirling operators are equivalent.

There are two equivalence class of twirling gates here, one is equivalent to $I$, while the other is equivalent to $X_{1}$ (or any single-qubit $X$ gate).

The effect of different strategies on the logical fidelity of Steane code is shown in Figure 2. We can see that twirling is consistently better than doing nothing, while $X_{1}$ conjugation will yield even higher fidelity than twirling.

IV.2 Other Codes

In this section, we will explore the effect of Pauli conjugation using other codes under the same noise model. The details of finding the equivalent class of conjugating gates for different codes are outlined in Appendix F. Here we will just look at the effect of using conjugating gates in different equivalence classes and compare their effects to doing nothing and twirling.

IV.2.1 Five-qubit code

The structure of five-qubit code is shown in Figure 3.

There is just one non-trivial conjugating strategy in five-qubit code, which is conjugation with any single-qubit X gate, the same we found in the Steane code. However, in our noise model, we found that this strategy makes no difference to the logical fidelity compared to doing nothing. Consequently, the twirled logical fidelity is also the same. Hence, rather interestingly under our noise model, none of the strategies works for the five-qubit code.

IV.2.2 Nine-qubit Shor code

The structure of the nine-qubit Shor code is shown in Figure 4.

There are three types of non-trivial Pauli conjugations in the nine-qubit Shor code for our noise model:

• •

Single qubit flip: $X_{1}$

• •

Two-qubit flip (in different rows): $X_{1}X_{4}$

• •

Three-qubit flip (in different rows): $X_{1}X_{4}X_{7}$

The effects of these strategies on the logical fidelity are shown in Figure 5. We see that doing nothing will result in a dip at $\theta=\frac{\pi}{6}$, where our noise turns into a logical operator. Twirling can definitely mitigate such a problem, leading to a great jump in fidelity. Superior improvements can be achieved by conjugating the noise with $X_{1}X_{4}X_{7}$.

The result for the other nine-qubit Shor code with the X and Z checks exchanged is shown in Appendix H.

IV.2.3 Distance-3 surface code

The structure of the distance-3 surface code is shown in Figure 6.

The non-trivial conjugating strategies and their effects on the logical fidelity are shown in Figure 7. Again we see improvement of the twirled fidelity over doing nothing, and a marked improvement of conjugating the noise with $X_{1}X_{8}$ over twirling.

IV.3 Gate Error

In reality, applying extra Pauli gates does not come free due to the errors associated with the gates. We should expect the effect of such errors due to Pauli conjugation to be small since the quantum error correction circuits involve far more gates than Pauli conjugation and also contain two-qubit gates which usually have much lower fidelity than single-qubit Pauli gates. Here we have simulated the performance of different schemes using different codes with depolarising gate error rates of $0.5\%$ and $1\%$ for the encoding circuit, the quantum error correction circuit and the Pauli conjugation gates (with the details of the circuits shown in Appendix I). From the result in Figure 8 we can see that as we increase the gate error rate, the fidelity curves shift downward without much change to their shapes. Hence, the optimal Pauli conjugation schemes maintain their advantages over doing nothing when we take into account gate errors. The fidelity curves using twirling are not shown. However in our examples, we should expect the advantage of Pauli conjugation over twirling increases with increasing gate error rates since the average weights of the twirling gates are higher than that of the conjugation gates.

When trying to implement Pauli conjugation in practice, such gate errors can be mitigated by absorbing the conjugation gates into the existing gates in the circuit. Such a strategy has been proven to be effective in the case of twirling Wallman and Emerson (2016).

IV.4 Concatenated Threshold

As discussed by Rahn et al. Rahn et al. (2002), after finding the map between the physical noise channel and the logical noise channel with one level of encoding, composing this map will give us the physical-logical noise map for the concatenated code. Here we have assumed that we are using a hard decoder which only takes into account of syndrome information of the current concatenation level. Finding such maps will allow us to compute the performance of a code with different levels of concatenation and hence find its concatenated threshold. Such analysis was carried out in Huang et al. (2019) for a variety of codes. Here we will use the local $Z$ noise map obtained in Huang et al. (2019) to calculate the concatenated threshold for different codes when we apply different kinds of noise tailoring schemes at the physical level (not at any subsequent levels of concatenation). From the results in Figure 9, we can see the logical fidelity of the threshold crossing points of different noise tailoring schemes are essentially the same. Hence when we try to achieve the threshold logical fidelity with one level of encoding, if one scheme has a higher tolerance of the physical error than another scheme, we should expect a similar improvement in the concatenated threshold. The improvement of the conjugated threshold over the original threshold is $40\%$, $160\%$ and $110\%$ for the Steane code, 9-qubit Shor code and distance-3 surface code respectively. All of them also show improvements of the conjugated thresholds over the twirled thresholds.

V Composing the Error Channels

V.1 Multiple Rounds of Quantum Error Correction

As mentioned in the introduction, coherent errors can be more damaging than incoherent errors because they can accumulate at a faster rate Sanders et al. (2015); Greenbaum and Dutton (2018). Hence, we use Pauli twirling to remove the coherent nature of the error channel for each round of error correction so that errors in multiple rounds of error correction will accumulate at a more favourable scaling. As demonstrated in the previous sections, Pauli conjugation can improve the logical fidelity for coherent errors in one round of error correction. However, the error remains coherent after conjugation, which means that the advantages of conjugation can be lost when we go to multiple rounds of error correction.

Fortunately this can be overcome by injecting ‘just enough’ randomness – the solution might be called ‘logical twirling’ of the error channel (instead of twirling at the physical level). Logical twirling simply means twirling over the logical Pauli operators and decohere the Pauli components that corresponding to different logical operators. The resultant effective channel will be logically incoherent and thus the errors will accumulate at a more favourable rate in terms of logical fidelity. For one round of quantum error correction, applying logical twirling will not change the logical fidelity just like twirling a noise channel will not change its fidelity. Hence, applying logical fidelity on top of conjugation can maintain the fidelity improvement brought by conjugation in each round of error correction while preventing the logical errors from rapid accumulation as we go to multiple rounds.

The Pauli components of a given noise channel can be partitioned into sets that correspond to different logical operators with different measured syndromes after quantum error correction. As discussed in Section II.4, the coherence between the components that correspond to the same logical operator and the same syndrome can be used by conjugation to improve the logical fidelity of the channel in one round of quantum error correction (via destructive interference between the logical error components), while in this section we see that the coherence between different logical operators can be removed by logical twirling to fight the accumulation of logical errors in multiple rounds of quantum error correction.

In Appendix J, using global $Z$ rotation as an example, we have demonstrated that using conjugation alone, the advantages of conjugation over physical twirling will diminish as we go to more rounds of quantum error correction and we have also shown how this is overcome by using logical twirling.

V.2 Multiple Rounds of Noise Tailoring

Instead of applying both noise tailoring and error correction at each time step, we can apply just noise tailoring in each time step and only do one round of error correction at the very end.

The matrix elements for the effective noise channel with $K$ rounds of twirling are:

[TABLE]

Here we divide the noise process into $K$ steps and apply a random Pauli gate $W_{k}$ at the beginning of each step. At the end, we undo all these random Pauli gate by applying the their inverse $\prod_{k=1}^{K}W_{k}$ and then perform quantum error correction. We denote the set of $K$ Pauli gate chosen using a vector $\vec{W}$. Similar to our arguments in Section II.3, multiple rounds of twirling correspond to the average of all the Pauli conjugation schemes, thus one of the Pauli conjugations will be optimal and outperforms twirling.

As detailed in Appendix L, if we want to find the equivalent conjugations to reduce the search space for multi-round conjugation, we can use similar arguments about the structure of the noise (Section III.2) and the symmetries in both the noise and the code (Section III.3), while the arguments about interaction with the code space to remove stabilisers and logical operators (Section III.1) can only be applied to the outer-most round of conjugation.

The search space of possible conjugations grows exponentially with the number of rounds while the number of symmetries that we can utilise is less than the one-round case (since we cannot remove all the stabilisers and logical operators from the twirling generating set). Hence, iterating over the whole search space might not be practical for a large number of rounds. However, we can still sample different conjugation schemes in our reduced search space to find a better scheme than doing nothing or even twirling, though such a scheme might not be optimal.

VI Conclusion

In this Article, we have shown that when doing one round of quantum error correction on a coherent noise channel, part of its coherence can actually be used to improve its logical fidelity using Pauli conjugation, which outperforms twirling. To search for the optimal Pauli conjugation under a given noise model using a given quantum error correction code, we use the properties and the symmetries of the noise and the code to identify the equivalent conjugations to reduce our search space. We applied our techniques to the Steane code, the Shor code and the surface code under a global $Z$ rotation noise, reducing the $4^{n}$ possibilities of Pauli conjugation to $2$, $4$ and $6$ equivalent classes respectively for those three codes. Iterated over these different classes of conjugations, we managed to find the optimal conjugations for each code, which resulted in higher logical fidelities than the twirled and original noise channel. We have shown via simulation that the advantages of the optimal Pauli conjugation schemes remain with gate errors present. Conjugation can also lead to higher concatenated thresholds than the twirled threshold. The conjugated threshold showed improvements over the original thresholds by $40\%$, $160\%$ and $110\%$ for the three codes we considered under the coherent $Z$ noise. We showed that by using logical twirling to remove the ‘harmful’ coherence within the error channel, we can extend the advantages of Pauli conjugation to multiple rounds of error correction. We also briefly discussed how to extend our arguments into multiple rounds of Pauli conjugation.

Compared to twirling, Pauli conjugations does not require the implementation of a random circuit, and the weights of the gates that we need to implement can be on average much smaller than twirling as shown by our examples. Being a deterministic scheme, it can be implemented in hardware systems in which modifying the circuit at each run is hard. It can also be used in quantum communication to combat coherent noise in the communication channel without needing to transmit the extra random bit needed by twirling. Single-qubit Pauli gates are usually the gates with the highest fidelity, combining with the fact that the Pauli conjugation gates we need to implement can be low-weight, it should be resilient to gate errors, as shown by our simulation. Hence, Pauli conjugation can be a practical way forward to mitigate errors in real experiments.

The way we reduce the Pauli conjugation search space is highly dependent on the code we use and the noise model we have. Though our techniques work for the simple examples that we have considered, searching over all possible Pauli conjugations may not be feasible when the size of our system increase, when there are very few symmetries in the noise or when we are considering multiple rounds of Pauli conjugation. Hence, we might want to find a way to construct the optimal conjugation based on the mechanism of conjugation in Section II.4, or at least find a better searching strategy than random sampling. Furthermore, we may not know the full noise model in practice. As discussed in Section II.4, conjugation will only act on the coherent components in the channel, thus to find the optimal (or close-to optimal) conjugation gate we only need the information about the dominant coherent component in the channel without needing any information about the incoherent parts or the other small coherent components. In the worst case scenario, we can still sample over the different Pauli conjugations based on any limited information we have to find a scheme with better performance than the original noise channel instead of finding the optimal one.

The above ideas can be tested by applying Pauli conjugation to more general error channels beyond the global $Z$ rotation. An example will be the general local $Z$ noise channel considered in Huang et al. (2019) or some non-biased noise models like those considered in Gutiérrez et al. (2016). To see if the conjugation technique is valuable in fault-tolerant computation, it will also be interesting to see how Pauli conjugation will perform against gate-level coherent noise and whether it can improve the surface code threshold (instead of the concatenated threshold) given a realistic noise model.

There are several degrees of freedom we can add to further optimise our noise tailoring schemes. Firstly, throughout this Article we have been focusing on conjugation using Pauli gates, it will be interesting to extend our technique to Clifford gates or even general unitaries. We can also look into the case where we allow Clifford correction Chamberland et al. (2017). We definitely did not exhaust all the ways to reduce the Pauli conjugation search space. For example, we have only been focusing on the permutation symmetry of code and noise, which at best can only prove the operators with the same weight are equivalent. A next step could be including other Clifford symmetries like CZ gates, etc.

Our conjugation scheme, especially the multi-round variant, in a way can be viewed as bang-bang dynamical decoupling tailored to a given quantum error correction code. Attempts has been made before to study the effect of dynamical decoupling within the context of quantum error correction Ng et al. (2011), though without explicitly considering the code structure like we did in this Article. It will be a fruitful area to adapt more schemes in the established literature of dynamical decoupling Suter and Álvarez (2016) into the context of quantum error correction taking into account the code structure. We may get a fuller understanding about how to search for better multi-round conjugation scheme from the way we optimise dynamical decoupling using average Hamiltonian arguments Viola et al. (1999) and group theoretic arguments Zanardi (1999). Ideas like non-equidistant pulses Uhrig (2007), robust decoupling sequences and higher-order decoupling Suter and Álvarez (2016) can also be extended into multi-round conjugation.

Besides applications in quantum error correction for memory, the conjugation technique can also be extended into other fields like quantum metrology and quantum simulation. For quantum metrology with error correction Kessler et al. (2014); Dür et al. (2014); Zhou et al. (2018), we hope to find conjugation schemes that can tailor the noise into a form that is less damaging to the code and/or tailor the signal into a form that the code is more sensitive towards. When applied to symmetry verification in quantum simulation Bonet-Monroig et al. (2018); McArdle et al. (2019); McClean et al. (2019), conjugation may enable more noise to be detected via transformation of the previously undetected noise components. In the above applications, it is likely that we need to develop more complex conjugation schemes beyond one-round Pauli conjugation.

Acknowledgements

The authors are grateful to Markus Müller for helpful and encouraging conversations. ZC thanks Y. Li for valuable discussions and E. Huang for providing the equations for the noise map used in the calculation of the concatenated thresholds.

ZC acknowledges support from Quantum Motion Technologies Ltd.

SCB acknowledges support from ESPRC grant EP/M013243/1 (the NQIT Quantum Hub).

SCB and XX are supported by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA), via the U.S. Army Research Office Grant No. W911NF-16-1-0070. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the view of the U.S. Army Research Office.

Competing Interests

The authors declare no conflict of interest.

Data Availability

The data sets generated during the current study are available from the corresponding author on reasonable request.

Contributions

ZC performed the theoretical analysis and wrote the manuscript with input from SCB. XX performed the numerical simulation for the circuits with gate errors, ZC performed the other numerical simulations.

Appendix A Construction of $\widetilde{\mathbb{E}}$

Recall that the error generators $\widetilde{\mathbb{E}}$ are just all the remaining generators needed to complement the stabiliser generators and the logical generators for generating the full Pauli gate set. The requirements of $\widetilde{\mathbb{E}}$ are

All of its elements are independent. 2. 2.

The size of $\widetilde{\mathbb{E}}$ is $|\widetilde{\mathbb{E}}|=|\widetilde{\mathbb{S}}|$. 3. 3.

The full set of elements that can be generated by $\widetilde{\mathbb{E}}$ does not contain any elements in $\mathbb{S}$ or $\overline{\mathbb{G}}$, otherwise we can replace the generators in $\widetilde{\mathbb{E}}$ with the elements in $\mathbb{S}$ or $\overline{\mathbb{G}}$.

The full Pauli set $\mathbb{G}$ can be generated using all the single physical qubit $X$ and $Z$ gate, after removing the elements that are dependent on each other through composition with stabiliser generators and/or logical generators, we will be left with the generating set $\widetilde{\mathbb{E}}$. Hence, we can always find a $\widetilde{\mathbb{E}}$ that consist of only single qubit $X$ or $Z$ operators. Here we will show how do we construct it.

Any practical stabiliser error correction code will be able to detect and correct all single qubit $X$ and $Z$ errors, hence all of these single-qubit errors will violate different subsets of stabiliser checks. The way we construct $\widetilde{\mathbb{E}}$ is:

Find all single-qubit $X$ and $Z$ errors that violate only one stabiliser check and add them to $\widetilde{\mathbb{E}}$. We will denote the set of stabiliser checks that they violate as $\mathbb{S}_{E}$. 2. 2.

Starting with $n=2$, search in the checked physical qubits of the stabiliser checks in $\mathbb{S}_{E}$, there will be $X$ or $Z$ errors on these qubits that fail $n$ stabiliser checks, with one and only one of the failed stabiliser checks not in $\mathbb{S}_{E}$. For each of such error we found, we will add it into $\widetilde{\mathbb{E}}$ and add the one additional violated stabiliser check into $\mathbb{S}_{E}$. Note that for each new element added into $\mathbb{S}_{E}$, we will have more physical qubits to check. 3. 3.

Repeat step 2 with $n$ increasing by 1 in each iteration until $\mathbb{S}_{E}=\widetilde{\mathbb{S}}$, i.e. until $\mathbb{S}_{E}$ contains all the stabiliser checks (or equivalently until $|\widetilde{\mathbb{E}}|=|\widetilde{\mathbb{S}}|$).

In the case of topological code with boundaries, the above scheme is just starting by adding the stabiliser checks at the boundary into $\mathbb{S}_{E}$ and slowly progressing inwards, adding the inner stabiliser checks into $\mathbb{S}_{E}$ until all stabiliser checks are within $\mathbb{S}_{E}$.

In this way of construction, there is no way to find any composition of elements in $\widetilde{\mathbb{E}}$ such that there are no stabiliser checks fail, hence there is no way to compose stabilisers or logical operators out of these elements.

Appendix B Construction of $\mathbb{W}$

With the twirling generators $\widetilde{\mathbb{W}}$ obtained in Section III.2, we can now generate the full set of twirling gate $\mathbb{W}$. The elements in the twirling set $\mathbb{W}$ will correspond to the error operators that are detectable by our quantum error correction code and will all have different syndromes. For the purpose of twirling, we would want to replace these operators with the lowest weight error operators that produce the same syndrome (i.e. equivalent up to composition with stabilisers and logical operators), since operators with lower weight will be easier to implement with fewer errors induced. These are usually just the recovery operators of the given syndromes, in such case we can just get them from the decoder. For a distance-$d$ code, by definition all errors with weight $d-1$ or lower produce non-trivial error syndromes, and all errors with weight $\lfloor\frac{d-1}{2}\rfloor$ or below will have different syndromes (thus correctable). Hence, for all $W\in\mathbb{W}$ with weight $\lfloor\frac{d-1}{2}\rfloor$ or below, they are already the lowest weight operators that can produce the given syndrome, while for the others in $\mathbb{W}$ it may be possible to find a lower weight equivalence (not guaranteed to find since some correctable errors can be of higher weight than $\lfloor\frac{d-1}{2}\rfloor$, e.g. a surface code with very long $Z$ boundaries and very short $X$ boundaries).

Appendix C Twirling Generators Reduction

Using $\overbracket{\overbracket{\quad}}$ to denote ‘super-super-operators’:

[TABLE]

we can rewrite that twirling process as:

[TABLE]

[TABLE]

Here we have implicitly assumed that $\overbracket{\overbracket{W}}$ only acts on $\mathcal{N}$: $\overbracket{\overbracket{W}}\mathcal{N}=\overbracket{\overbracket{W}}(\mathcal{N})$.

Hence, the matrix elements for the twirled logical channel are

[TABLE]

All Pauli super-operators commute, thus all Pauli super-super-operators also commute. Hence, we can arrange the order of the twirling generators in $\prod_{W\in\widetilde{\mathbb{G}}}\left(I+\overbracket{\overbracket{W}}\right)$ in any way we want. We will arrange it in the following way

[TABLE]

where $\widetilde{\mathbb{E}}_{c}$ is a subset of $\widetilde{\mathbb{E}}$ that acts trivially on noise $\mathcal{N}$ when used for twirling as discussed in Section III.2.

Thus $\frac{1}{2^{|\widetilde{\mathbb{E}}_{c}|}}\prod_{E_{c}\in\widetilde{\mathbb{E}}_{c}}\left(I+{\overbracket{\overbracket{E}}}_{c}\right)$ will act trivially on $\mathcal{N}$ and can be absorbed by $\mathcal{N}$ when we put them closest to $\mathcal{N}$.

On the other hand, the twirling of $\widetilde{\mathbb{S}}$ and $\widetilde{\overline{\mathbb{G}}}$ will act trivially on the error correction code and the logical states (see Section III.1), hence we can put them nearest to the logical states to remove them.

In Section III.3, the equivalence of the twirling gates is obtained via interaction with both the noise elements and the logical states. To allow a generator to interact with both the noise elements and the logical states, we need to permute the symmetry operator of the noise elements or the logical states through the other generators, which will modify them. Hence instead of proving equivalence of generators, we expand out the product of generators to obtain a linear combination of the elements in the twirling set, and prove their equivalence instead.

Appendix D Derivation of Eqn (4)

If all the code state basis $\Pi_{\vec{0}}\overline{G}$ and the physical noise channel $\mathcal{N}$ are invariant under the Clifford transformation $U$:

[TABLE]

then the recovery channel $\mathcal{R}$ will also be invariant under the same transformation since it is completely based on the code and the error channel: $\left[\overbracket{U},\mathcal{R}\right]=0$.

Hence, we have:

[TABLE]

Thus

[TABLE]

Since $\overbracket{W}$ and $\mathcal{R}$ are both Pauli channel, they commutes, hence

[TABLE]

Since $U$ is Clifford, $U^{\dagger}WU$ is Pauli, hence $\overbracket{U^{\dagger}WU}$ commute with $\mathcal{R}$:

[TABLE]

Appendix E Shape of Fidelity Curve for Global $Z$ Rotation

E.1 Rotational symmetry of the fidelity curve

For the noise model in (6) and for all the codes we considered which have global logical $Z$ gates, we have:

[TABLE]

For the worst case fidelity $Q$ for such pure $Z$ noise, we will start and measured in the logical $\ket{+_{L}}$ eigenstate:

[TABLE]

[TABLE]

For fidelity of one qubit, we have:

[TABLE]

Hence, we have:

[TABLE]

Hence, the logical fidelity curve $F(\theta)$ is rotationally symmetry about a point at $\theta=\frac{\pi}{4}$

E.2 Fidelity at $\theta=\frac{\pi}{4}$

For the noise model in (6), at $\theta=\frac{\pi}{4}$ we have:

[TABLE]

For an operator $U$ consist of tensor product of single-qubit $Z$, we will write the set of qubit index that we apply $Z$ gate on as $\vec{U}$:

[TABLE]

Hence, the terms in the expansion of (9) will be $(-i)^{\absolutevalue{\vec{U}}}\prod_{i\in\vec{U}}Z_{i}=(-i)^{\absolutevalue{\vec{U}}}U$. In the case of measuring the zero syndrome, $N(\frac{\pi}{4})$ will collapse into a superposition of stabilisers and $Z$ logical operators. For each stabiliser term $(-i)^{\absolutevalue{\vec{S}}}S$ in the expansion, there will be a corresponding logical $Z$ operator term differed by apply $Z$ to all qubits: $(-i)^{J-\absolutevalue{\vec{S}}}S\left(\prod_{j}Z_{j}\right)=(-i)^{J-\absolutevalue{\vec{S}}}S\overline{Z}$, hence the terms in the expansion correspond to zero syndrome is:

[TABLE]

If all stabilisers have even weights, i.e. $|\vec{S}|=2n$, then $2|\vec{S}|=4n$, hence $(-i)^{J-2\absolutevalue{\vec{S}}}=(-i)^{J}(-i)^{-2\absolutevalue{\vec{S}}}=(-i)^{J}$.

Thus if all the stabilisers have even weights, and the logical $Z$ operator consist of applying $Z$ to all the qubits, then the terms in the expansion of (9) is:

[TABLE]

and similarly for other syndromes. Note that terms of other syndromes will also result in the same amplitude $\absolutevalue{\mathbb{S}}$. Hence, we have the same probability of collapse into any syndrome. For odd number of qubits $J$, we then have a logical $Z$ rotation of the angle $\frac{\pi}{2}$ (or $-\frac{\pi}{2}$), which means a worst case fidelity of $\frac{1}{2}$ and an average fidelity of $\frac{2}{3}*\frac{1}{2}+\frac{1}{3}=\frac{2}{3}$.

Appendix F Equivalent Conjugation Classes for Codes in Global $Z$ Rotation

Recalled the arguments in Section IV. We can make the following simplification based on the codes and the noise model we consider.

• •

Our noise model is global, thus have all possible qubit permutation symmetry. Along with the fact that our codes have one logical qubit and global Pauli gates mean that we only need to consider the permutation symmetry of the stabilisers when we try to reduce the twirling set.

• •

The noise model is pure $Z$ noise, thus all $Z$ twirling generators can be removed. All $Z$ stabiliser checks will also have trivial effects (besides the five-qubit code which does not have pure $Z$ checks), thus we only need to consider the permutation symmetry of the $X$ stabilisers.

F.1 Five-qubit code

In five-qubit code, the generators are

• •

Stabiliser generators $\widetilde{\mathbb{S}}$: $XZZXI$ and three of its cyclic permutations $IXZZX$, $XIXZZ$, $ZXIXZ$

• •

Logical generators $\widetilde{\overline{\mathbb{G}}}$: $X$ or $Z$ on all qubits.

Following Section III.1, we can construct the twirling generators:

[TABLE]

As mentioned above, the $Z$ twirling generators can be safely removed since we have pure $Z$ noise:

[TABLE]

which generates the twirling set:

[TABLE]

Here we have transform the error operators $X_{1}X_{2}$ to its lowest weight equivalence with the same error syndromes $Z_{4}$. Conjugating the noise with $Z_{4}$ has trivial effect since we have pure $Z$ noise.

The five-qubit code has cyclic permutation symmetry (there are also additional symmetries that we do not need to use here Huang et al. (2019)). As discussed in Section III.2, using these symmetry transformation, we can easily prove that conjugating the noise with $X_{1}$ is equivalent to $X_{2}$ since $X_{2}=U^{\dagger}X_{1}U$ where $U$ is one of the qubit cyclic permutation operator.

Hence, there are two equivalent class of twirling gate, one is equivalent to $I$, while the other is equivalent to $X_{1}$ (or any single-qubit $X$ gate by cyclic permutation).

F.2 Nine-qubit Shor code

F.2.1 With Local Z checks

As shown in Figure 4, in nine-qubit Shor Code, the generators are

• •

Stabiliser generators $\widetilde{\mathbb{S}}$: $\{Z_{i}Z_{i+1}\ |\ i\in\{1,2,4,5,7,8\}\}$ and $\{\prod_{j=0}^{5}X_{i+j}\ |\ i\in\{1,4\}\}$

• •

Logical generators $\widetilde{\overline{\mathbb{G}}}$: $X$ or $Z$ on all qubits.

Following Section III.1, we can construct our twirling generators:

[TABLE]

As mentioned above, the $Z$ twirling generators can be safely removed since we have pure $Z$ noise:

[TABLE]

When looking at the $Z$ stabiliser checks, which will produce the syndromes for these $X$ error operators, we realise they are divided into 3 non-overlapping set (no shared checked qubits), which are individual rows in Figure 4. All the error syndromes within each row can be produced by single-qubit $X$ errors within that row. The Z-check syndrome of different rows are independent of each other since they do not share any qubits. Hence, to produce all possible syndromes using error operators with the lowest weight, we will have zero or one single-qubit X errors in each row. This set of error operators will be the full twirling set $W$ that is generated.

Permutation symmetries that exist in the 9-qubit Shor code will be any permutation of the elements within each row and any permutation between the rows shown in Figure 4. In such a case, all the operators with the same weight in our twirling set can be shown to be equivalent, leaving us with the following four equivalent classes of twirling operators.

• •

Identity: $I$

• •

Single qubit flip: $X_{1}$

• •

Two-qubit flip (in different row): $X_{1}X_{4}$

• •

Three-qubit flip (in different row): $X_{1}X_{4}X_{7}$

F.2.2 With Local X checks

It is still a nine-qubit Shor code, with a swap between the $X$ and $Z$ stabilisers.

Following Section III.1, we can construct our twirling generators:

[TABLE]

As mentioned above, the $Z$ twirling generators can be safely removed since we have pure $Z$ noise:

[TABLE]

which generates the twirling set:

[TABLE]

Here we have transform the error operators $X_{1}X_{7}$ to its lowest weight equivalence with the same error syndromes $X_{4}$.

We have the same code symmetry as the other Shor code, which allows us to prove the equivalence of conjugation with $X_{1}$, $X_{4}$ and $X_{7}$.

Hence, there are two equivalent class of twirling gate, one is equivalent to $I$, while the other is equivalent to $X_{1}$ (or any single-qubit $X$ gate).

F.3 Distance-3 surface code

The stabiliser generators of the distance-3 surface code is shown in Figure 6.

Following Section III.1, we can construct our twirling generators:

[TABLE]

As mentioned above, the $Z$ twirling generators can be safely removed since we have pure $Z$ noise:

[TABLE]

which generates the twirling set:

• •

Weight-1: $X_{1}$, $X_{2}$, $X_{3}$, $X_{5}$, $X_{7}$, $X_{8}$, $X_{9}$

• •

Weight-2: $X_{2}X_{7}$, $X_{1}X_{7}$, $X_{1}X_{8}$, $X_{1}X_{9}$, $X_{2}X_{9}$, $X_{3}X_{9}$, $X_{3}X_{8}$, $X_{2}X_{8}$

The logical Pauli gates of the code are just applying the corresponding Pauli gates to all the physical qubits (because it is an odd distance surface code), hence we only need to look at the symmetry of its stabilisers as discussed in Section III.3. We can group the operators that are equivalent due to the rotational symmetry of the code: ($X_{1}$, $X_{9}$), ($X_{2}$, $X_{8}$), ($X_{3}$, $X_{7}$), ($X_{5}$), ($X_{2}X_{7}$, $X_{3}X_{8}$), ($X_{1}X_{7}$, $X_{3}X_{9}$), ($X_{1}X_{8}$, $X_{2}X_{9}$), ($X_{1}X_{9}$), ($X_{2}X_{8}$).

Since we have only pure $Z$ noise, we only need to look at the symmetry exists in the X stabilisers, leading to additional symmetry in the exchange between qubits ($1$, $2$) and between qubits ($8$, $9$). Applying on top of the rotational symmetry, we have the following classes of equivalent conjugations:

• •

$I$

• •

$X_{1}$, $X_{2}$, $X_{8}$, $X_{9}$

• •

$X_{3}$, $X_{7}$

• •

$X_{5}$

• •

$X_{1}X_{7}$, $X_{3}X_{9}$, $X_{2}X_{7}$, $X_{3}X_{8}$

• •

$X_{1}X_{9}$, $X_{2}X_{8}$, $X_{1}X_{8}$, $X_{2}X_{9}$

Appendix G Effective $Z$ Logical Channel Conditioned on Syndrome

When we expand the physical noise $e^{-i\theta\sum_{j}Z_{j}}$ into the sum of tensor products of $Z$, all the odd-weight term will form the imaginary part, while all even-weight terms will form the real part. Hence, when we flip the sign of $\theta$, which is equivalent to taking the complex conjugate of our noise channel, all the odd-weight terms (the imaginary part) will flip their signs while all the even-weight terms (the real part) will remain the same.

By saying the operator is real (imaginary) here, we mean that the operator has real (imaginary) amplitude. Since we are only considering $Z$ noise, composing two $Z$ operators together will not lead to any extra phase factor $i$. Thus when we compose an imaginary $Z$ operator with a real $Z$ operator, we will get an imaginary $Z$ operator, while composing two imaginary or two real operators will give a real $Z$ operator.

For all the codes we consider here, they have stabiliser generators that are all even-weight, which means that they are all real in the noise expansion. For our codes, we can find one of the logical operators $\overline{Z}$ is odd-weight, which corresponds to imaginary amplitude in the expansion, thus all $\overline{Z}$ are imaginary since they can be obtained by composing the imaginary $\overline{Z}$ with the real stabilisers. Hence, when we measured the [math] syndrome, the noise is collapsed into a coherent superposition of $\overline{I}$ with real amplitude and $\overline{Z}$ with imaginary amplitude. When we flip the sign of the physical error angle $\theta$, it is the same as taking the complex conjugate, which will flip the sign of $\overline{Z}$ since its amplitude is pure imaginary. For other syndromes with error $E$, we still have one of $E\overline{Z}$ and $E\overline{I}$ being one real and the other being imaginary and hence similar argument follows.

For codes with odd-weight stabiliser generators, we will have a complex amplitude (mix of real and imaginary) for $\overbracket{I}$. On the other hand, for codes with even-weight logical operators (even distance code), it will give real $\overline{Z}$ for real $\overline{I}$ and imaginary $\overline{Z}$ for imaginary $\overline{I}$. In both case, since the phase of $\overline{I}$ and $\overline{Z}$ are no longer guaranteed to be differed by $i$, the logical channel for a given syndrome can no longer be written as a logical $\overline{Z}$ rotation, but instead a combination of logical $\overline{Z}$ rotation and logical dephasing channel. This was observed by Huang et. al. Huang et al. (2019) for even-distance repetition code and distance-4 surface code.

Appendix H Pauli Conjugation for the Other 9-qubit Shor Code

In the main text, we have only shown results for the 9-qubit Shor code local $Z$ checks. For the 9-qubit Shor code with local $X$ check, its average fidelity of different conjugation schemes and its concatenated threshold plots are shown in Figure 10 and 11.

For the $Z$ noise we considered, the 9-qubit Shor code that has local $X$ checks will actually have better performance since it has more $X$ checks which are sensitive to $Z$ noise. This is shown by the large gap between the two original fidelity curve in Figure 12. However, after using conjugation to tailor the noise to fit the code, the Shor code with local $Z$ checks receives a huge boost in fidelity such that it even exceeds the fidelity of the other Shor code with conjugation. This further exemplifies the power of Pauli conjugation when there is a misfit between the code and the noise.

Appendix I Detailed Circuit for the Codes

Here in Figure 13, 14 and 15, we outline the encoding circuits and the parity check circuits we used for our codes.

Appendix J Multiple Rounds of Error Correction under Global Z Rotation

J.1 Without logical twirling

All the codes that we have considered in this section have one logical qubit and transversal $Z$ gates. When they undergo coherent $Z$ noise, the effective logical error for a given measured syndrome $\vec{m}$ after correction will be a logical $Z$ rotation of angle $\theta_{\vec{m}}$. Hence, the effective logical error channel averaged over all the syndrome measurements is:

[TABLE]

The Pauli transfer matrix of $\overline{Z}(\theta)$ is

[TABLE]

with the eigenvalues $1,1,e^{-i\theta},e^{i\theta}$, and the same eigenvectors independent of $\theta$. Hence, $\overline{\mathcal{N}}_{0}$ will have the same eigenvectors with the eigenvalues $1,1,\sum_{\vec{m}}p_{\vec{m}}e^{-i\theta_{\vec{m}}},\sum_{\vec{m}}p_{\vec{m}}e^{i\theta_{\vec{m}}}$.

Hence, after $k$ round of error correction, the logical fidelity is:

[TABLE]

If we twirl the $Z$ noise channel, then we will have a logical dephasing channel instead. Thus $\overline{\mathcal{N}}_{T}$ is a diagonal matrix with eigenvalues: $1,1-2p_{d},1-2p_{d},1$ where $p_{d}$ is the dephasing probability.

Hence, for $k$ round of error correction (each round undergo the same noise as before), the logical fidelity is:

[TABLE]

Using these formulae, in Figure 16 we have plotted the logical fidelity of different schemes for different codes after $100$ cycles; in each cycle, error correction follows a period of exposure to the environment which induces global $Z$ rotation with angle $\theta$. In all codes, we can see the improvements of the Pauli conjugation schemes and the twirling scheme over doing nothing in small $\theta$. In Shor code and surface code, we can see the advantage of our optimal conjugation scheme over twirling still remains for small error angle $\theta$ in each round even after $100$ rounds. Nevertheless, we can see that in many cases twirling becomes superior to even our best Pauli conjugation after sufficient cycles have occurred; fortunately this can be entirely remedied by an adaption we term ‘logical twirling’.

J.2 With logical twirling

The logically twirled version of the noise channel $\overline{\mathcal{N}}_{0}$ described in (10) is a logical dephasing channel of the form

[TABLE]

The corresponding conjugated noise channel $\overline{\mathcal{N}}_{c}$ will be in a form similar to (10) with different $\phi_{\vec{m}}$. Applying logical twirling on top of conjugation will lead to the channel $\overline{\mathcal{N}}_{c,LT}$. Recall that the corresponding physically twirled noise channel is denoted as $\overline{\mathcal{N}}_{T}$.

Our previous simulations for one round of error correction show that:

[TABLE]

Since logical twirling will not change the logical fidelity (since the eigenvalues of the Pauli transfer matrices are not affected), we have:

[TABLE]

in which $\overline{\mathcal{N}}_{c,LT}$, $\overline{\mathcal{N}}_{T}$ and $\overline{\mathcal{N}}_{0,LT}$ are all logical dephasing channel with different dephasing probability $p_{d}$.

For a single-qubit dephasing channel $\overline{\mathcal{N}}_{d}$ with dephasing probability $p_{d}$, the eigenvalues of its Pauli transfer matrix will be $\{\lambda_{i}\}=\{1,1-2p_{d},1-2p_{d},1\}$. Hence, the logical fidelity of $k$ rounds of $\overline{\mathcal{N}}_{d}$ is Kimmel et al. (2014); Helsen et al. (2019):

[TABLE]

Thus we have:

[TABLE]

Combining with (14), we then have:

[TABLE]

for any positive integer $k$. Hence, with the help of logical twirling, the improvement of logical fidelity using Pauli conjugation over twirling (or doing nothing) with single-round of error correction in global Z rotation will indeed persist when we go to multiple rounds of error corrections.

J.3 Random walk noise model

Up to now, we have only considered the case in which the global $Z$ rotations in each round of error correction are rotations of the same angle in the same direction. In practice, for such a noise model, all we need to do is flip all the qubits right in the middle of the whole process which flips the direction of the rotation and cancels the coherent error. This is just a simple case of dynamical decoupling.

It may be interesting to look at the other extreme in which the error channel is a random walk. Within each round of error correction, there is a equal probability of positive or negative rotation of angle $\theta$: $N(\pm\theta)=e^{\pm i\theta\sum_{j}Z_{j}}$.

A a global $Z$ rotation $e^{-i\theta\sum_{j}Z_{j}}$ will lead to an effective logical error channel as described in (10):

[TABLE]

When the sign of rotation of the physical error $\theta$ is flipped, the sign of the logical rotation $\phi_{\vec{m}}$ will also be flipped for all the codes that we are considering (see Appendix G). For each time step, since we have equal probabilities of positive and negative physical rotations, we also have equal probabilities of positive and negative logical rotations, leading to the effective logical channel:

[TABLE]

which is just the logically twirled channel $\overline{\mathcal{N}}_{0,LT}$. Hence, for such a random walk noise model, the logical channel is already logically twirled and we just need to apply conjugation to it to reduce the effect of the noise.

Appendix K Conjugating High Frequency Noise

For a coherent noise:

[TABLE]

the Hamiltonian $H$ can be broken down into its Pauli basis $\mathbb{G}_{H}$:

[TABLE]

Note that $\beta_{i}$ are real since $H$ is Hermitian.

Now we define the magnitude of $H$ to be $E$, and the normalised version of $H$ to be $h$ where:

[TABLE]

for $\alpha_{i}=\frac{\beta_{i}}{E}$ and $\sum_{i}\alpha_{i}^{2}=1$.

Now the evolution operator is just:

[TABLE]

with $\theta=Et$.

Suppose our noise channel is some high frequency noise that is only coherent for a very short amount of time $\delta t$, resulting in a rotation angle of $\epsilon=E\delta t$:

[TABLE]

Within each time period $\delta t$, the coherent noise will have a $50$-$50$ chance for rotations in the positive and negative directions, just like a random walk. Thus the effective channel over a time period $\delta t$ is just:

[TABLE]

which in the Pauli transfer matrix formalism is just:

[TABLE]

Composing $N$ of such channels together we have:

[TABLE]

Now if $H$ (and thus $h$) contains coherent superposition of multiple Pauli components, then as discussed in Section II.4, conjugation can be used to improve the logical fidelity of the channel by changing the way these components interfere. In particular, if a conjugation scheme works for the channel $\mathcal{U}_{\epsilon}$, then the same scheme should also work for the composite channel $\mathcal{U}_{\epsilon}^{N}\approx\mathcal{U}_{\sqrt{N}\epsilon}$ since their Pauli components interfere in similar ways (as can be seen from their similar structural dependence on $h$). In the case of the global $Z$ rotation that we considered in Section IV, we have discussed why conjugation would work for a single step of the random walk channel $\mathcal{U}_{\epsilon}$ in Appendix J.3 (in which the channel is denoted as $\overline{\mathcal{N}}_{0,\pm}$). Hence, by the arguments above, the same conjugation scheme will also work for the composite channel which corresponds to high frequency global $Z$ noise.

Appendix L Multi-round Twirling Set Reduction

The effective error channel with $K$ rounds of twirling is:

[TABLE]

The argument about structure of noise (Section III.2) can still be applied to the twirling within each individual rounds here, giving us a smaller set of twirling generators $\widetilde{\mathbb{W}}$, from which we can obtained a reduced twirling set $\mathbb{W}$:

[TABLE]

Since we are summing all possible $\vec{W}$ and the twirling set is a group on super-operator composition, we can do the following change of variables: ${\overbracket{W}}_{k}{\overbracket{W}}_{k+1}\Rightarrow{\overbracket{W}}_{k+1}$, which gives:

[TABLE]

In this form, our arguments about interaction of twirling with the code space in Section III.1 can be applied to the outermost twirling set, obtaining a reduced twirling set $\mathbb{W}_{1}$. Hence, we have

[TABLE]

Similar arguments to Section III.3 can be made about the symmetries in both noise and code. However, rather than proving the equivalence of using two different Pauli operators in conjugation, we now will prove the equivalence of using two different sets of Pauli operators in conjugation: i.e. after find the symmetry $U$, we can say a Pauli conjugation set $\vec{W}^{\prime}$ is equivalent to $\vec{W}$ when $U\vec{W}U^{\dagger}=\vec{W}^{\prime}$. Here $U\vec{W}U^{\dagger}$ is defined as:

[TABLE]

Note that this is not a simple tensor product of the single round case. For example, if $W_{1}$ equivalent to $W_{1}^{\prime}$ due to symmetry $U$ and $W_{2}$ equivalent to $W_{2}^{\prime}$ due to another symmetry $U^{\prime}$, this does not means that $\vec{W}=(W_{1},W_{2})$ is equivalent to $\vec{W}^{\prime}=(W_{1}^{\prime},W_{2}^{\prime})$ since the two elements are related by different symmetry: $U\vec{W}U^{\dagger}\neq\vec{W}\neq U^{\prime}\vec{W}U^{\prime\dagger}$.

Appendix M Notation and Definition

• $\overbracket{\quad}$:

Super-operators. e.g. $\overbracket{A}(\rho)=A\rho A^{\dagger}$.

• $\overbracket{\overbracket{\quad}}$:

Super-super-operators. e.g. $\overbracket{\overbracket{A}}(\mathcal{N})=\overbracket{A}\mathcal{N}\overbracket{A^{\dagger}}$.

• $\eta$:

Commutator. $AB=\eta(A,B)BA$ .

• $\widetilde{\quad}$:

Generating set. Note that $\widetilde{A}$ means that $A$ can be generated from $\widetilde{A}$, but does not means that $A$ is the **complete **set of elements that can be generated from $\widetilde{A}$. In our paper, all the composition are carried out ignoring the irrelevant phase factor of the Pauli operators.

• $\mathbb{G}$:

The Pauli set. It is not the Pauli group since we are ignoring all the phase factors.

• $\mathbb{W}$:

The twirling set.