Check the symmetries the answer must have

What it fills

• Recover a noiseless expectation value by post-processing

  Estimate what an observable would have measured on a noiseless device by running modified or repeated circuits on the noisy one and combining the results classically. No qubits are spent on redundancy; the whole price is paid in shots.

When it applies

Bonet-Monroig et al. give two mechanisms and one honest boundary. The mechanisms: "two protocols to measure conserved symmetries during the bulk of an experiment", and "a zero-cost post-processing protocol which is equivalent to a variant of the quantum subspace expansion" — the same construction this map draws under `subspace-expansion-excited-state`, arrived at from the error side rather than the spectrum side. They also "develop methods for inserting global and local symmetries into quantum algorithms, and for adjusting natural symmetries of the problem to boost their mitigation against different error channels", so which symmetry is checked is a design choice tuned to the noise, not a fixed recipe. The boundary is the scale of the evidence: the demonstration is "two- and four-qubit simulations of the hydrogen molecule (using a classical density-matrix simulator)", where they find "up to an order of magnitude reduction of the error in obtaining the ground state dissociation curve". *Up to*, on a density-matrix simulator, at two and four qubits — no device run and no larger system is claimed here.

Requires

Every step this method names moves its route along, so there is nothing it needs alongside them.

Example

given  a noisy state rho produced by the circuit (a density matrix -- the
       argument does not require rho to be pure)
       a Pauli symmetry S in P_N with [H, S] = 0, and a target sector
       eigenvalue s = +-1 fixed by the problem (e.g. the parity of the
       Hartree-Fock reference)                                        (Sec. III)
       N_S = number of qubits on which S acts nontrivially, writing
       S = tensor_i S_i with each nontrivial S_i in {X, Y, Z}          (Sec. IV)

requires  a projective measurement whose projectors include one onto the
    target eigenspace. Taking S to be a PAULI operator is what makes this
    cheap -- each nontrivial factor rotates into the computational basis
    by a single-qubit gate. The paper does NOT require it: if S is not
    Pauli but the target eigenspace lies inside the eigenspace of some
    Pauli P, measure P instead (weaker mitigation when that eigenspace is
    strictly larger), and phase estimation constructs the measurement for
    a general unitary symmetry at much higher cost. What is genuinely
    excluded is an ANTIUNITARY symmetry, or one that ANTICOMMUTES with H:
    those yield no eigenspace to project into                          (Sec. III)
  for the post-processing branch (B): the observable P being estimated
    commutes with S, [P, S] = 0 -- otherwise Eq. 13's cross term is not
    defined                                                            (Sec. VI)
  to verify more than one symmetry together: [S_i, S_j] = 0 pairwise for
    all of them, else sequential verification projects between different
    eigenspaces and discards far more shots                            (Sec. III)

M_s = (1/2) * (I + s*S)          # projector onto the target sector
                                 #   (general Pauli form M_p = 1/2(1+pP)
                                 #   in Sec. II; this s,S instance Sec. VI)

# ===========================================================================
# Branch A -- circuit verification: measure a symmetry, then post-select
# ===========================================================================

