Quantum Error Mitigation by
Pauli Check Sandwiching

We begin by describing the simplest version of the Pauli Check Sandwiching technique that consists of a single pair of parity checks sandwiching the computation (one “layer”). Figure 1 shows a graphical view of the protocol. The unitary operation $U$ represents the gates of the computation. The bottom qubit is the single ancilla introduced by this scheme, and we commonly refer to the $n$ qubits above as the compute or computation qubits.

Let $C_{2}$ ($C_{1}$) be a controlled unitary with control on the ancilla that applies $\tilde{C}_{2}$ ($\tilde{C}_{1}$) on the compute target qubits. Mathematically,

This scheme also requires that

Before continuing, we make an important distinction between two protocols: the efficient PCS protocol and the general PCS protocol. For the efficient PCS protocol, we restrict $\tilde{C}_{1}$ and $\tilde{C}_{2}$ to be elements of the $n$-qubit Pauli group $\mathcal{P}_{n}$, where

These added conditions are partly due to the difficult problem of determining the optimal circuit that implements $\tilde{C}_{1}$ from a given $\tilde{C}_{2}$ and $U$. Note that $\tilde{C}_{2}$ and $\tilde{C}_{1}$ can be much more general and still satisfy Eq. (11). Thus, there are no additional constraints on the checks in the general PCS protocol.

In the general PCS protocol and for a given $U$, any unitary $\tilde{C}_{2}$ can be used because in Eq. (11) we can always pick $\tilde{C}_{2}$ and solve for $\tilde{C}_{1}$. We note in the text if a result holds for a specific case. If no statement is made, then the result holds for both scenarios.

The single-layer protocol is as follows.

1. 1.

   Initialize the ancilla to $\ket{0}$ and apply a Hadamard gate. Perform $C_{1}$ with the control on the ancilla qubit and target on the compute qubits.

2. 2.

   Perform $U$ on the compute qubits.

3. 3.

   Perform $C_{2}$ with the control on the ancilla qubit and target on the compute qubits.

4. 4.

   Apply a Hadamard gate to the ancilla. Measure the ancilla in the $\{P_{0}=\outerproduct{0}{0},P_{1}=\outerproduct{1}{1}\}$ basis, and discard the results where the outcome is $P_{1}$. We keep the result where the outcome is $P_{0}$.

We now consider the effect of this scheme on an error map $\mathcal{E}$ acting on the compute qubits after $U$, as shown in Fig. 2(a). Let $\mathcal{E}(\rho)=\sum_{i}E_{i}\rho E_{i}^{\dagger}$. Then the postselected output state of the protocol is

As shown in Fig. 2(b), this protocol transforms the error map. We can write the postselected state given in Eq. (III-B) in terms of a new error map $\mathcal{E}^{\prime}$,

where $\mathcal{E}^{\prime}$ has Kraus operators

and the factor of $1/2$ comes from multiplying Eq. (III-B) by a convenient form of one, namely, $(1/4)/(1/4)$. We can now observe the power of this error mitigation technique. The error operators $E_{i}$ can be expanded in the Pauli basis. Thus, let

where $\tilde{\sigma}_{j}$ is an element of the Pauli group and $\alpha_{ij}=\tr(E_{i}\tilde{\sigma}_{j})/(2^{n})$ is a complex constant. Let $\tilde{C}_{2}\in\mathcal{P}_{n}$. Each $\tilde{\sigma}_{j}$ term in the expansion of $E_{i}$ either commutes or anticommutes with $\tilde{C}_{2}$. Substituting Eq. (16) into Eq. (15), we see that the $\tilde{\sigma}_{j}$ elements that anticommute with $\tilde{C}_{2}$ are eliminated and

where $\mathcal{P}^{\prime}_{n}$ is the Pauli group excluding the elements that anticommute with $\tilde{C}_{2}$.

The effect of the protocol on the error map shares some similarities to that of twirling [30, 31, 32]. In twirling, the twirling set $T$ is used to conjugate the error map:

Usually, twirling is performed by using the Pauli or Clifford group as the twirling set. When twirling is performed with a suitable set, it transforms the noise into a Pauli channel. However, the PCS scheme is in some sense more powerful since it completely eliminates the contribution of anticommuting Pauli terms.

