folding trotterized circuit and measuring it at the end

[pegahmp]

I have a circuit that is obtained from trotterization. I start with 5 qubits. I also want to add circuit noise which I do with an initial depolarizing noise and then use scales that are quadratic multiple of the trotterized step size to produce noisy circuits that are folded versions of the circuit with the initial noise. At the end I want to measure the Pauli-X operator on the outputs of the circuit.
To measure the Pauli-X on the first qubit, I apply circuit.h(0) before the measurement. I think this should be done after the folding but once I do that Mitiq does not seem to recognize my curcuit. On the other hand, when I do the measurement first, then do the folding (which I don't think is correct), most of the expectation values (for different trotter steps) are close to 0, which are far from the exact expectation value by an order of 0.4.

Here is a snippet of my code:

lambda_initial_noise = 0.02

def fold_circuits(circuit, initial_noise, scale_factors):

    noisy_circuit = circuit

    noise_model = initialized_depolarizing_noise(noise_level=initial_noise)


    backend = QasmSimulator(noise_model=noise_model)

    exec_circuit = qiskit.transpile(
        noisy_circuit,
        backend=backend,
        basis_gates=noise_model.basis_gates,
        optimization_level=0,  # Important to preserve folded gates.
    )


    folded_circuits = [
        zne.scaling.fold_gates_at_random(exec_circuit, scale)
        for scale in scale_factors
    ]


    return folded_circuits

def exec_folded_circuits(folded_circuits, shots):

    noise_model = initialized_depolarizing_noise(noise_level=0.02)
    backend = QasmSimulator(noise_model=noise_model)


    exec_circuit = qiskit.transpile(
        folded_circuits,
        backend=backend,
        basis_gates=noise_model.basis_gates if noise_model else None,
        optimization_level=0, # Important to preserve folded gates.
    )


    job = backend.run(exec_circuit, shots=shots)

    all_counts = [job.result().get_counts(i) for i in range(len(folded_circuits))]
    expectation_values = [(counts.get("0") - counts.get("1")) / shots for counts in all_counts]

    return expectation_values

def compute_joint_exps_error_and_step_size(num_trotter_steps_list, c): #joint algorithmic and physical error
    errors = []
    joint_exps = [] #joint expectation values
    step_sizes = []

    for num_steps in num_trotter_steps_list:
        trotter = TrotterQRTE(SuzukiTrotter(order=2), num_timesteps=int(num_steps), estimator=Estimator())
        problem = TimeEvolutionProblem(
            H,
            initial_state=initial_state,
            time=final_time, )
            result = trotter.evolve(problem)

        circuit = result.evolved_state

        circuit = circuit.decompose(reps=2).decompose("disentangler_dg").decompose("multiplex1_reverse_dg")

        c_reg = qiskit.ClassicalRegister(1)

        # Apply Hadamard gate to qubit 0 before measurement to measure in the X-basis
        circuit.h(0)

        # Alternatively, add the classical register to an existing quantum circuit
        circuit.add_register(c_reg)

        #print(circuit)

        # Measure the qubit
        circuit.measure(0, 0)

        # Compute the step size
        step_size = final_time / num_steps

        quadratic_scale = c * (step_size**2)
        print("num_steps", num_steps, "x quadratic", quadratic_scale/lambda_initial_noise)

        folded_circuit = fold_circuits(circuit, lambda_initial_noise, [1, quadratic_scale/lambda_initial_noise])
        noisy_exps = exec_folded_circuits(folded_circuit, shots)
        joint_exps.append(noisy_exps[1])

        # Compute the error
        error = exact_exp_val - noisy_exps[1]
        errors.append(error)


        step_sizes.append(step_size)
return joint_exps, step_sizes, errors

c1 = 30
num_trotter_steps = [45, 55, 65, 75]

joint_exp_values, joint_step_sizes, joint_errors = compute_joint_exps_error_and_step_size(num_trotter_steps, c1)

Now if we print the joint_exp_values which is the expectation value due to the error caused by both the trotter step sizes and the physical noise, we see the expectation values around 0 that I wrote about at the beginning.

[natestemen]

Thanks for posting this here. I'm still having trouble running your code due to missing imports. Could you add those so I can help debug?

There are two possibilities for your workflow:

1. Add the measurements in the exec_folded_circuits function
2. Modify your execution function to return measurement results (i.e. bitstrings, or similar) and pass an observable to execute_with_zne.

Have you tried either of these approaches?

[pegahmp]

I have tried 1, no changes are applied. As for 2, I can't use execute_with_zne since I am changing the circuit for each one the noise levels. Basically I have a physical noise and then I use multiples of that physical noise. However, the noiseless circuit is changing at the same time.

here are the imports, some of them might have been used in the other parts of the code:
import qiskit
import math
import numpy as np
from scipy.linalg import expm
from qiskit_aer import QasmSimulator
from qiskit.quantum_info import Operator, Pauli, PauliList
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.primitives import Estimator
import matplotlib.pyplot as plt
import copy

from mitiq import zne
from mitiq.interface.mitiq_qiskit.qiskit_utils import initialized_depolarizing_noise

from qiskit.quantum_info import Statevector
from qiskit_algorithms import TimeEvolutionProblem
from qiskit_algorithms import TrotterQRTE
from qiskit.synthesis import SuzukiTrotter

[natestemen]

Thanks for providing these. I'm still getting errors when running your code:

  File "/Users/nate/code/mitiq/pegahmp.py", line 77, in compute_joint_exps_error_and_step_size
    H,
    ^
NameError: name 'H' is not defined

In addition the following variables are undefined:

1. initial_state
2. final_time
3. exact_exp_val

Please ensure your code is runnable if you'd like further help.

I have tried 1, no changes are applied

I'm not sure what this means. Can you elaborate?

I've noticed a few oddities about your code while trying to figure out what your workflow looks like.

1. You are transpiling circuits twice. I would remove the transpilation in the fold_circuits function since it happens inside exec_folded_circuits.
2. You are executing noise scaled circuit, but there is never any extrapolation happening. I.e. you are only looking at expectation values of noise-scaled circuits. You need to do extrapolation if you are trying to use ZNE.
3. I'm failing to see why you can't use execute_with_zne in your workflow using something like

   execute_with_zne(circuit, exec_folded_circuits, factory=LinearFactory([1, quadratic_scale/lambda_initial_noise]))

   Here you can use any Factory object for extrapolation (linear, polynomial, exponential).

[Misty-W]

To the question of where the depolarizing noise is implemented, as asked on Discord: the noise model you imported from Mitiq actually comes from Qiskit. So to understand how the noise model is implemented you would need to check the Qiskit docs