pick ONE construction of a projective measurement equivalent to M_s:

  ANCILLA (Fig. 1), using one extra ancilla qubit:
      for each nontrivial factor S_i of S:
          rotate qubit i by R_i     # R_i in {exp(i*pi/2*Y), exp(-i*pi/2*X), I}
                                     #   -- chosen per Sec. IV so that
                                     #   R_i |S_i = 1> = |0>, i.e. it sends the
                                     #   S_i eigenbasis to the Z eigenbasis
          CNOT( qubit i -> ancilla )
          rotate qubit i by R_i^-1  # undo the basis change
      measure the ancilla in the computational basis
      # depth O(N_S); needs the ancilla coupled to every measured qubit, or
      #   O(N_S) SWAPs walking it along a line (Fig. 1b) if it is not     (Sec. IV)
      # per-qubit duty cycle in the Fig. 1b variant is O(1), so those qubits
      #   stay free for other work while verification runs               (Sec. IV)

  IN-LINE (Fig. 2), no ancilla -- encrypt S onto one system qubit's own
      computational degree of freedom, then read that qubit out:
          rotate each nontrivial qubit i by R_i    # SAME basis change as the
                                                    #   ancilla circuit; Fig. 2
                                                    #   brackets both panels with
                                                    #   R_i ... R_i^-1, and
                                                    #   without it a nontrivial
                                                    #   X or Y factor of S is
                                                    #   never measured
          run a binary tree of CNOTs among the N_S nontrivial qubits,
              accumulating the parity onto the readout qubit
          measure that qubit in the computational basis
          uncompute the CNOT tree                  # Fig. 2a mirrors the tree
                                                    #   after the meter
          rotate each nontrivial qubit i by R_i^-1
      # depth O(log N_S) -- but ONLY under binary-tree (all-to-all) coupling;
      #   under d-dimensional local coupling the depth is at least
      #   O(N_S^(1/d)), and O(N_S) is optimal on a line (Fig. 2b)        (Sec. IV)
      # even WITH all-to-all coupling the O(log N_S) circuit may not be
      #   preferable: every qubit's duty cycle is O(log N_S), against O(1)
      #   for the ancilla circuit of Fig. 1b                             (Sec. IV)

if this is BULK verification:
    insert the chosen measurement between gates, at every point where the
        noiseless state is expected to be an eigenstate of S             (Sec. III)
    # only a circuit measurement can be inserted mid-circuit like this;
    #   Branch B cannot, because post-selection needs the trace of a state
    #   that no longer exists once the circuit continues                 (Sec. VI)
else:
    perform the measurement once, at the end of the experiment  # "final" verification

read outcome m
if m does not correspond to sector s:
    discard this shot                                                    (Sec. III)
else:
    keep it -- the retained state is rho_s = M_s*rho*M_s / Trace[M_s*rho] (Eq. 6)
    # overlap with the true target state can only improve:
    #   Trace[rho_s |target><target|] >= Trace[rho |target><target|],
    #   strict unless M_s*rho*M_s = rho already                          (Eq. 7)

accumulate kept shots to estimate Trace[P*rho_s] for each Pauli term P of H
# repeated verification compounds rejection: total run-time grows
#   exponentially in the number of verifications inserted, and the paper
#   gives no closed-form rejection rate or variance to bound it against  (Sec. X)

# ===========================================================================
# Branch B -- S-QSE: zero extra circuitry, FINAL verification only
# ===========================================================================

on the SAME unverified state rho -- no post-selection, no ancilla, no
discarded shots:
    measure Trace[P*rho]        for every Pauli term P of H
    measure Trace[S*rho]        # one extra expectation value overall
    measure Trace[P*S*rho]      # P*S is again a Pauli operator, so this
                                 #   costs one more term per P, not a new
                                 #   measurement class                    (Eq. 13, deriv.)

    Trace[P*rho_s] = ( Trace[P*rho] + s*Trace[P*S*rho] )
                      / ( 1 + s*Trace[S*rho] )                           (Eq. 13)
        # derived by expanding M_s inside the trace and using [P, M_s] = 0
        # undefined when s*Trace[S*rho] = -1 -- the denominator vanishes

    sum the mitigated Trace[P*rho_s] over the Hamiltonian's Pauli
        decomposition to get the S-QSE energy estimate
    # shown equal to the generalized quantum subspace expansion built on
    #   the excitation set {I, S} -- the same eigenvalue problem as QSE,
    #   reached without the outer excitation manifold                    (Sec. VI)

return  a mitigated expectation-value estimate Trace[P*rho_s]
        # Branch A: accumulated from surviving (kept) shots
        # Branch B: computed by post-processing statistics of the
        #   unverified state -- no circuit was added at all