The suppression of errors from anticommuting Pauli terms in the postselected state can be enhanced by introducing multiple layers of the single-layer error mitigation technique. A graphical view of how this scheme works is given in Fig. 3. There are $m$ layers with each layer consisting of controlled operations $C_{1,k}$ and $C_{2,k}$, where the second index represents the layer, and one ancilla corresponding to each layer. Each pair of $C_{1,k}$ and $C_{2,k}$ satisfies

The multilayer scheme generalizes the single-layer scheme and is performed as follows.

1. 1.

   Initialize the ancillas to $\ket{0}$, and perform Hadamard gates on the ancillas. Perform $C_{1,k}$ with control on the $k^{\text{th}}$ ancilla qubit and target on the compute qubits.

2. 2.

   Perform $U$ on the compute qubits.

3. 3.

   Perform $C_{2,k}$ with control on the $k^{\text{th}}$ ancilla qubit and target on the compute qubits.

4. 4.

   Perform Hadamard gates on the ancillas. Measure all the ancillas in the $\{P_{0}=\outerproduct{0}{0},P_{1}=\outerproduct{1}{1}\}$ basis, and discard the results where at least one of the outcomes is $P_{1}$. We keep the result where all the outcomes are $P_{0}$.

Now let us consider a noise map $\mathcal{E}(\rho)=\sum_{i}E_{i}\rho E_{i}^{\dagger}$ acting after $U$ on a subset of qubits as shown in Fig. 4(a). From Eq. (15), in the expansion of $E_{i}$ in the Pauli basis, we know that the $k$th layer eliminates Pauli terms that anticommute with $\tilde{C}_{2,k}$. This immediately leads to the observation that we can detect all errors under the noise model shown in Fig. 4(a), which we prove in the following theorem. Theorem 1 holds in general for the general PCS protocol and it holds for the efficient PCS protocol when the checks are in the Pauli group, in other words, when $U$ is Clifford. Note that we discuss why these results hold for NCP errors as well later at the start of Section III-E.

Before proceeding, we need to clarify the implications of Theorem 1. In that theorem, if we satisfy the conditions, we will have unit fidelity in the postselected state. However, the probability of postselecting is

where the Kraus operators of $\mathcal{E}^{(m)}$ are given by Eq. (23). In Eq. (23) the checks will eliminate all the Pauli terms that are nonidentity. Thus, we see that if all the Kraus operators of the error map are traceless, in other words, contain no identity term in their expansion in the Pauli basis, all the Kraus operators for the error map in the postselected state will be the zero matrix, and the probability of postselecting is zero. This makes sense because we are not correcting errors, but mitigating errors by post selecting outcomes. The theorem holds trivially in this scenario because there is no post selected state.

Moreover, from Fig. 4(a) and Theorem 1, it seems that we can set $\mathcal{E}(\rho)=U^{\dagger}\rho U$, which eliminates $U$, and use only the checks for the implementation of the circuit. While this is certainly true, we must consider the postselection probability. If $U$ is traceless, the probability of postselecting is zero.

Next we provide a small number of $C_{2}$ checks that can reach unit fidelity in the setting of Theorem 1. The following results given in Propositions 1 and 2 are for the general PCS protocol. Propositions 1 and 2 hold for the efficient PCS protocol given that the $\tilde{C}_{1}$ checks are in the Pauli group, in other words, $U$ is Clifford. Propositions 1 and 2 hold for the noise model give in Fig. 4(a). For arbitrary weight-one Kraus errors, that is, the Kraus error operators, $E_{i}$ act only on a single qubit; there exist two layers, where $\tilde{C}_{2,1}$ and $\tilde{C}_{2,2}$ are max weight, and we reach unit fidelity in the postselected state.

The checks given in Proposition 1 can detect all errors $\mathcal{E}$ that consist of weight-one Kraus operators $E_{i}$. This class of errors contains error maps that are more general than just single-qubit error maps. For example, $E_{1}$ can act on qubit one, and $E_{2}$ can act on qubit two. $E_{1}$ and $E_{2}$ are weight-one errors, but the overall map affects multiple qubits.

