Noise Aware ZNE

[daniel-mills-cqc]

Adds noise aware zero noise extrapolation, in particular as a new folding method. There were a couple of changes to other parts of ZNE needed to make this possible:

• ZNE no longer does 'factor 1 folding' (i.e. using the base noise of the device) by default. A MitEx which just scales the noise has been added
• The folding methods may now generate many circuits, for example in this case sampling many noisy circuits. I expect this to be of more general use.

Otherwise, I think I have pushed enums and kwargs too far here. I would like to move to having a Folding base class which other folding methods can inherit from. Their behaviour can be defined when they are initialised, rather than counting on kwargs being passed. The reason I have not done this here is because it would change the API significantly, and make the ZNE section of the manual redundant, so I thought I'd get your approval first.

Here is an example, which is also included in the tests:

from pytket import OpType, Circuit
from qermit.noise_model import NoiseModel, PauliErrorTranspile, ErrorDistribution
from pytket.pauli import Pauli
from qermit.noise_model import TranspilerBackend, PauliErrorTranspile
from qermit.zero_noise_extrapolation.zne import gen_ZNE_MitEx, Folding, Fit
from qermit.taskgraph.mittask import ObservableExperiment, AnsatzCircuit
from qermit.taskgraph.utils import ObservableTracker
from pytket.utils import QubitPauliOperator
from pytket.pauli import QubitPauliString
from pytket.unit_id import Qubit
import numpy as np
from itertools import product

# Here we are creating the PTM of an error model
# which acts XI with rate 0.1
ptm = np.diag([1,1,1,1,1,1,1,1,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8])
# This index dixtionary maps Paulis to their index in the PTM
pauli_index = {pauli: index for index, pauli in enumerate(product([Pauli.I, Pauli.X, Pauli.Y, Pauli.Z], repeat=2))}
error_distribution = ErrorDistribution.from_ptm(ptm, pauli_index)

# This print will verify the above
print(error_distribution.distribution)

# This error model will act on the CZ gate,
# and will be acted by the backend created below.
noise_model = NoiseModel(
    noise_model={
        OpType.CZ:error_distribution
    }
)
transpiler = PauliErrorTranspile(noise_model=noise_model)
backend = TranspilerBackend(transpiler=transpiler)

# Note that this particular example of ZNE
# will run with unevenly distributed noise
# scaling values.
zne_mitex = gen_ZNE_MitEx(
    backend=backend,
    noise_scaling_list=[3.6, 1, 4, 2, 2.5, 3, 3.3],
    show_fit=True,
    folding_type=Folding.noise_aware,
    fit_type=Fit.exponential,
    noise_model=noise_model,
    n_noisy_circuit_samples=1000,
)

circuit_noisy = Circuit(2).CZ(0,1)

qps_noisy_noisy = QubitPauliString(map={Qubit(0):Pauli.Z, Qubit(1):Pauli.Z})

qubit_pauli_operator_noisy = QubitPauliOperator(
    dictionary = {
        qps_noisy_noisy:1,
    }
)

observable_tracker_noisy = ObservableTracker(
    qubit_pauli_operator=qubit_pauli_operator_noisy
)

shots=10000
ansatz_circuit_noisy = AnsatzCircuit(
    Circuit=circuit_noisy,
    Shots=shots,
    SymbolsDict={}
)

observable_experiment_noisy = ObservableExperiment(
    AnsatzCircuit=ansatz_circuit_noisy,
    ObservableTracker=observable_tracker_noisy,
)

qubit_pauli_operator_list = zne_mitex.run(
    mitex_wires=[observable_experiment_noisy]
)

producing:

[sjdilkes]

Please rename to mumbai_backend

[sjdilkes]

Mostly looking good - a few small changes + the expected changes to the noise scaling

[sjdilkes]

I'd just do this:
return CustomPass(transform=lambda circuit: circuit)

[sjdilkes]

same again: return CustomPass(transform=lambda circuit: circuit)

[sjdilkes]

return type for function (BasePass?)

[sjdilkes]

Ah, do you use uuid.UUID instead of ResultHandle in this mock backend?

[daniel-mills-cqc]

I do, in part as I don't know how to create new unique ResultHandle objects. Do you happen to know how to do that?

[daniel-mills-cqc]

Never mind, figured it out :P

[sjdilkes]

I'd change the error message to:
BackendInfo stored by Backend has no defined Architecture, please use a Backend with a specified Architecture.

[sjdilkes]

I think this is my line where I get too pedantic with types in python, but I'd do: noise_model: NoiseModel = ... - understood if you'd prefer not to though!

[daniel-mills-cqc]

Thanks! I think you're right that annotating kwargs is best.

[sjdilkes]

n_noisy_circuit_samples: int =

[sjdilkes]

scaled_noise_model: NoiseModel =

[daniel-mills-cqc]

Would you expect mypy to be able to infer this from the signature of scale? Just curious, I don't mind being over cautious in any case :P.

[sjdilkes]

This suggestion was less for mypy and more for me! I just find it helpful, where they're easily defined, to just set the type - less things to track mentally!

[sjdilkes]

You could try:
return(merged_qpo_list = [ QubitPauliOperator(index_to_merged_qpo_dict.get(index, {})) for index in range(max(experiment_index_list) + 1) ],)

might be more confusing though?

If not I'd still type merged_qpo_list: List[QubitPauliOperatpr] - in this case I think it makes it clearer that this is the first time the object has been created, which is helpful to know at the bottom of a function

[sjdilkes]

LGTM