# what this method does NOT catch, in either branch: a noise channel that
#   commutes with S moves the state WITHIN the target sector, and
#   symmetry verification "explicitly does not mitigate" that error      (Sec. V)
# nor does either branch guarantee a lower energy estimate on any single
#   run -- only that the rejected component tends to carry the excess
#   energy; the paper shows this can fail in principle              (Sec. V, Eq. 11-12)
# particle number, though also conserved at low energy in non-super-
#   conducting systems, is not a Pauli operator and is "much more
#   difficult to measure" -- out of scope for this construction          (Sec. V)

Cost, as the source states it

Bonet-Monroig, Sagastizabal, Singh and O'Brien price two circuit protocols against $N_S$, the number of non-trivial tensor factors of a Pauli symmetry $\hat{S} \in P_N$. Ancilla verification: one ancilla qubit plus, per non-trivial factor, a rotation $\hat{R}_i$, a CNOT and $\hat{R}_i^{-1}$ — $\hat{R}_i$ is trivial for a $Z$ factor — at depth $O(N_S)$, requiring all-to-all ancilla coupling or $O(N_S)$ SWAP gates on a line. In-line verification drops the ancilla at depth $O(\log(N_S))$, but only under binary-tree connectivity; under $d$-dimensional local coupling it is at least $O(N_S^{1/d})$, and $O(N_S)$ is optimal on a line. S-QSE, the third protocol, adds no circuit: for $[\hat{P}, \hat{S}] = 0$, Eq. 13 rebuilds $\mathrm{Tr}[\hat{P}\rho_s]$ from three expectation values on the unverified state — at most one extra Pauli expectation per Hamiltonian term, zero for their two-qubit $\mathrm{H}_2$ — but cannot verify mid-circuit. Particle number is not a Pauli operator and is \"much more difficult to measure\". Nothing bounds the repetitions: no numerical rejection rate or variance formula, only the acceptance weight $\mathrm{Tr}[\hat{M}_s\rho]$ (Eq. 6) and a run-time that \"increases exponentially in the number of verifications\" added to a circuit.

Implementations