We can also reach fidelity one for arbitrary weight errors for the error model given in Fig. 4(a) with a small number of weight-one $\tilde{C}_{2,k}$. These checks are generators of the Pauli group and require $2n$ layers, but the $C_{2}$ components of the checks require the same number of cnot gates as in Proposition 1. Thus, generally at the cost of more ancillas, we can detect all errors on the postselected state. Consider two weight-one $\tilde{C}_{2}$ checks of $\sigma_{1}$ and $\sigma_{3}$ on the $k$th compute qubit. All Pauli group elements that are nonidentity on the $k$th qubit anticommute with either $\sigma_{1}$ or $\sigma_{3}$. This leads to the following small set that can reach fidelity one.

Figure 5 shows an example of a random Clifford circuit consisting of two compute qubits and 30 cnot gates that gives unit fidelity for the postselected state. This matches the prediction of Theorem 1. We use a Clifford circuit to guarantee that we can get the desired checks with the efficient PCS protocol. We use the checks provided in Proposition 2. The two checks on each compute qubit are $\sigma_{1}^{(k)}$ and $\sigma_{2}^{(k)}$, and we vary the number of layers from zero to four. Interestingly, at the single-qubit error of $0.1$, the two-qubit depolarizing channel is maximally depolarizing, but the fidelity remains at one for the postselected state (as predicted).

The gain in fidelity comes at the cost of a lower probability of measuring all zeros for the ancillas. This trade-off is demonstrated in Fig. 5b. The probability of measuring all zeros $p(\overline{0})$ drops to around 7% for this circuit at the high single-qubit error of $0.1$. Note that the overhead in the number of runs is $\frac{1}{p(\overline{0})}$.

In the preceding sections, we restricted $\mathcal{E}$ to CP maps, but our results hold also for general linear Hermitian maps, which includes NCP maps. As previously mentioned, NCP maps play a major role in non-Markovian evolutions, where the maps tend to be non-CP divisible. NCP maps have a similar form to CP maps and are written as $\mathcal{E}(\rho)=\sum_{i}\eta_{i}E_{i}\rho E_{i}^{\dagger}$, where $\eta_{i}=\pm 1$ and there exists at least one $\eta_{i}=-1$. The coefficients $\eta_{i}$ are not used in any of our proofs, and thus the results hold.

Also, we restricted $\mathcal{E}$ to act only on the compute qubits. Obviously this is a restricted case, and in physical systems the checks are noisy and the error map would generally act across all the qubits, as shown in Fig. 6(a). In this situation, the checks still conjugate the error, as shown in Fig. 6(b). Consequently, the technique is effective when $\mathcal{E}$ is dominated by Kraus operators that mainly affect the compute qubits; that is, the majority of the noise is from $U$.

On non fully connected quantum computers, the parity checks may be difficult to perform with resulting minimal noise on the ancillas due to the need for swapping qubits. Thus, applications of this technique likely need to carefully map the circuit to the hardware to minimize the swaps between ancillas and compute qubits or execute the circuits on a fully connected device.

Since single-qubit gates introduce less noise than nonlocal gates, the Pauli group is a good candidate for the $\tilde{C}_{2}$ part of the checks. Furthermore, when $U$ is a deep circuit, the noise it induces will generally act across multiple qubits. In this scenario, low-weight $\tilde{C}_{2}$ will act nontrivially on these errors. Thus, in general it is better to use low-weight checks in order to avoid introducing too many errors.

Moreover, for some executions of this scheme, the postselection probability may be smaller than desired. The postselection probability can be increased by reducing the number of check layers.

While checks always exist for a given $U$, in practice it is difficult to directly compute $\tilde{C}_{1}$ from Eq. (19) for a given $\tilde{C}_{2}$. Here we introduce our searching protocol for the efficient PCS protocol for determining the check pairs quickly and without matrix multiplication. Note that this protocol can fail to find any checks or may not find the desired number of checks. This can happen when the circuit contains many non-Clifford gates. We refer to the checks searching protocol as the finding checks protocol. For our implementation, we constrained $\tilde{C}_{1}$ and $\tilde{C}_{2}$ to be in the Pauli group. We leave the potential searching protocol of a non-Pauli $\tilde{C}_{1}$ for future work.

