Unexpected outputs with ZNE

[hametar0u]

Hi,

I'm running into unexpected behavior when using ZNE with my circuit. Here is my code:

import pennylane as qml
from pennylane import numpy as np
from qiskit.providers.fake_provider import *
from pennylane.transforms import mitigate_with_zne, richardson_extrapolate, fold_global

# the noisy simulator I'm using simulates the IBM Manila QC
def configured_backend():
    return FakeManila()

def ansatz(params, wires):
    qml.RY(params[0], wires=wires)

# controlled application of unitary matrix A. In this specific example I'm setting A to be the identity
def CA():
    # qml.CZ(wires=(1, 0))
    pass

def U_b():
    qml.Hadamard(wires=0)

# define devices
dev_noisy = qml.device("qiskit.remote", wires = 2, backend=configured_backend())
dev = qml.device("default.qubit", wires = 2)

# the main circuit (hadamard test)
def circuit(params, part=None, j=-1):
    # hadamard on the ancilla
    qml.Hadamard(wires=1)

    if part == "Im": # in this example we don't need this
        qml.PhaseShift(-np.pi/2, wires=1)

    ansatz(params, wires=0)
    # CA()
    U_b() # H

    if j != -1: # j = 0, (when we call it below), so this should induce a π phase on the |11> component
        qml.CZ(wires=[1, j])

    U_b() # H
    # CA()

    qml.Hadamard(wires=1)

    return qml.probs()

    # return qml.expval(qml.PauliZ(wires=1))

circuit_noiseless = qml.QNode(circuit, dev)
circuit_noisy = qml.QNode(circuit, dev_noisy)
circuit_mitiq = mitigate_with_zne(circuit_noisy, [1, 2, 3], fold_global, richardson_extrapolate)

# print the values of the circuits for comparison
for i in range(5):
    print(f"it {i}")
    print("noiseless probs: ", circuit_noiseless([np.pi/2], part="Re", j=0))
    print("noisy probs: ", circuit_noisy([np.pi/2], part="Re", j=0))
    print("mitiq probs: ", circuit_mitiq([np.pi/2], part="Re", j=0))

Here is the output when I ran it:

it 0
noiseless probs:  [5.00000000e-01 3.08148791e-33 5.00000000e-01 3.08148791e-33]
noisy probs:  [0.58398438 0.00878906 0.40234375 0.00488281]
mitiq probs:  (0.23144531249993736, 0.444335937500095, 0.05566406249994298, 0.2685546875000598)
it 1
noiseless probs:  [5.00000000e-01 3.08148791e-33 5.00000000e-01 3.08148791e-33]
noisy probs:  [0.56152344 0.00292969 0.4296875  0.00585938]
mitiq probs:  (0.2041015624999355, 0.38183593750008543, 0.15429687499995637, 0.25976562500005757)
it 2
noiseless probs:  [5.00000000e-01 3.08148791e-33 5.00000000e-01 3.08148791e-33]
noisy probs:  [0.54003906 0.01269531 0.44042969 0.00683594]
mitiq probs:  (0.04980468749991402, 0.45996093750009653, 0.21191406249996458, 0.2783203125000598)
it 3
noiseless probs:  [5.00000000e-01 3.08148791e-33 5.00000000e-01 3.08148791e-33]
noisy probs:  [0.55859375 0.00976562 0.421875   0.00976562]
mitiq probs:  (0.10253906249992563, 0.4511718750000964, 0.18945312499995606, 0.2568359375000568)
it 4
noiseless probs:  [5.00000000e-01 3.08148791e-33 5.00000000e-01 3.08148791e-33]
noisy probs:  [0.58984375 0.01074219 0.39746094 0.00195312]
mitiq probs:  (-0.010742187500092037, 0.4345703125000897, 0.2597656249999685, 0.31640625000006867)

As you can see, the mitigated results are wildly different every run, and I'm not sure why.

Here are my versions (qml.about()):

Name: PennyLane
Version: 0.33.1
Summary: PennyLane is a Python quantum machine learning library by Xanadu Inc.
Home-page: https://github.com/PennyLaneAI/pennylane
Author: 
Author-email: 
License: Apache License 2.0
Location: /Users/bigsad/Downloads/Algorithm-Research/Student-Hub/Indy-Ng/.venv/lib/python3.11/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, pennylane-lightning, requests, rustworkx, scipy, semantic-version, toml, typing-extensions
Required-by: PennyLane-Lightning, PennyLane-qiskit

Platform info:           macOS-12.6-x86_64-i386-64bit
Python version:          3.11.6
Numpy version:           1.23.5
Scipy version:           1.10.1
Installed devices:
- default.gaussian (PennyLane-0.33.1)
- default.mixed (PennyLane-0.33.1)
- default.qubit (PennyLane-0.33.1)
- default.qubit.autograd (PennyLane-0.33.1)
- default.qubit.jax (PennyLane-0.33.1)
- default.qubit.legacy (PennyLane-0.33.1)
- default.qubit.tf (PennyLane-0.33.1)
- default.qubit.torch (PennyLane-0.33.1)
- default.qutrit (PennyLane-0.33.1)
- null.qubit (PennyLane-0.33.1)
- lightning.qubit (PennyLane-Lightning-0.33.1)
- qiskit.aer (PennyLane-qiskit-0.33.1)
- qiskit.basicaer (PennyLane-qiskit-0.33.1)
- qiskit.ibmq (PennyLane-qiskit-0.33.1)
- qiskit.ibmq.circuit_runner (PennyLane-qiskit-0.33.1)
- qiskit.ibmq.sampler (PennyLane-qiskit-0.33.1)
- qiskit.remote (PennyLane-qiskit-0.33.1)

[purva-thakre]

@hametar0u Apologies for the delayed reply. I don't use pennylane that often.

Could you provide more info on what j=-1 means in your circuit definition? def circuit(params, part=None, j=-1):

I understand j is a label for the circuit wires. I am a bit confused as to why you then use j=0 in the results portion of your code.

[hametar0u]

Hi @purva-thakre , sorry for the late response. I'm basically recycling this code for two different circuits as specified in the VQLS paper (https://arxiv.org/abs/1909.05820). When j = -1, I'm essentially implementing the circuit in figure 9a (page 12), and when j has a non-negative value, I'm implementing the circuit in figure 9c.

[natestemen]

@hametar0u thanks for the question, and apologies for the delay in response here. I figured better late than never!

It's hard to say exactly why this is happening, but a major contributing factor is that quantum error mitigation in general increases the variance of whatever you're measuring. It will decrease your errors on average, but the spread of the measured values will almost certainly be wider than without error mitigation due to the additional post-processing, and in the case of ZNE, the extrapolation.

I'm wondering if you've tried other methods to get the expectation value from PennyLane such as qml.expval. I'd be curious to know if it behaves differently. Usually when I use a simulator I use something with an adjustable number of shots which can be helpful, especially when transitioning to a real device later on.