• Three symmetry-verification protocols compared on a simulated H2 VQE

  • Low-cost error mitigation by symmetry verification

  The demonstration inside the method's own paper, built by Bonet-Monroig, Sagastizabal, Singh and O'Brien to put their three protocols — ancilla, in-line and post-selected S-QSE — on one problem and rank them by the error they remove. The problem is chosen for comparability rather than difficulty: “To first investigate symmetry verification in a simple setting, we use a VQE to find the ground-state energy of H2 on two qubits. This follows previous experimental demonstrations”. It is a classical simulation throughout; no device is involved.

  On two qubits the Hamiltonian is Eq. 25, $\hat{H} = h_0 II + h_1 IZ + h_2 ZI + h_3 XX + h_4 YY + h_5 ZZ$, which commutes with $\hat{S} = ZZ$; the Hartree-Fock state sits in the $ZZ = -1$ sector, and that is the target subspace. The ansatz is the unitary coupled cluster form $\hat{U}(\theta) = e^{-i\theta X_0 Y_1}$ applied to $|01\rangle$. All three protocols are run as a FINAL verification step: ancilla verification exactly as Fig. 1(a); in-line verification as Fig. 2(a) but without undoing the symmetry measurement, propagating $\hat{P}$ through the verification circuit instead; and S-QSE as the Eq. 13 post-processing, which here costs nothing at all — “S-QSE not only requires no additional circuitry, but also no additional measurements (all required terms are in the Pauli decomposition of the Hamiltonian)”. Sec. IX then extends the same study to four qubits under the Jordan-Wigner transformation, where the Hamiltonian “has symmetries $\hat{S}_0 = Z_0 Z_1$, $\hat{S}_1 = Z_0 Z_2$, and $\hat{S}_2 = Z_0 Z_1 Z_2 Z_3$”, the ansatz is $\hat{U}(\theta) = e^{i\theta Y_0 X_1 X_2 X_3}$ on the Hartree-Fock state $|1100\rangle$ “for a total circuit time of 400 ns”. That set is not enough by itself — “The above set of symmetries still commute with all single-qubit Z errors” — so Eq. 34 rotates the problem by $\hat{R} = e^{i\frac{\pi}{2} Y_0 X_2} e^{i\frac{\pi}{2} Y_1 X_3}$, which “transforms the symmetry $\hat{S}_0 \to X_0 X_1 X_2 X_3$, whilst leaving $\hat{S}_1$ and $\hat{S}_2$ unchanged”. What that buys is a property of the SET and not of any one member: “The resulting set of symmetries do not commute with any single-qubit X or Z operator, as required” — the rotated $\hat{S}_0$ anticommutes with every single-qubit $Z$, and $\hat{S}_2 = Z_0 Z_1 Z_2 Z_3$ with every single-qubit $X$, so between them every single-qubit $X$ or $Z$ error is detectable. The rotation carries the ansatz with it, $\hat{U}(\theta) \to \hat{R}\hat{U}\hat{R}^{\dagger} = e^{i\theta Y_0 Z_1 X_2}$, “resulting in a total circuit time of 440 ns”.

  One molecule, one basis, integrals from named packages: “We take the STO-3G basis for H2, which has four spin-orbitals, and convert this into a qubit Hamiltonian via the Bravyi-Kitaev transformation”, in which two qubits carry a diagonal Hamiltonian and are removed. “The calculation of these terms, and the Bravyi-Kitaev transformation itself, were performed using the psi4 and OpenFermion packages.” The noise parameters are not measured here either: the authors “take gate error models and parameters similar to previous simulation work based on experimental data of state-of-the-art superconducting transmon qubits”, citing O'Brien, Tarasinski and DiCarlo, npj Quant. Inf. 3, 39 (2017).

  The instrument is quantumsim, cited by the paper with an address: “The quantumsim density matrix simulator can be found at https://github.com/quantumsim/.” That GitHub organisation holds a Python, GPL-3.0 repository at https://github.com/quantumsim/quantumsim, labelled there as a mirror; the project itself is at https://gitlab.com/quantumsim/quantumsim, whose page describes it as “A GPU-accellerated full density matrix simulator of quantum circuits”.

  Everything below is quantumsim, a classical density-matrix simulator, under a stated error model — “decoherence times, which we take at a base level to be $T_1 = T_2 = 20\,\mu s$”, single- and two-qubit gate times of 20 ns (220 ns total circuit without verification), “additional dephasing noise of 0.01% and 1% respectively”, and a 1% read-out error on the single-shot verification measurement. On two qubits, “the un-mitigated VQE (blue points) achieves an error in the energy of approximately 0.01 − 0.04 hartree across the bond dissociation curve”, and against that baseline “The S-QSE circuit is observed to give approximately a five-fold improvement over the unmitigated circuit, while ancilla (orange crosses) and in-line (green squares) symmetry verification show an approximately two-fold and three-fold improvement respectively” (Fig. 3). Sweeping decoherence at 0.75 Å with all other error sources off, the S-QSE estimate is less susceptible to $T_1$ than to $T_\phi$ noise “up to a factor of two over the range of decoherence times plotted” (Fig. 4). On four qubits, “Over the entire bond-dissociation curve, the rotated four-qubit S-QSE simulation outperforms its unmitigated counterpart by over an order of magnitude”, and “At the largest distance studied, this simulation achieves a two-fold reduction in error compared to the two-qubit S-QSE simulation, despite using twice as many qubits and a twice as long circuit.” That gain belongs to a regime. At small bond distance ($\lesssim 0.75$ Å) the target ground state “is roughly a computational basis state, which is immune to dephasing errors” and “all three verification protocols perform roughly similarly” — the three being the two-qubit and the two four-qubit S-QSE runs compared in Fig. 5. It is at large bond distance ($\gtrsim 0.75$ Å), where “the ground state is prone to T2 noise”, that they separate, and there the UNROTATED four-qubit S-QSE “cannot protect against the T2 noise accumulated over the simulation, and performs a factor of two worse than the two-qubit S-QSE simulation”. The authors' own reading is not that four qubits are worse but that the protocol has to be matched to the noise: this “clearly demonstrates the need to optimize symmetry verification protocols to account for errors present in the system as this technique is scaled up to larger computations”.