The goal is to determine the gates comprising $\tilde{C}_{1}$ from a given $\tilde{C}_{2}\in\mathcal{P}_{n}$ and a given $U$. Instead of performing matrix multiplication, we transpile the input circuit to an equivalent circuit that uses the gate set $\{\textsc{x},\textsc{y},\textsc{Rz},\textsc{s},\textsc{h},\textsc{cnot}\}$ and perform lookups of the commutation relations. This method applies to circuits consisting of Clifford $+$ arbitrary diagonal gates, which is a universal gate set since diagonal gates contain the gate $T$.

To determine the checks, we use the equality $U_{1}U_{2}=U_{2}(U_{2}^{\dagger}U_{1}U_{2})=U_{2}U^{\prime}_{1}$, where $U^{\prime}_{1}=U_{2}^{\dagger}U_{1}U_{2}$ and $U_{1}$ and $U_{2}$ are unitary. We refer to this technique as “pushing" $U_{1}$ through $U_{2}$. Figure 7 gives a visual example of the pushing of the $\tilde{C}_{2}$ gates to determine $\tilde{C}_{1}$. Figure 8 is the completed error-mitigated circuit. This process is efficient since the cost of each lookup call is constant $O(1)$.

Algorithm 1 is the pseudocode for the main script for finding a desired number of Pauli check pairs. It iterates through the minimum weight Pauli checks first and terminates when a sufficient number of layers of checks have been found. The protocol focuses on using low weight checks to minimize the noise introduced by the checks as discussed previously in Section III-E. The main script calls on Alg. 3 to see whether it is possible to push the current gate through. In Alg. 2 the lookup call is a preset table that has commutation relations. This symbolic “pushing" of Pauli gates through $U$ works for all gates in the basis set except for Rz. For Rz, if the gate being pushed is not in $\{\textsc{z},\textsc{i}\}$, which are operators that commute with an arbitrary diagonal gate, then we skip that Pauli group element.

Note that mathematically, any $\tilde{C}_{2}\in\mathcal{P}_{n}$ can be used because $\tilde{C}_{1}$ can be determined from Eq. (11). Thus, one should be able to expand the current algorithm to allow for finding of general $\tilde{C}_{1}$. This problem is nontrivial.

The analytical results presented above assume perfect checks. Here we numerically investigate the scheme in a more realistic setting where most gates are noisy, including those involved in the parity checks (the only gates that are not noisy are measurements and the circuit that generates the random input state).

Intuitively, given a Clifford circuit and using the efficient PCS protocol, we should be able to perform long computations with high fidelity. For a given Clifford circuit, we can keep the $C_{2}$ checks constant and independent of the depth of $U$. Thus, the noise induced by our $C_{2}$ checks should be relatively constant.

The $C_{1}$ checks depend on $U$, but they are elements of the Pauli group and hence limited in size and complexity. Therefore, the noise induced by the $C_{1}$ checks should also be limited and independent of the depth of $U$.

We demonstrate this intuition on simulations consisting of 550 randomly generated Clifford circuits with two compute qubits. Note that these Clifford simulations provide only intuition that the protocol is suitable for deep circuits because Clifford circuits can in general be optimized to use $O(n^{2}/log(n))$ cnot gates, where $n$ is the number of qubits [34]. Thus, two-qubit Clifford circuits can be optimized to be shallow. It may be possible to prove this performance on Clifford circuits with higher qubit counts.

We considered random circuits with cnot counts that varied from $1,2,4,\cdots,1,024$. For each cnot count we generated $50$ random circuits, and we used single-qubit depolarizing noise of 0.00126 (0.0126 two-qubit noise). This lies within the range of current noise levels found in state of the art quantum computers [35, 29]. We used four layers of checks; the form of the checks was provided in Proposition 2. As shown in Fig. 9a, we maintained an average fidelity $F_{m}$ for the postselected state of greater than 90% for circuits consisting of up to 1,024 cnot gates. The average fidelity of the unmitigated circuits drops to 25% at 256 cnots. Note that this comes at the cost of a lower postselection rate of 6.25% as shown in Fig. 9b.

For optimized Clifford circuits, we would likely not want to use all the checks from Proposition 2 because we would probably exceed the cnot count of the input circuit. Still, as shown in Fig. 9a, fewer layers can produce significant fidelity improvement.

These simulations establish the general trend that fidelity is positively correlated with the number of layers up to some value. We suspect that these results also hold for general (non-Clifford) circuits.

We also randomly generated 1,850 input circuits consisting of Clifford + arbitrary diagonal unitary gates. Of these, 1,350 input circuits consist of five qubits with cnot counts of $\{1,5,\cdots,40\}$; 500 input circuits consist of ten qubits with cnot counts of $\{1,5,\cdots,40,80\}$. We varied the single-qubit error from $10^{-5}$ to $10^{-2}$ with 21 equally spaced points in log scale.

For the ten-qubit circuits we also generated circuits with cnot gate counts of 80 to match the max cnot count to qubit ratio of the five qubit case. Each random circuit was generated first as a random Clifford gate, which we truncated to reach the desired cnot count. Next, we inserted Rz gates with random rotation angles and random locations in the circuit. We used Rz gate counts of {5, 10, 15}. Each Rz value for five qubits consists of 450 circuits. This covers a large class of variational quantum eigensolver and quantum approximate optimization algorithm circuits [36].

We achieved an average peak fidelity gain $F_{m}-F_{n}$ of $34$ percentage points for five-qubit circuits with a cnot gate count of 40, five Rz gates, and six layers of checks, as shown in Fig. 10a. For input circuits with a low cnot count, the fidelity gain is negative because the checks introduce more errors than they eliminate in the post selected state. The average postselection probability is given in Fig. 10b.

We also give in Fig. 11a a plot that breaks down this peak fidelity gain. At the peak fidelity gain, the nonmitigated circuit has about 33% fidelity, and the six-layer mitigated circuit has about 67% fidelity.

As shown in Fig. 11a, the mitigated circuits perform significantly and consistently better than the unmitigated circuits. Even for lower-layer counts such as two, the average fidelity gain reached 20 percentage points. Fig. 11b gives the corresponding post selection probabilities and demonstrates that we have significant control over the probabilities by changing the number of layers.

Each additional layer increased the average fidelity provided enough circuit depth. We show this in more detail in Fig. 12a, where we fixed the single-qubit error rate to 0.00251 (0.0251 two-qubit error) the value that gave the peak fidelity gain in Fig. 10a.

Circuits with more than six layers may result in even better performance, but the amount of fidelity gained decreases with subsequent layers. Fig. 12b shows the corresponding post selection probabilities and the minimum post selection probability is about 16%.

As the number of Rz (non-Clifford) gates increases, the number of possible low weight $\tilde{C}_{2}$ checks for the efficient PCS protocol decreases, and consequently the fidelity gain decreases. As shown in Fig. 13a, at an Rz gate count of 10, the peak fidelity gain is about 25%.

As shown in Fig. 14a, at an Rz gate count of 15, we cannot find six layers of checks for random circuits with 20 cnot gates or higher. Interestingly, as shown in Figs. 10b, 13b and 14b, the post selection curves are relatively unchanged.

Using one layer of checks, we have a peak fidelity gain of about 10 percentage points at 40 cnot gates, as shown in Fig. 15a. Fig. 15b shows the corresponding post selection probabilities.

For the ten-qubit case, as shown in Fig. 16a, we achieved a fidelity gain of about ten percentage points. This occurred at a cnot count to qubit ratio of eight, which matches the scenario of the peak fidelity gain in the five-qubit case. The peak fidelity gain occurred at a single-qubit error of about 0.000891 (0.00891 two-qubit error). Fig. 16b shows the corresponding post selection probabilities.

The preceding simulations focus on using low-weight checks first. We now analyze the performance of high-weight checks. As shown in Figs. 17(a) and 17(b), while the high-weight checks do give a boost in fidelity, they introduce significant amounts of noise compared to the low-weight checks.