• Symmetry-verified H2 VQE on two transmon qubits in a circuit QED processor

  • Error Mitigation by Symmetry Verification on a Variational Quantum Eigensolver

  The device run the method's own paper does not contain, by all four authors of that paper together with ten collaborators at QuTech and Delft University of Technology, Leiden's Instituut-Lorentz and TNO, citing Bonet-Monroig et al. as its Ref. 19. The stated claim is narrow and quantitative: “In this Rapid Communication, we experimentally demonstrate the use of SV to reduce the error of a VQE estimating the ground-state energy and the ground state of the H2 molecule by one order of magnitude on average across the bond-dissociation curve.”

  “We now experimentally investigate the benefits of SV in the VQE of H2 using two of three transmon qubits in a circuit QED quantum processor”, the two qubits coupled by a common bus resonator with dedicated microwave drive, flux-bias and readout lines. The ansatz is hardware-native and symmetry-respecting: a $\pi$ pulse excites $Q_1$ to $|10\rangle$, then $Q_0$ is flux-pulsed into resonance with $Q_1$ so that population exchanges within the single-excitation subspace, realising the exchange gate $U_\theta$ of Eq. 7. Because 1 ns pulse-duration resolution is too coarse, amplitude and duration are stitched into a hybrid path: “This results in a fine experimental knob $\tilde{\theta}$ (1500 possible settings) that controls population exchange like $\theta$ in Eq. (7)”. The state is read by tomography — 36 pre-rotation pairs across three measurement channels ($Q_1$, $Q_0$ and their correlation), 108 linear equations, least-squares linear inversion. Optimisation uses “the covariance matrix adaptation evolution strategy (CMA-ES) optimization algorithm, using $E^{(raw)}$ as cost function and $\tilde{\theta}$ as single variational parameter”, $N_{pop} = 10$ and $N_{meas} = 10^3$ per sample; “A typical optimization [Fig. 2(a) inset] converges after $\sim 20$ generations ($\sim 2$ hours)”, and the converged state is re-reconstructed at $N_{meas} = 10^5$. Symmetry verification is then applied in post-processing via Eq. 6, costing no extra measurements here because $ZZ$ maps the non-zero Pauli terms of $\hat{H}_{H_2}$ to other non-zero terms. A matching density-matrix simulation is built incrementally — optimiser inaccuracy, then $T_2^*$, then $T_1$, then residual excitation, then the extra dephasing of $Q_0$ during the exchange gate — to budget the error.

  The molecule and its integrals: H2 “in the STO-3G basis” mapped “onto four qubits via the Bravyi-Kitaev transformation and then further reducing dimensions by projecting out two non-interacting qubits”, giving the two-qubit $\hat{H}_{H_2}$ of Eq. 3, whose coefficients “may be determined classically using the OpenFermion and psi4 packages”. The other inputs are the device's own measured parameters, Table S1: $T_1 = 9.8 \pm 1.0\,\mu s$ ($Q_1$) and $11.7 \pm 0.6\,\mu s$ ($Q_0$); $T_2^* = 9.0 \pm 1.3\,\mu s$ and $17.3 \pm 1.0\,\mu s$; residual qubit excitation $1.34 \pm 0.20\%$ and $0.25 \pm 0.09\%$; single-qubit gate fidelity 98.6% and 99.1% by randomized benchmarking; qubit-qubit coupling $J_1/2\pi = 20.9$ MHz. These are outputs of the device rather than inputs to it — “We ran a series of characterization experiments to extract the device parameters needed as inputs to the error model used in our density-matrix simulaiton” (the misspelling is the paper's) — and what they feed is the matching simulation.

  No new code is claimed for this paper; the packages named are released ones, PycQED among them from the authors' own group — its Ref. 45 lists Rol, Bultink and Sagastizabal, all authors here. “All measurements were controlled at the software level with qCoDeS and PycQED packages. The QuTech OpenQL compiler translated high-level Python code into the eQASM code forming the input to the CCL.” PycQED's Python 3 implementation is public — MIT-licensed Python at https://github.com/DiCarloLab-Delft/PycQED_py3, described there as “Python3 version of PycQED using QCoDeS as backend”. The matching simulation is the same quantumsim used by the method's own paper (Ref. 37 here).

  Measured on two of the three transmon qubits of a circuit QED processor, over twelve values of the interatomic distance $R$ — “Figure 2 shows the resulting energy estimate for twelve values of $R$”, with reconstructed density matrices shown at $R = 0.25$ Å, $0.80$ Å and $2.00$ Å — “SV reduces the energy error by an average factor $\sim 10$ and reduces the infidelity by an average factor $\sim 9$.” The quantumsim error budget locates the gain: “Without SV, $\Delta E$ is clearly dominated by residual qubit excitation”, and “Using SV changes the dominant error mechanism from residual qubit excitation to optimization inaccuracy.” A second, sharper result concerns what symmetry verification does to a tomographically reconstructed state: binning the data into 100 samples per $R$ at $N_{meas} = 10^3$, “Without enforcing physicality, SV makes no significant improvement to the state fidelity, although it almost always improves the energy error. However, when positivity is enforced, SV greatly improves the overlap with the true ground state.” The positivity constraint is applied to the fermionic 2-reduced density matrix by convex optimisation.

• Stabiliser-VQE parity checking simulated in QuEST

  • Error-mitigated digital quantum simulation

  An independent construction from the University of Oxford that appeared on the arXiv twenty days before the method's own paper — v1 on 6 July 2018 against 26 July 2018 — and that Bonet-Monroig et al. name in their closing paragraph: “While this paper was in production, a related work by McArdle et al. appeared on the ArXiv. They simulate the performance of ancilla symmetry verification for a VQE, and its combination with other error mitigation strategies to further improve robustness against noise.” They set it beside their own work rather than inside it: “Their results are consistent with and complementary to our own, and they provide useful techniques for measuring non-Pauli operators not considered in this work.” That last clause is the seam between the two — the electron-number check described below reads a quantity this method's own cost record already flags as not a Pauli operator. McArdle, Yuan and Benjamin state the target as detection rather than correction: “we propose a stabiliser-like method which enables the detection of up to 60 – 80 % of depolarising errors”. That range is derived under four assumptions the paper lists — “1. The errors are symmetric and depolarising. 2. The error rate is low, such that only one gate malfunctions in the circuit. 3. The ansatz circuit is built from individual gates which conserve particle number and spin. 4. Single qubit gate error rates are negligible compared to two qubit gate error rates.” — and its upper end is reached only in the limit $M \to \infty$, $M \gg N$, which the paper itself calls “clearly unattainable in practice”. Like the method's own paper, it is a simulation study. Everything quoted here is from v5 (28 May 2019): the title and the 60 – 80 % figure first appear in v3 (23 August 2018), and v1 and v2 are titled “Error mitigated quantum computational chemistry” with a 66 % figure in the abstract.

  An ancilla reads out the conserved electron number bit by bit: the circuit of Fig. 3 measures the $m$th bit $N_m$, with $R_m = \mathrm{diag}(1, e^{\pi i/2^{m-1}})$ and a correction gate $\omega_m$ built from the $m-1$ bits already measured, the ancilla being measured in the $X$ basis; spin numbers are measured the same way. For the H2 test they use the cheaper, weaker variant: “we performed error-prone checks of both the spin-up and spin-down parity numbers, using the circuit shown in the Supplementary Materials. This circuit has nearest-neighbour connectivity, and so lower bounds the efficacy of our method.” The check gates are themselves noisy. The classical loop is deliberately absent — “We did not consider the parameter update step of the VQE, so as to examine the effect of errors without consideration of a classical optimisation algorithm” — and four conditions are compared: no check / check, each with and without zero-noise extrapolation. Measurements are distributed over Hamiltonian terms “proportional to [their] strength”.

  “We tested our method's efficacy in a VQE calculation on the simplest model of H2, with two electrons in four spin-orbitals. We used a spin-conserving UCC ansatz applied to the Hartree-Fock state.” No basis set is named anywhere in the paper; the system is described only as the hydrogen molecule “in a minimal basis”, from which “we construct four molecular orbitals”. The four-qubit Jordan-Wigner Hamiltonian is Eq. 29 and its coefficients come from a named package: “We obtained the numerical values of $h_i$ using OpenFermion.” The circuit sizes are stated: “There were 92 single qubit gates and 56 two qubit gates in the UCC ansatz circuit – which we can approximate as 65 two qubit gates. The parity checks contributed an additional 8 error-prone two qubit gates.” Two noise settings are used: a symmetric depolarising model with “the two qubit gate error rate to be 10 times larger than the single qubit gate error rate”, swept over “two qubit gate error rates ranging from 0.1 % to 2 %”; and, for the dissociation curve, a 0.1% two-qubit depolarising rate “combined with temporally correlated over/under rotations of up to 1 %”.

  Released, and named in the paper: “Numerical simulations were performed using QuEST, and simulation code can be found at Ref. 47.” That reference is the author's GitHub account, https://github.com/sammcardle30, which holds the repository Error-mitigated-digital-quantum-simulation — C, MIT-licensed, described there as “Simulation code generated in preparation of the work 'Error mitigated digital quantum simulation'.” QuEST itself is the simulator of Jones, Brown, Bush and Benjamin (arXiv:1802.08032).

  All numbers are from QuEST, a classical simulator, with no device run, and all of them are quoted from v5 (28 May 2019) — the 2018 versions of this paper report different figures. Sweeping the two-qubit gate error rate from 0.1 % to 2 % against a true energy of “−1.1227 Hartree” (Fig. 4), the measured detection rate falls short of the abstract's upper bound: “When the error rate is small we detect around 53 % of errors”, against the “roughly 59 %” expected if only errors inside the ansatz circuit were detectable — a deviation the authors attribute to “the use of a UCC ansatz, which enables errors to propagate”. At higher error rates multiple errors occur per circuit, “which reduces the fraction of errors that we can detect to close to one third”, and detection alone is weaker than extrapolation alone. On the dissociation curve at 0.1 % two-qubit depolarising noise plus temporally correlated over/under rotations of up to 1 %: “our method can obtain chemically accurate energies, even when the results would otherwise be corrupted by noise. The combined mitigation method achieves quantitatively accurate results, with a mean absolute residual of 0.2 mHartree.” Against the unmitigated run, “the deviation from the true value is reduced by a median factor of 239 (with a range of 141 to 818, and a mean of 340)”; against extrapolation alone, “by a median factor of 9.1 (with a range of 6.6 to 35.6, and a mean of 15.0)”. Those two factors are v5's: v4 (19 November 2018), the last version dated 2018, gives 106 (range 71 to 869, mean 246) and 4.5 (range 0.8 to 38.6, mean 10.6) for the same two comparisons.

What it needs

Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.

Other ways to fill the same slot

Different approaches

• Zero-noise extrapolation (ZNE)

  Deliberately amplify the device noise by a set of known factors, measure the observable at each, and extrapolate the resulting curve back to zero noise. The fit is Richardson's deferred approach to the limit, or another model.

• Probabilistic error cancellation (PEC)

  Write the inverse of the characterized noise channel as a quasi-probability distribution over implementable operations, sample circuits from it, and combine the results with signed weights. Unlike extrapolation it inverts the noise rather than fitting through it, so it is unbiased in principle.

• Readout (measurement) error mitigation

  Correct the classical readout channel by deconvolving the assignment matrix that maps true bitstrings to observed ones. The naive form calibrates and inverts the full $2^n x 2^n$ matrix; the scalable form never forms it.

In the Atlas

• Symmetry-verified VQE

  Samples outside conserved symmetry sectors are rejected or reweighted as an error-mitigation step.

Sources

• Low-cost error mitigation by symmetry verification↗X. Bonet-Monroig, R. Sagastizabal, M. Singh, T.E. O'Brien · 2018theory yes · simulation yes · hardware no