From cf09966c9c9ee32e568f4a7d1c148ae5a8ef1077 Mon Sep 17 00:00:00 2001 From: Anders Rokne Date: Thu, 22 Oct 2020 13:02:23 +0200 Subject: [PATCH 1/2] added zero noise extrapolation implementation using amplification of CNOT-gates by repeating CNOTs --- zero_noise_extrapolation_cnot.py | 562 +++++++++++++++++++++++++++++++ 1 file changed, 562 insertions(+) create mode 100644 zero_noise_extrapolation_cnot.py diff --git a/zero_noise_extrapolation_cnot.py b/zero_noise_extrapolation_cnot.py new file mode 100644 index 0000000..2a2de66 --- /dev/null +++ b/zero_noise_extrapolation_cnot.py @@ -0,0 +1,562 @@ +from qiskit import QuantumCircuit, execute, Aer + +from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap +from qiskit.transpiler.passes import Unroller, Optimize1qGates +from qiskit.transpiler.preset_passmanagers.level3 import level_3_pass_manager + +from numpy import asarray, ndarray, shape, zeros, empty, average, transpose, dot +from numpy.linalg import solve + +import random + + +""" +-- ZERO NOISE EXTRAPOLATION for CNOT-gates -- + +This implemention does quantum error mitigation using the method of zero noise extrapolation, by amplifying noise in +a quantum circuit by a set of noise amplification factors, then using Richardson extrapolation to extrapolate the +expectation value to the zero-noise limit. + +The noise amplified and mitigated is specifically noise in CNOT-gates. The noise is amplified by n amplification +factors 1, 3, 5, ..., 2n + 1, where 1 means the bare circuit without noise amplification, and 3 means every +CNOT gate is extended as CNOT*CNOT*CNOT. + +As CNOT*CNOT = Id, the identity, in the noise-free case the amplified CNOT have the same action as a single CNOT, +but ~3 times the noise. + +""" + + +class ZeroNoiseExtrapolation: + + def __init__(self, qc: QuantumCircuit, exp_val_func, backend=None, noise_model=None, + n_amp_factors: int = 3, pauli_twirl: bool = False, shots: int = 8192, + pass_manager: PassManager = None): + """ + :param qc: The circuit to be mitigated + :param exp_val_func: A function which computes the observed expectation value of some operator as a function of + the measurement counts from the circuit qc + :param backend: The backend on which to execute the circuit + :param noise_model: Optinal custom noise model for execution on a simulator backend + :param n_amp_factors: Number of amplification factors to be used. For n amplification factors, the + amplification factors will be 1,3,5,...,2n + 1 + :param pauli_twirl: Do pauli twirl True / False + :param shots: Number of shots of the circuit to execute + :param pass_manager: Optional custom pass manager to use when transpiling the circuit + """ + + if backend == None: + self.backend = Aer.get_backend("qasm_simulator") + else: + self.backend = backend + + # Do an initial heavy optimization of the input circuit + self.qc = self.transpile_circuit(qc, custom_pass_manager=pass_manager) + + self.exp_val_func = exp_val_func + + self.noise_model = noise_model + + self.n_amp_factors = n_amp_factors + self.noise_amplification_factors = asarray([(1 + 2*i) for i in range(0, n_amp_factors)]) + + self.pauli_twirl = pauli_twirl + + # Max number of shots for one circuit execution on IBMQ devices is 8192. + # To do more shots, we have to partition them up into several executions. + if shots <= 8192: + self.num_executions = 1 + self.shots = shots + else: + self.num_executions = (shots // 8192) + 1 + self.shots = int(shots / self.num_executions) + + # Initialization of variables for later use: + + self.counts = [] + + self.depths = empty(n_amp_factors) + + self.bare_exp_vals = zeros(0) + self.all_exp_vals = zeros(0) + self.mitigated_exp_vals = zeros(0) + + self.result = None + + def set_shots(self, shots: int): + if shots <= 8192: + self.num_executions = 1 + self.shots = shots + else: + self.num_executions = (shots // 8192) + 1 + self.shots = int(shots / self.num_executions) + + def noise_amplify_and_pauli_twirl_cnots(self, qc: QuantumCircuit, amp_factor: int, + pauli_twirl: bool) -> QuantumCircuit: + """ + Amplify CNOT-noise by extending each CNOT-gate as CNOT^amp_factor and possibly Pauli-twirl all CNOT-gates + + Using CNOT*CNOT = I, the identity, and an amp_factor = (2*n + 1) for an integer n, then the + extended CNOT will have the same action as a single CNOT, but with the noise amplified by + a factor amp_factor. + + :param qc: Quantum circuit for which to Pauli twirl all CNOT gates and amplify CNOT-noise + :param amp_factor: The noise amplification factor, must be (2n + 1) for n = 0,1,2,3,... + :param pauli_twirl: Add pauli twirling True / False + :return: Noise-amplified and possibly Pauli-twirled Quantum Circuit + """ + + if (amp_factor - 1) % 2 != 0: + print("Invalid amplification factor:", amp_factor) + + # The circuit may be expressed in terms of various types of gates. + # The 'Unroller' transpiler pass 'unrolls' (decomposes) the circuit gates to be expressed in terms of the + # physical gate set [u1,u2,u3,cx] + + # This is still general for backends with possibly different native gate sets, as we can still express the + # circuit, and do the noise amplification + pauli twirling, in terms of the [u1,u2,u3,cx] gate set, and then + # if necessary convert to the native gate set of the backend at a later point + + unroller = Unroller(["u1","u2","u3","cx"]) + pm = PassManager(unroller) + + unrolled_qc = pm.run(qc) + + circuit_qasm = unrolled_qc.qasm() + new_circuit_qasm_str = "" + + qreg_name = find_qreg_name(circuit_qasm) + + for i, line in enumerate(circuit_qasm.splitlines()): + if line[0:2] == "cx": + for j in range(amp_factor): + if pauli_twirl: + new_circuit_qasm_str += pauli_twirl_cnot_gate(qreg_name, line) + else: + new_circuit_qasm_str += (line + "\n") + else: + new_circuit_qasm_str += line + "\n" + + new_qc = QuantumCircuit.from_qasm_str(new_circuit_qasm_str) + + # The "Optimize1qGates" transpiler pass optimizes chains of single-qubit gates by collapsing them into + # a single, equivalent u3-gate. We want to collapse unnecessary single-qubit gates, but not CNOT-gates, as + # these give us the noise amplification. + optimize1qates = Optimize1qGates() + pm = PassManager(optimize1qates) + + return pm.run(new_qc) + + def transpile_circuit(self, qc: QuantumCircuit, custom_pass_manager: PassManager = None) -> QuantumCircuit: + """ + Transpile and optimize the quantum circuit using qiskits PassManager class and the level_3_pass_manager, + which contains the transpiler passes for the optimalization level 3 preset (the preset with highest + level of optimization). + + As we want to add additional CNOTs for noise amplification and possibly additional single qubit gates + for Pauli twirling, we need to transpile the circuit before, to avoid the additional gates to be removed + by the transpiler. + + The Optimize1qGates transpiler pass will be used later to optimize single qubit gates added during + the Pauli-twirling + + :return: The transpiled circuit + """ + + if custom_pass_manager == None: + pass_manager_config = PassManagerConfig(basis_gates=["id", "u1", "u2", "u3", "cx"], + coupling_map=CouplingMap(self.backend.configuration().coupling_map), + backend_properties=self.backend.properties()) + pass_manager = level_3_pass_manager(pass_manager_config) + else: + pass_manager = custom_pass_manager + + self.passes = pass_manager.passes() + + return pass_manager.run(qc) + + def execute_circuits(self, circuits: list) -> list: + """ + Execute all circuits and return measurement counts. If shots > 8192, we need to partition the execution + into several sub-executions. + + :param circuits: All circuits to be executed + :return: A list of count-dictionaries + """ + + # The max number of shots on a single execution on the IBMQ devices is 8192. + # If shots > 8192, we have to partition the execution into several sub-executions. + execution_circuits = [] + for qc in circuits: + execution_circuits += [qc.copy() for i in range(self.num_executions)] + + # + + if self.noise_model == None: + counts = execute(execution_circuits, backend=self.backend, + pass_manager=PassManager(), shots=self.shots).result().get_counts() + else: + counts = execute(execution_circuits, backend=self.backend, noise_model=self.noise_model, + pass_manager=PassManager(), shots=self.shots).result().get_counts() + + self.counts = counts # Saving the counts in a member variable. Might remove. + + return counts + + def compute_exp_vals(self, counts: list) -> ndarray: + """ + From the given exp_val_func, which computes the expectation value as a function of measurement counts, we + compute the exp val of all executed circuits taking into account that we might have partitioned up circuit + executions due to IBMQ's restriction of shots<=8192 per execution. + + :param counts: A list of measurement counts-dictionaries + :return: A list of computed expectation values + """ + + n_distinct_circuits = int(len(counts) / self.num_executions) + exp_vals = zeros(n_distinct_circuits, dtype=float) + + for i in range(n_distinct_circuits): + exp_val_k = 0 + for k in range(self.num_executions): + exp_val_k += self.exp_val_func(counts[i*self.num_executions + k]) + exp_vals[i] = exp_val_k / self.num_executions + return exp_vals + + def extrapolate(self, exp_vals, noise_amplification_factors=None, n_amp_factors=None, + custom_extrapolation_func=None) -> float: + """ + Do extrapolation to the zero-noise case based on the expectation values measured from the + noise amplified circuits. + + :param exp_vals: Expectation values in an array of length n_amp_factors + :param noise_amplification_factors: Optional custom noise amplification factors + :param n_amp_factors: Number of amplification factors to be included in the extrapolation + :param custom_extrapolation_func: + :return: Extrapolated/mitigated expectation value + """ + if noise_amplification_factors == None: + noise_amplification_factors = self.noise_amplification_factors + if n_amp_factors == None: + n_amp_factors = self.n_amp_factors + + # Sanity checks. For now, only prints for debugging purposes + if shape(noise_amplification_factors)[0] < n_amp_factors: + print("Noise amplification factors is of shape", shape(noise_amplification_factors), + "but must be of length equal or greater than n_amp_factors=",n_amp_factors) + if shape(exp_vals)[0] < n_amp_factors: + print("Array of exp vals is of shape", shape(noise_amplification_factors), + "but must be of length equal or greater than n_amp_factors=", n_amp_factors) + + if custom_extrapolation_func == None: + return richardson_extrapolate(asarray(exp_vals[0:n_amp_factors]), + asarray(noise_amplification_factors[0:n_amp_factors])) + else: + return custom_extrapolation_func(asarray(exp_vals[0:n_amp_factors]), + asarray(noise_amplification_factors[0:n_amp_factors])) + + def extrapolate_array(self, all_exp_vals, noise_amplification_factors=None, + extrapolation_method=None, n_amp_factors=None) -> ndarray: + """ + Redo the extrapolation to the zero-noise limit for an array of runs. + + :param all_exp_vals: + :param noise_amplification_factors: + :param extrapolation_method: + :param n_amp_factors: + :return: Array of mitigated expectation values for each run + """ + if noise_amplification_factors != None and n_amp_factors == None: + n_amp_factors = shape(noise_amplification_factors)[0] + + results = zeros(shape(all_exp_vals)[0]) + for i in range(shape(all_exp_vals)[0]): + results[i] = self.extrapolate(all_exp_vals[i], noise_amplification_factors, + extrapolation_method, n_amp_factors) + return results + + def mitigate(self, repeats: int = 1, verbose: bool = False) -> float: + """ + + + :param repeats: Number of repeats of the extrapolation to perform. The result is averaged over all repeats. + :param verbose: Prints during the computation, True / False + :return: The mitigated expectation value + """ + + n_amp_factors = shape(self.noise_amplification_factors)[0] + + if verbose: + print("shots=", self.shots, ", n_amp_factors=", self.n_amp_factors, ", paulitwirl=", self.pauli_twirl, + " repeats=", repeats, sep="") + print("noise amplification factors=", self.noise_amplification_factors, sep="") + + if verbose: + print("Constructing circuits") + + circuits = [] + + for i in range(repeats): + + if verbose and ((i + 1) % 25 == 0): + print(i+1,"/",repeats) + + for j, amp_factor in enumerate(self.noise_amplification_factors): + circuits.append(self.noise_amplify_and_pauli_twirl_cnots(qc=self.qc, amp_factor=amp_factor, + pauli_twirl=self.pauli_twirl)) + if i == 0: + self.depths[j] = circuits[-1].depth() + + if verbose: + print("Depths=",self.depths, sep="") + + print("Executing circuits") + + counts = self.execute_circuits(circuits) + + exp_vals = self.compute_exp_vals(counts) + + # Process the resulting expectation values: + + self.bare_exp_vals = zeros((repeats,)) + self.all_exp_vals = zeros((repeats,n_amp_factors)) + self.mitigated_exp_vals = zeros((repeats,)) + + if verbose: + print("Processing results:") + + if repeats == 1: + self.result = richardson_extrapolate(self.all_exp_vals[0,:], self.noise_amplification_factors) + else: + for i in range(repeats): + self.bare_exp_vals[i] = exp_vals[i*n_amp_factors] + + for j in range(n_amp_factors): + self.all_exp_vals[i, j] = exp_vals[i*n_amp_factors + j] + + mitigation_results = richardson_extrapolate(self.all_exp_vals[i, :], self.noise_amplification_factors) + self.mitigated_exp_vals[i] = mitigation_results + + self.result = sum(self.mitigated_exp_vals) / shape(self.mitigated_exp_vals)[0] + + if verbose: + print("Mitigation done. Result:") + print("Bare exp val =", average(self.bare_exp_vals)) + print("Mitigated exp val =",self.result) + + return self.result + + +# PAULI TWIRLING AND NOISE AMPLIFICATION HELP FUNCTIONS + +# Conversion from pauli x/y/z-gates to physical u1/u3-gates in correct OpenQASM-format +PHYSICAL_GATE_CONVERSION = {"X": "u3(pi,0,pi)", "Z": "u1(pi)", "Y": "u3(pi,pi/2,pi/2)"} + + +def find_qreg_name(circuit_qasm: str) -> str: + """ + Finds the name of the quantum register in the circuit. + + :param circuit_qasm: OpenQASM string with instructions for the entire circuit + :return: Name of the quantum register + """ + for line in circuit_qasm.splitlines(): + if line[0:5] == "qreg ": + qreg_name = "" + for i in range(5,len(line)): + if line[i] == "[" or line[i] == ";": + break + elif line[i] != " ": + qreg_name += line[i] + return qreg_name + + +def find_cnot_control_and_target(qasm_line: str) -> (int, int): + """ + Find indices of control and target qubits for the CNOT-gate in question + + :param qasm_line: OpenQASM line containing the CNOT + :return: Indices of control and target qubits + """ + qubits = [] + for i, c in enumerate(qasm_line): + if c == "[": + qubit_nr = "" + for j in range(i+1, len(qasm_line)): + if qasm_line[j] == "]": + break + qubit_nr += qasm_line[j] + qubits.append(int(qubit_nr)) + return qubits[0], qubits[1] + + +def propagate(control_in: str, target_in: str): + """ + Propagates Pauli gates through a CNOT in accordance with the following circuit identities: + + (X x I) CNOT = CNOT (X x X) + (I x X) CNOT = CNOT (I x X) + (Z x I) CNOT = CNOT (I x Z) + (I x Z) CNOT = XNOT (Z x Z) + + Note that instead of Pauli-twirling with [X,Z,Y] we use [X,Z,XZ] where XZ = -i*Y. + The inverse of XZ is ZX = -XZ = i*Y. Propagating over the CNOT, the complex factors cancels. + + :param control_in: Pauli gates on control qubit before CNOT + :param target_in: Pauli gates on target qubit before CNOT + :return: Equivalent Pauli gates on control and target qubits after CNOT + """ + + control_out, target_out = '', '' + if 'X' in control_in: + control_out += 'X' + target_out += 'X' + if 'X' in target_in: + target_out += 'X' + if 'Z' in control_in: + control_out += 'Z' + if 'Z' in target_in: + control_out += 'Z' + target_out += 'Z' + + # Pauli gates square to the identity, i.e. XX = I, ZZ = I + # Remove all such occurences from the control & target out Pauli gate strings + if 'ZZ' in control_out: + control_out = control_out[:-2] + if 'ZZ' in target_out: + target_out = target_out[:-2] + if 'XX' in control_out: + control_out = control_out[2:] + if 'XX' in target_out: + target_out = target_out[2:] + + # If no Pauli gates remain then we have the identity gate I + if control_out == '': + control_out = 'I' + if target_out == '': + target_out = 'I' + + # The inverse of XZ is ZX, therefore we reverse the gate order to obtain the correct pauli gates c,d + # such that (a x b) CNOT (c x d) = CNOT (c^-1 x d^-1) (c x d) = CNOT + return control_out[::-1], target_out[::-1] + + +def apply_qasm_pauli_gate(qreg_name: str, qubit: int, pauli_gates: str): + """ + Construct a OpenQASM-string with the instruction to apply the given pauli gates to + the given qubit + + :param qreg_name: Name of quantum register + :param qubit: Index of qubit + :param pauli_gates: The Pauli gates to be applied + :return: The OpenQASM-string with the instruction + """ + new_qasm_line = '' + for gate in pauli_gates: + if gate != 'I': + u_gate = PHYSICAL_GATE_CONVERSION[gate] + new_qasm_line += u_gate + ' ' + qreg_name + '[' + str(qubit) + '];' + '\n' + return new_qasm_line + + +def pauli_twirl_cnot_gate(qreg_name: str, qasm_line_cnot: str) -> str: + """ + Pauli-twirl a CNOT-gate from the given OpenQASM string line containing the CNOT. + This will look something like: cx q[0],q[1]; + + :param qreg_name: Name of quantum register + :param qasm_line_cnot: OpenQASM-line containing the CNOT to pauli twirl + :return: + """ + control, target = find_cnot_control_and_target(qasm_line_cnot) + + # Note: XZ = -i*Y, with inverse (XZ)^-1 = ZX = i*Y. This simplifies the propagation of gates a,b over the CNOT + pauli_gates = ["I", "X", "Z", "XZ"] + + a = random.choice(pauli_gates) + b = random.choice(pauli_gates) + + # Find gates such that: + # (a x b) CNOT (c x d) = CNOT for an ideal CNOT-gate, + # by propagating the Pauli gates through the CNOT + + c, d = propagate(a, b) + + new_qasm_line = apply_qasm_pauli_gate(qreg_name, control, a) + new_qasm_line += apply_qasm_pauli_gate(qreg_name, target, b) + new_qasm_line += qasm_line_cnot + '\n' + new_qasm_line += apply_qasm_pauli_gate(qreg_name, target, d) + new_qasm_line += apply_qasm_pauli_gate(qreg_name, control, c) + + return new_qasm_line + + +def pauli_twirl_cnots(qc: QuantumCircuit) -> QuantumCircuit: + """ + General function for Pauli-twirling all CNOT-gates in a quantum circuit. + Included for completeness. + + :param qc: quantum circuit for which to Pauli twirl all CNOT gates + :return: Pauli twirled quantum circuit + """ + + # The circuit may be expressed in terms of various types of gates. + # The 'Unroller' transpiler pass 'unrolls' the circuit to be expressed in terms of the + # physical gate set [u1,u2,u3,cx] + unroller = Unroller(["u1", "u2", "u3", "cx"]) + pm = PassManager(unroller) + + unrolled_qc = pm.run(qc) + + circuit_qasm = unrolled_qc.qasm() + new_circuit_qasm_str = "" + + qreg_name = find_qreg_name(circuit_qasm) + + for i, line in enumerate(circuit_qasm.splitlines()): + if line[0:2] == "cx": + new_circuit_qasm_str += pauli_twirl_cnot_gate(qreg_name, line) + else: + new_circuit_qasm_str += line + "\n" + + new_qc = QuantumCircuit.from_qasm_str(new_circuit_qasm_str) + + # The "Optimize1qGates" transpiler pass optimizes chains of single-qubit gates by collapsing them into + # a single, equivalent u3-gate + + # We want to avoid that the transpiler optimizes CNOT-gates, as the ancillary CNOT-gates must be kept + # to keep the noise amplification + + optimize1qates = Optimize1qGates() + pm = PassManager(optimize1qates) + + return pm.run(new_qc) + + +# Richardson extrapolation: +def richardson_extrapolate(E: ndarray, c: ndarray) -> float: + """ + Code taken from github.com/OpenQuantumComputing/error_mitigation/ -> zero_noise_extrapolation.py and slightly modified + :param E: Expectation values + :param c: Noise amplification factors + :return: Extrapolation to the zero-limit + """ + if isinstance(E, list): + E = asarray(E) + if isinstance(E, list): + c = asarray(c) + + n = E.shape[0] + if c.shape[0] != n: + raise ValueError('E and c must have the same dimension.') + if n <= 1: + raise ValueError('the dimension of E and c must be larger than 1.') + A = zeros((n, n)) + b = zeros((n, 1)) + # must sum to 1 + A[0, :] = 1 + b[0] = 1 + for k in range(1, n): + A[k, :] = c ** k + x = solve(A, b) + return dot(transpose(E), x)[0] \ No newline at end of file From 8d13c76dc6e2a05059ad306ae1cda81aeaaeadf8 Mon Sep 17 00:00:00 2001 From: Anders Rokne Date: Fri, 23 Oct 2020 10:30:29 +0200 Subject: [PATCH 2/2] Implemented zero noise extrapolation by repeating cnot-gates, with the 3-qubit SWAP-test circuit as an example. --- .gitignore | 3 + 3qubit Swap-test.ipynb | 741 ++++++++++++ 5qubit GHZ state.ipynb | 2 +- ...48_paulitwirlingFalse_r1.max_circuit_depth | 1 + ...rlingFalse_r1.max_transpiled_circuit_depth | 1 + ...8_paulitwirlingFalse_r1.mean_circuit_depth | 1 + ...lingFalse_r1.mean_transpiled_circuit_depth | 1 + ...periments2048_paulitwirlingFalse_r1.result | Bin 0 -> 1117441 bytes ...8_paulitwirlingFalse_r16.max_circuit_depth | 1 + ...lingFalse_r16.max_transpiled_circuit_depth | 1 + ..._paulitwirlingFalse_r16.mean_circuit_depth | 1 + ...ingFalse_r16.mean_transpiled_circuit_depth | 1 + ...eriments2048_paulitwirlingFalse_r16.result | Bin 0 -> 1120605 bytes ...48_paulitwirlingFalse_r2.max_circuit_depth | 1 + ...rlingFalse_r2.max_transpiled_circuit_depth | 1 + ...8_paulitwirlingFalse_r2.mean_circuit_depth | 1 + ...lingFalse_r2.mean_transpiled_circuit_depth | 1 + ...periments2048_paulitwirlingFalse_r2.result | Bin 0 -> 1120639 bytes ...8_paulitwirlingFalse_r32.max_circuit_depth | 1 + ...lingFalse_r32.max_transpiled_circuit_depth | 1 + ..._paulitwirlingFalse_r32.mean_circuit_depth | 1 + ...ingFalse_r32.mean_transpiled_circuit_depth | 1 + ...eriments2048_paulitwirlingFalse_r32.result | Bin 0 -> 1122653 bytes ...48_paulitwirlingFalse_r4.max_circuit_depth | 1 + ...rlingFalse_r4.max_transpiled_circuit_depth | 1 + ...8_paulitwirlingFalse_r4.mean_circuit_depth | 1 + ...lingFalse_r4.mean_transpiled_circuit_depth | 1 + ...periments2048_paulitwirlingFalse_r4.result | Bin 0 -> 1120563 bytes ...8_paulitwirlingFalse_r64.max_circuit_depth | 1 + ...lingFalse_r64.max_transpiled_circuit_depth | 1 + ..._paulitwirlingFalse_r64.mean_circuit_depth | 1 + ...ingFalse_r64.mean_transpiled_circuit_depth | 1 + ...eriments2048_paulitwirlingFalse_r64.result | Bin 0 -> 1122635 bytes ...48_paulitwirlingFalse_r8.max_circuit_depth | 1 + ...rlingFalse_r8.max_transpiled_circuit_depth | 1 + ...8_paulitwirlingFalse_r8.mean_circuit_depth | 1 + ...lingFalse_r8.mean_transpiled_circuit_depth | 1 + ...periments2048_paulitwirlingFalse_r8.result | Bin 0 -> 1120703 bytes ...alse_shots16777216_paulitwirlFalse.circuit | Bin 0 -> 11907 bytes ...se_shots16777216_paulitwirlFalse_r1.result | Bin 0 -> 11935 bytes ...e_shots16777216_paulitwirlFalse_r11.result | Bin 0 -> 57516 bytes ...e_shots16777216_paulitwirlFalse_r13.result | Bin 0 -> 66641 bytes ...se_shots16777216_paulitwirlFalse_r3.result | Bin 0 -> 21051 bytes ...se_shots16777216_paulitwirlFalse_r5.result | Bin 0 -> 30168 bytes ...se_shots16777216_paulitwirlFalse_r7.result | Bin 0 -> 39284 bytes ...se_shots16777216_paulitwirlFalse_r9.result | Bin 0 -> 48400 bytes ...False_shots8388608_paulitwirlFalse.circuit | Bin 0 -> 4655 bytes ...lse_shots8388608_paulitwirlFalse_r1.result | Bin 0 -> 4959 bytes ...se_shots8388608_paulitwirlFalse_r11.result | Bin 0 -> 24040 bytes ...se_shots8388608_paulitwirlFalse_r13.result | Bin 0 -> 27856 bytes ...lse_shots8388608_paulitwirlFalse_r3.result | Bin 0 -> 8776 bytes ...lse_shots8388608_paulitwirlFalse_r5.result | Bin 0 -> 12592 bytes ...lse_shots8388608_paulitwirlFalse_r7.result | Bin 0 -> 16408 bytes ...lse_shots8388608_paulitwirlFalse_r9.result | Bin 0 -> 20224 bytes ...odelamplification_ampfactors7_shots8388608 | Bin 0 -> 203 bytes zero_noise_extrapolation.py | 14 +- zero_noise_extrapolation_cnot.py | 1016 +++++++++++++---- 57 files changed, 1545 insertions(+), 259 deletions(-) create mode 100644 3qubit Swap-test.ipynb create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.result create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_transpiled_circuit_depth create mode 100644 results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse.circuit create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r1.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r11.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r13.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r3.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r5.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r7.result create mode 100644 results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r9.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse.circuit create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r1.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r11.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r13.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r3.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r5.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r7.result create mode 100644 results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r9.result create mode 100644 results/3qswaptest_paulinoisemodel_noisemodelamplification_ampfactors7_shots8388608 diff --git a/.gitignore b/.gitignore index b6e4761..8b4de1a 100644 --- a/.gitignore +++ b/.gitignore @@ -127,3 +127,6 @@ dmypy.json # Pyre type checker .pyre/ + + +.idea/ \ No newline at end of file diff --git a/3qubit Swap-test.ipynb b/3qubit Swap-test.ipynb new file mode 100644 index 0000000..36b6dd0 --- /dev/null +++ b/3qubit Swap-test.ipynb @@ -0,0 +1,741 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import *\n", + "from qiskit.result.result import Result, ExperimentResult\n", + "from qiskit.providers.aer.noise import *\n", + "from qiskit.providers.aer.noise.device import basic_device_noise_model\n", + "\n", + "from qiskit.test.mock import FakeAthens\n", + "\n", + "from qiskit.transpiler import PassManager\n", + "from qiskit.transpiler.passes import Unroller\n", + "\n", + "import numpy as np\n", + "\n", + "import sys\n", + "sys.path.append('../')\n", + "\n", + "from qiskit_utilities.utilities import *\n", + "\n", + "from zero_noise_extrapolation_cnot import ZeroNoiseExtrapolation\n", + "from zero_noise_extrapolation import mitigate, Richardson_extrapolate\n", + "\n", + "import pickle\n", + "from typing import List\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "sim_backend = Aer.get_backend(\"qasm_simulator\")\n", + "mock_backend = FakeAthens()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def add_swaptest_gate(qc, probe, q1, q2, barrier=False):\n", + " qc.toffoli(probe, q1, q2)\n", + " \n", + " if barrier:\n", + " qc.barrier()\n", + " \n", + " qc.toffoli(probe, q2, q1)\n", + " \n", + " if barrier:\n", + " qc.barrier()\n", + " \n", + " qc.toffoli(probe, q1, q2)\n", + " \n", + "def create_3qswaptest_circuit(barrier=False):\n", + " qc = QuantumCircuit(3,1)\n", + " \n", + " qc.h(0)\n", + " \n", + " qc.h(1)\n", + " \n", + " if barrier:\n", + " qc.barrier()\n", + " \n", + " add_swaptest_gate(qc, 0, 1, 2, barrier=barrier)\n", + " \n", + " if barrier:\n", + " qc.barrier()\n", + " \n", + " qc.h(0)\n", + " \n", + " qc.measure(0,0)\n", + " \n", + " return qc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The SWAP-test circuit on two 1-qubit states is constructed as shown belown, using 3 Toffoli-gates (https://arxiv.org/abs/1712.09271).\n", + "\n", + "We prepare the states q_1 = (|0> + |1>)/sqrt(2) and q_2 = |0>, while q_0 is called the probe qubit. The Z-measurement on the probe qubits measures the overlap between the state on q_1 and q_2. The true expectation value in this case is 0.5." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = create_3qswaptest_circuit()\n", + "\n", + "qc.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each Toffoli-gate can be decomposed in the following way. Note that one Toffoli gate has a CNOT complexity of 6. A SWAP-test circuit on two n-qubit states, thus 2n + 1 qubits in total, requires 3n Toffoli gates." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pass_manager = PassManager(Unroller([\"u1\",\"u2\",\"u3\",\"cx\"]))\n", + "\n", + "qc_swap = create_3qswaptest_circuit(barrier=True)\n", + "\n", + "qc_unrolled = pass_manager.run(qc_swap)\n", + "\n", + "qc_unrolled.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We specify the expectation value function that computes the estimated expectation value from a set of quantum circuit experiment results.\n", + "\n", + "The repeating CNOTs implementation requires the expectation value function to return both the expectation value and the variances. The random Pauli-sampling implementation requires only the expectation value. To reuse code, we specify a filter to be passed to the function that specifies the method used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def swaptest_exp_val_func(results: List[ExperimentResult], myfilter=None):\n", + " exp_vals = np.zeros(len(results))\n", + " variances = np.zeros(len(results))\n", + " for i,experiment_result in enumerate(results):\n", + " shots = experiment_result.shots\n", + " counts = experiment_result.data.counts\n", + " eigenval = 0\n", + " for key in counts.keys():\n", + " if key == \"0x0\":\n", + " eigenval = +1\n", + " elif key == \"0x1\":\n", + " eigenval = -1\n", + " exp_vals[i] += eigenval*counts[key] / shots\n", + " variances[i] = 1 - exp_vals[i]**2\n", + " if myfilter is not None and myfilter[\"repeatingcnots\"]:\n", + " return exp_vals, variances\n", + " else:\n", + " return exp_vals" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zero noise extrapolation, mitigating noise on CNOT-gates, on the SWAP-test circuit. Executing the circuits on a simulator with a stochastic Pauli noise model. We choose the noise probability on CNOT-gates to be an order of magnitude larger than on the u1/u2/u3 single-qubit gates, which is realistic for modern quantum processors.\n", + "\n", + "Noise amplification factors = [1,3,5,7,9]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Amplification factor = 1.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.39123917, variance = 0.84683265, total shots executed = 8388608.\n", + "Amplification factor = 3.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.27788734, variance = 0.92266582, total shots executed = 8388608.\n", + "Amplification factor = 5.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.19675660, variance = 0.96117035, total shots executed = 8388608.\n", + "Amplification factor = 7.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.13966966, variance = 0.98036979, total shots executed = 8388608.\n", + "Amplification factor = 9.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.09886336, variance = 0.99010501, total shots executed = 8388608.\n", + "Amplification factor = 11.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.07036972, variance = 0.99492316, total shots executed = 8388608.\n", + "Amplification factor = 13.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.05051708, variance = 0.99733688, total shots executed = 8388608.\n", + "-----\n", + "ERROR MITIGATION DONE\n", + "Bare circuit expectation value: 0.39123917\n", + "Noise amplified expectation values: [0.39123917 0.27788734 0.1967566 0.13966966 0.09886336 0.07036972\n", + " 0.05051708]\n", + "Circuit depths: [ 35 71 107 143 179 215 251]\n", + "-----\n", + "Mitigated expectation value: 0.46028259\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0.4602825874462453" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def create_depolarizing_error_model(p_cnot, p_u, p_meas):\n", + " X = np.asarray([[0, 1], [1, 0]])\n", + " Y = np.asarray([[0, -1j], [1j, 0]])\n", + " Z = np.asarray([[1, 0], [0, -1]])\n", + " I = np.asarray([[1, 0], [0, 1]])\n", + "\n", + " pauli_dict = {\"X\": X, \"Y\": Y, \"Z\": Z, \"I\": I}\n", + "\n", + " # Two-qubit depolarizing error channel with error rate p_cnot on CNOT-gates\n", + " kraus_operators_cnot = [np.sqrt(1-p_cnot)*np.kron(I,I)]\n", + "\n", + " for a in [\"I\",\"X\",\"Y\",\"Z\"]:\n", + " for b in [\"I\",\"X\",\"Y\",\"Z\"]:\n", + " if not ((a==\"I\") and (b==\"I\")):\n", + " op = np.kron(pauli_dict[a], pauli_dict[b])\n", + " kraus_operators_cnot.append(np.sqrt(p_cnot/15)*op)\n", + "\n", + " cnot_error = QuantumError(noise_ops=kraus_operators_cnot, number_of_qubits=2)\n", + "\n", + " # One-qubit depolarizing error channel with error rate p_u on all single-qubit gates\n", + " kraus_operators_u = [np.sqrt(1-p_u)*I, np.sqrt(p_u/3) * X, np.sqrt(p_u/3) * Y, np.sqrt(p_u/3)*Z]\n", + " u_error = QuantumError(noise_ops=kraus_operators_u, number_of_qubits=1)\n", + "\n", + " # One-qubit depolarizing error channel with error rate p_meas on all measurement gates\n", + " kraus_operators_meas = [np.sqrt(1-p_meas)*I, np.sqrt(p_meas/3) * X, np.sqrt(p_meas/3) * Y, np.sqrt(p_meas/3)*Z]\n", + " meas_error = QuantumError(noise_ops=kraus_operators_meas, number_of_qubits=1)\n", + " \n", + " noise_model = NoiseModel()\n", + " noise_model.add_all_qubit_quantum_error(cnot_error, [\"cx\"])\n", + " noise_model.add_all_qubit_quantum_error(u_error, [\"u2\",\"u3\"])\n", + " noise_model.add_all_qubit_quantum_error(meas_error, [\"measure\"])\n", + " \n", + " return noise_model\n", + "\n", + "p_cnot = 0.01\n", + "p_u = 0.001\n", + "p_meas = 0.05\n", + " \n", + "noise_model = create_depolarizing_error_model(p_cnot, p_u, p_meas)\n", + "\n", + "N_AMP_FACTORS = 7 # -> amplification_factors = [1,3,5,7,9,11,13]\n", + "SHOTS = 1024*8192\n", + "\n", + "qem = ZeroNoiseExtrapolation(qc=qc, exp_val_func=swaptest_exp_val_func, backend=sim_backend,\n", + " exp_val_filter={\"repeatingcnots\": True}, noise_model=noise_model,\n", + " n_amp_factors=N_AMP_FACTORS, shots=SHOTS,\n", + " save_results=True, experiment_name=\"3qswaptest_paulinoisemodel\")\n", + "\n", + "qem.mitigate(verbose=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To examine if this method of noise amplification works as expected, we construct a set of noise models where the noise on CNOT-gates is manually ajusted to be amplified by the same set of noise amplification factors. This is done by setting the error rate on the CNOT-gate to p_r = r * p_0, where r is the amplification factor and p_0 the bare error rate. Noise on single-qubit gates and on measurements is kept the same.\n", + "\n", + "Note that this does not represent an actual feasible method of noise amplification as we \"amplify\" the noise in the very definition of the specific different noise models. But this shall serve as a sanity check for the noise amplification scheme by CNOT repetition. If the scheme amplifies noise as expected we should find the noise amplified expectation value for each amplification factor to align closely with the expectation value found with the corresponding amplified noise model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Amplified exp vals read from file.\n", + "[0.39198685 0.2758348 0.19391012 0.13463688 0.09251571 0.06230164\n", + " 0.04276776]\n" + ] + } + ], + "source": [ + "filename = \"results\" + \"/\" + \"3qswaptest_paulinoisemodel\" + \\\n", + " \"_noisemodelamplification_ampfactors{:}_shots{:}\".format(N_AMP_FACTORS, qem.shots)\n", + "\n", + "data_loaded = False\n", + "\n", + "if os.path.isfile(filename):\n", + " file = open(filename, \"rb\")\n", + " noisemodels_amplified_exp_vals = pickle.load(file)\n", + " file.close()\n", + " \n", + " if noisemodels_amplified_exp_vals is not None:\n", + " print(\"Amplified exp vals read from file.\")\n", + " data_loaded = True\n", + "\n", + "if not data_loaded:\n", + " amplified_noise_models = []\n", + "\n", + " for amplification_factor in qem.noise_amplification_factors:\n", + " p_cnot_amplified = amplification_factor * p_cnot\n", + "\n", + " amplified_noise_models.append(create_depolarizing_error_model(p_cnot_amplified, p_u, p_meas))\n", + "\n", + " noisemodels_amplified_exp_vals = np.zeros(np.shape(amplified_noise_models)[0])\n", + "\n", + " shots, repeats = qem.partition_shots(qem.shots)\n", + "\n", + " for i, nm in enumerate(amplified_noise_models):\n", + " job = execute([qem.qc for i in range(repeats)], sim_backend, shots=shots, noise_model=nm)\n", + " exp_vals_temp,_ = swaptest_exp_val_func(job.result().results)\n", + " noisemodels_amplified_exp_vals[i] = np.average(exp_vals_temp)\n", + " \n", + " file = open(filename, \"wb\")\n", + " pickle.dump(noisemodels_amplified_exp_vals, file)\n", + " file.close()\n", + " print(\"Amplified exp vals written to file.\")\n", + "\n", + "print(noisemodels_amplified_exp_vals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting the noise amplified expectation values against each other, we find exactly what we expected. The noise amplification scheme by CNOT repetition seems to amplify the noise present in CNOT-gates very closely to the desired amplification factor." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = qem.noise_amplification_factors\n", + "y = qem.noise_amplified_exp_vals\n", + "\n", + "plt.xlabel(r\"$r$, noise amplification factor\")\n", + "plt.ylabel(r\"$E_r$, expectation value\")\n", + "\n", + "plt.xticks(x)\n", + "\n", + "plt.plot(x, noisemodels_amplified_exp_vals,'--o', label=\"Noise amplification by adjusted noise model\")\n", + "plt.plot(x, y,'--o', label=\"Noise amplification by CNOT repetition\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the mitigated expectation value, as a function of the number of noise amplification factors used, and we can see a noticable improvement.\n", + "\n", + "From the plot above we observe that the noise amplified expectation values are being slightly over-estimated for the last amplification factors for the repeating CNOTs-method. Correspondingly, we observe that the mitigated expectation value flattens off and fails to improve when including these amplification factors." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_amp_factors = qem.n_amp_factors\n", + "noise_amplified_exp_vals = qem.noise_amplified_exp_vals\n", + "noise_amplification_factors = qem.noise_amplification_factors\n", + "\n", + "mitigated_exp_vals = np.zeros(n_amp_factors)\n", + "mitigated_exp_vals[0] = noise_amplified_exp_vals[0]\n", + "\n", + "for n in range(1, n_amp_factors):\n", + " mitigated_exp_vals[n] = Richardson_extrapolate(noise_amplified_exp_vals[0:n+1], noise_amplification_factors[0:n+1])[0]\n", + " \n", + "x = [i+1 for i in range(n_amp_factors)]\n", + "ideal_exp_val = [0.5 for i in range(n_amp_factors)]\n", + "\n", + "plt.plot(x, ideal_exp_val, '--g')\n", + "plt.plot(x, mitigated_exp_vals, '-o')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zero noise extrapolation, mitigating noise on CNOT-gates, on the SWAP-test circuit. Now on the mock backend FakeAthens that emulates the IBMQ Athens quantum device. This mock backend has the same configurations as the real device, and an noise model that aims to approximate the physical device as closely as possible.\n", + "\n", + "Noise amplification factors = [1,3,5,7,9]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ander\\.conda\\envs\\qcomp\\lib\\site-packages\\qiskit\\providers\\ibmq\\ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n", + " warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n" + ] + } + ], + "source": [ + "#load IBMQ account\n", + "#IBMQ.save_account('Your IBMQ token')\n", + "IBMQ.load_account()\n", + "provider = IBMQ.get_provider(hub=\"ibm-q\")\n", + "\n", + "athens_backend = provider.get_backend(\"ibmq_athens\")\n", + "\n", + "athens_noise_model = NoiseModel.from_backend(athens_backend)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Amplification factor = 1.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.29174495, variance = 0.91477763, total shots executed = 16777216.\n", + "Amplification factor = 3.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.10535479, variance = 0.98877137, total shots executed = 16777216.\n", + "Amplification factor = 5.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.04850841, variance = 0.99752100, total shots executed = 16777216.\n", + "Amplification factor = 7.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.03171182, variance = 0.99887338, total shots executed = 16777216.\n", + "Amplification factor = 9.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.02537715, variance = 0.99923966, total shots executed = 16777216.\n", + "Amplification factor = 11.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.02293003, variance = 0.99935403, total shots executed = 16777216.\n", + "Amplification factor = 13.\n", + "Noise amplified result successfully read from disk.\n", + "Noise amplified exp val = 0.02211404, variance = 0.99939353, total shots executed = 16777216.\n", + "-----\n", + "ERROR MITIGATION DONE\n", + "Bare circuit expectation value: 0.29174495\n", + "Noise amplified expectation values: [0.29174495 0.10535479 0.04850841 0.03171182 0.02537715 0.02293003\n", + " 0.02211404]\n", + "Circuit depths: [ 84 170 256 342 428 514 600]\n", + "-----\n", + "Mitigated expectation value: 0.49105048\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0.4910504779547751" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N_AMP_FACTORS = 7 # -> amplification_factors = [1,3,5,7,9,11,13]\n", + "SHOTS = 2048*8192\n", + "\n", + "qc_transpiled = transpile(qc, athens_backend, optimization_level=3)\n", + "\n", + "qem = ZeroNoiseExtrapolation(qc=qc_transpiled, exp_val_func=swaptest_exp_val_func, backend=sim_backend, \n", + " noise_model = athens_noise_model,\n", + " n_amp_factors=N_AMP_FACTORS, shots=SHOTS,\n", + " save_results=True, experiment_name=\"3qswaptest_ibmqathensnoisemodel\")\n", + "\n", + "qem.mitigate(verbose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For comparisons we run also the zero-noise extrapolation implementation with noise amplification by random Pauli gate-sampling.\n", + "\n", + "While the repeating CNOT-method requires odd noise amplificaiton factors (1, 3, 5, ..., 2n-1), the random Pauli-method seems to work best with powers of two (1, 2, 4, ..., 2^(n-1))." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sanity checks passed\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r4 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32 ' successfully read from disk\n", + "Result for job ' 3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64 ' successfully read from disk\n", + "[0.46603722]\n" + ] + } + ], + "source": [ + "two_qubit_error_map = get_cx_error_map(athens_backend)\n", + "athens_basis_gates = athens_noise_model.basis_gates\n", + "\n", + "# we take the same transpiled circuit as used before, because there is some randomness involved in the transpilation\n", + "qc_transpiled = qem.qc\n", + "\n", + "n_amp_factors = qem.n_amp_factors\n", + "\n", + "# amplification factors as multiples of 2 seems to give better results for this method\n", + "amplification_factors_powersoftwo = [2**i for i in range(n_amp_factors)]\n", + "\n", + "R,E_dict,E_av_dict,\\\n", + "max_depth_dict,mean_depth_dict,\\\n", + "max_depth_transpiled_dict,mean_depth_transpiled_dict,\\\n", + "bn= mitigate(qc_transpiled, amplification_factors_powersoftwo,\\\n", + " swaptest_exp_val_func,\\\n", + " sim_backend, \\\n", + " \"3qswaptest_ibmqathens\", two_qubit_error_map,\\\n", + " 8192, 2048,\\\n", + " athens_backend,\\\n", + " athens_noise_model,\\\n", + " athens_basis_gates,\\\n", + " paulitwirling=False\n", + " )\n", + "\n", + "print(R[-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the mitigated expectation values as a function of the number of amplification factors used for both methods. We observe from the below plot that the repeating CNOTs-method converges a lot closer to the ideal expectation value than the random Pauli-method.\n", + "\n", + "The random Pauli-method relies on approximating the quantum noise as a two-qubit depolarizing noise model. Optionally, doing a pauli-twirling before applying this assumption. The repeating CNOTs-method have no such assumptions about the character of the quantum noise. Thus, we might expected the latter to work better for general noise models, and exp" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CNOT repetition, mitigated exp vals: [0.29174495 0.38494003 0.43351895 0.46148582 0.4778664 0.48694545\n", + " 0.49105048]\n", + "Random pauli gates, mitigated exp vals: [0.29193199 0.40144479 0.44075068 0.45646464 0.4634236 0.46669605\n", + " 0.46603722]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Process results from ZNE with noise amplification by CNOT repetition:\n", + "n_amp_factors = qem.n_amp_factors\n", + "noise_amplified_exp_vals = qem.noise_amplified_exp_vals\n", + "noise_amplification_factors = qem.noise_amplification_factors\n", + "\n", + "mitigated_exp_vals = np.zeros(n_amp_factors)\n", + "mitigated_exp_vals[0] = noise_amplified_exp_vals[0]\n", + "\n", + "for n in range(1, n_amp_factors):\n", + " mitigated_exp_vals[n] = Richardson_extrapolate(noise_amplified_exp_vals[0:n+1], noise_amplification_factors[0:n+1])[0]\n", + " \n", + "print(\"CNOT repetition, mitigated exp vals:\", mitigated_exp_vals)\n", + "\n", + "# Process results from ZNE with noise amplification by random pauli gates:\n", + "noise_amplified_exp_vals_randompauliamplification = np.zeros(N_AMP_FACTORS)\n", + "mitigated_exp_vals_randompauliamplification = np.zeros(N_AMP_FACTORS)\n", + "for i,r in enumerate(amplification_factors_powersoftwo):\n", + " noise_amplified_exp_vals_randompauliamplification[i] = E_av_dict[bn + \"_r{:}\".format(r)][-1]\n", + "\n", + "mitigated_exp_vals_randompauliamplification[0] = noise_amplified_exp_vals_randompauliamplification[0]\n", + "\n", + "for i in range(1, N_AMP_FACTORS):\n", + " mitigated_exp_vals_randompauliamplification[i] = Richardson_extrapolate(noise_amplified_exp_vals_randompauliamplification[0:i+1],\n", + " np.asarray(amplification_factors_powersoftwo[0:i+1]))[0]\n", + "\n", + "\n", + "print(\"Random pauli gates, mitigated exp vals:\", mitigated_exp_vals_randompauliamplification)\n", + " \n", + "# Plotting\n", + "x = [i+1 for i in range(N_AMP_FACTORS)]\n", + "\n", + "plt.xlabel(\"Number of amplification factors included\")\n", + "plt.ylabel(\"Mitigated expectation values\")\n", + "\n", + "plt.plot(x, mitigated_exp_vals, \"--o\", label=\"Noise amplification by CNOT repetition\")\n", + "plt.plot(x, mitigated_exp_vals_randompauliamplification, \"--o\", label=\"Noise amplification by random pauli gates\")\n", + "plt.plot(x, [0.5 for i in range(len(x))], \"--\", label=\"Ideal\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Qiskit version:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'qiskit-terra': '0.16.0',\n", + " 'qiskit-aer': '0.6.1',\n", + " 'qiskit-ignis': '0.4.0',\n", + " 'qiskit-ibmq-provider': '0.8.0',\n", + " 'qiskit-aqua': '0.7.5',\n", + " 'qiskit': '0.23.0'}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qiskit.__qiskit_version__" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/5qubit GHZ state.ipynb b/5qubit GHZ state.ipynb index 89745ef..45553b0 100644 --- a/5qubit GHZ state.ipynb +++ b/5qubit GHZ state.ipynb @@ -435,7 +435,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.3" } }, "nbformat": 4, diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_circuit_depth new file mode 100644 index 0000000..3ca9062 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_circuit_depth @@ -0,0 +1 @@ +84 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_transpiled_circuit_depth new file mode 100644 index 0000000..c954f9c --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.max_transpiled_circuit_depth @@ -0,0 +1 @@ +394 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_circuit_depth new file mode 100644 index 0000000..219dd62 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_circuit_depth @@ -0,0 +1 @@ +84.0 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_transpiled_circuit_depth new file mode 100644 index 0000000..7ba3f31 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +394.0 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r1.result new file mode 100644 index 0000000000000000000000000000000000000000..569c24b2499c693e4d5ca60a825849471828d32c GIT binary patch literal 1117441 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� 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 oWE!OV literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_circuit_depth new file mode 100644 index 0000000..105d7d9 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_circuit_depth @@ -0,0 +1 @@ +100 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_transpiled_circuit_depth new file mode 100644 index 0000000..4754f24 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.max_transpiled_circuit_depth @@ -0,0 +1 @@ +461 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_circuit_depth new file mode 100644 index 0000000..1b1beb1 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_circuit_depth @@ -0,0 +1 @@ +90.49951171875 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_transpiled_circuit_depth new file mode 100644 index 0000000..9eeb823 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +418.64501953125 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r16.result new file mode 100644 index 0000000000000000000000000000000000000000..60c4cf268f3d267635fa70280899df7be6979c37 GIT binary patch literal 1120605 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
x6Z<2(HXIP?=_|r9ucP<8Wj z+ji~J&S?2tm- zA)G=(+^*`HRjvkgBIcHg5j!unqKc5&pjS=A)2mu<13W<|gjJEYtJ30np6ww*&z5Fq3;7D8-y0kY5u;T7b~>ZtsGPQoc7 zPwko|{OUp#BlQ3y*YPl7efN#L?@Z))fw);c>*odUfH%*5vGUypx~3)G0y{=(W7#oc z+jsT`Jw;R+;$}5&XS4B8oiWc8+a7KBj;aiK3AQ(v#j?HG(N{E_T1DEdN)=aigipNk znA~UIe>S6v5Iv|eBk)ui>#W3Q=oz9>68EY<{!QSa43Xz&wJF|-t~-g103nyL5Mr}t z=(mYDfg|lzbxf_BD>vKqs)Mgz8s2#lRVfk&yjdz1Z)PZP{Lm+jGkS`M3gTvU%A4iw zpcFCPxp3`lvYskJFsF$Ag8%GRPcj`KL?CTebxdBl*YDvJF}GOgIjz!Esu<}BD$Qmr zmBx0Sd56r1QlTd8R;9AZVX<(EIG36FDQ5^(gye%0uLqVBZ|bV-oG#nY=SC=56=}1o zW46h{Q8-29t8RBc%%iIp!F_8rci)_aIdjlcgj14ttL{C88+MFbPk+2_`xB~i~8qfYf^jf9=V0Cd(A~bFY*yfFJk+K*BG4;UP0Wgnw#kD zCP&Pzd#l927^*U)D>(C-v7CAJ*0}&-4iF*`cdI*>wDEn{Qw4! zfCI||(C>;URcg|1RmZ#?+w-DbC$e_OuGH>BsbZuMxV8Ej&#hI*HUx-DwTir5<$nA+ zV8_U>3W@or!l+`T6ky~n7DiI9eBJ%o=Qet!(I|=A)dB5i`9PJ%)N;s|ff)v>2x$ts z)niz?Rof<-E9is>EP1=y-|fc*I7PDit2g^-Jg8zM2&BjgJSp-}w{zv7j}9;*61S^$ z>pm5s6ftkRIcJjmm?}agLLL8h2z_UDYvsy7n zj)MtVUfB>Z@iSF~>;T{JBrMOa*UWQD(q>i1w8?Q#f_qi7+kvJb7wOtF zvIwL|IGz--&cVBkUT2gnX}79l+77+86lTO!vr(`773oyv23T);0}xUW3n8{G&S~g`XgJbtRmU_qd)aOmjVX3vtMk*IQW+`jwV@P|lj6BLIlHMMWH9JgGx7AR*4ZNHw-R|lByLw{(Y2Qs^Rz$r3g#Ip5gN>fG10+1rZv80G?DnM;?LRg-(U6qdP888GQWUI^D%t9Mi zQ$>gyxGVA%%Uu!MdtN7WLO71JTh%f17S^8&TM_d^x4eX90#%H}gA|#AB}McOzOzy( zS@L%Eo6p+oFe9cOt;!@Yv#DZa5Xg~LSaQVnjiw-ajwnU)c6D;eD`#OwWasV0hpg#N z6(g(4|J_zJ$PLG~BE5Ca*&%dBcnxX0s$*i7m~X<2m^0c{%RNljyKgU0YwlyLHM7wf zQK?A#RVku@u{hMRnu^3MKULJ3suXDh2-%N^5bL+zd~`z8JaM}k>sG!lM2NiCm{w~E zU8mlT;7-vlEO&}*vm>UU6Qbcr+f~aqnu=c8aGfy~-28Z>Sc|F@VL^(V!;>P`DMf41 z84(nu{i^h2^tQ5aiX5oZ@^(ax|M7$@V4Mm#{rQpN5gQyA92u#N42%ztNr*T46-X)b zpI=G{PS6G>#)esbGWwNBOboB!@8lI;F*&?acopjgmT<2>3s_tfqZLN~P!J~>SmH!q zJuvH|yVe0zMADj7$86wNKDCPz*It{iwP^W29+v-3Mq)vn81Tf2bwq$=%}|s!Dkg4B zV0`3Xrro0ht(%7|fHNrtql2Tg#uSgxh`7+ihy;NZRicKpXw@;?jf59=jC?BWysK4h zsu&3cjAUS8#5QOI{c@37p(3qXrDMCi2SFvr^h%+vu{fD3LTUg)?qVTCzr2uf@t{`7 zDWYb1(xO$WFohio5h6d`_G|fO6IFy@UZ7|ju9<;O2*;7utkSyT2D`&=?;o?TiF7T; zs|rN?Lo6ab^+fnS{|b5Ngji;45?-IEW4L2KYs8pmit5mSEX%yV8Ztv3V=qr{gLP`Ka-s2&}GqZWZ zuFLmELDtD2c5`0Je`Q6-KwAQa^M0aY4vSeL=QlYdIXhg@gi=KA({TF1<8)mx>X041y~L=q}{6YJFN`- zl~=x8+!1d$qn)Wk>|@W()Cn zGwV8uk`53ekT$D2=1KedDe#GRtLOfobri3uVx%)*WIGl{Y+7!-#|4Orv3mo7H!z%`{M*F-L!4 z0{7DOthWIm$Z5ftRj>g5Wnr^6{??wT7q;$RR}DYDb;uUYL>9*bGEKH7YV zUTFk@v{}_LkRgZhWQc<= zXarVC+^uGAx@dPNvEx2Ap==MT2pI#u;LXJI1jA(h$xNv+7>< zo%G*S5wZag(iaOMwwv$h>%Ij}ByLvMjvWIJ=QWjYIxGCdTdD{VKp%1(OCMsp`Th$% zLzDt(v#Miey9L~XPrRn$9peHQ(RCwH13HltcsdaWM|=ysnzUP$=AIcd5$aXtN2w-u z_I#>RL<(eCxpVa#QJAYlV9rfOSYwCORQ%C26xN zxpVDep$svv`F$f|eru{Sq#Ec%9^mOjtgA*G=v6Hj5{bX|cDm`b$F39MwITh(8&bu{ zGcb0w0+z9>soytk{gmm2o+1{pN}Q3wV>hgU8Ih;YiLbcf994|;1HH(4EWL=qy`=BS zj)l+}5j4cjYR?J3nnRUFj>v!bph!om2?|hn|6C$cfn^hh2hHIK; zmm-sIE90v4qKc88z?^NyV$KYF(VZCw`yn$TDtO{<^>O&sL?}hf(vCZ$TKu4jklKKd zTX+abaaq@P^G9?-SdO?`%?+vB7$U^<=~ADbCpJ+<$o}GgZ;G@jf#s%%b@ACKbV4|m zv|E*0HacDoB1Aset3|tPy3DEwI*~j)orv|G$Sns55lNd>9dq;Fy-9YRh$(Q(zLu#} zrHCi+BCoM{5xs*mBSfW!xLfsB-W&s^hOuiZSc2VD~*5&rMip;ZwlQ5B6H9_h^A1m?u}*A8J@s00M5!TdS9Q#w z*_CxLBj%7jg~n|-N>z?ve$DIHh7k)Ryo$JAH7RCyhR!td)gAqpOzuP#A>YAm5eCa` z5kppV^=OxR=#@sLB=1*wx1zh@6v-}jscyi7DpWCo`R1yj{Zqbj{%CYY)EsHQs$)4QuVNe(j+Y*?Rf1v!C)7RfOQa zyXw#kD^9^$)Cl2TL^@Zfmpep=$!*ct?De@+5poRN2WX1tK7e&UKt<#XVOfs6UtR0` z?Uh}f$qyfTe2AJVMoNQj^$nJ8)zMS01rgGIRf->9qa>6fTPwLQaZapF6(NlPA(ycb zqR-toXJHQNE-Oo&;RND#b=A>=N{A5CbFZiM7tlqB0uXW@4KHwwcZ6(K``dMcS=O6FN1h2xmy2+tb%2bfJonrGOAE z9zxuko0jJa=!B@0q|K_-<6mPZm=KS3A@Y|bst8enDsu);mHF&6t)<@!bVAfDaj)u| zbt)Jl#2g8IwzlS0}$!R58*HFtQg5Bl=wp^>0?jqcg(u#NBGCRUgYhDI(wd zRp867Y5$)P@A^HA6O5L3FQJhk5eb2j!6Dknc;g_;U-iP3eok78ln#y44h@Wt7_0ry zuNScVdeNbgF(JW`fwAGi@mgbtLpDOjq7$N0l6I>)W^LnJi|tb6)5-j6U+LQL-3gep zop{XIvO6_%9+X07M9q@6tJ0Mn*FxbGxn+*5s_slxiWCEc{DX%O|HfPMU8Xreh)CS6 z)?2@DEKJD4UF8csEI<_@bwDR_6H6yzu-;iMgHDJ>An#W7Yxos#osskAU8pzSiz-H% z0Y-AMFrv5K6;YuxBB+VG)v2WlYTy*vU83)h@}X1_!ht$-7E7JcTeoVW-+bpRW1C68 zjcA?m8Q!XCs_^!JzH&HKgkZi2V0&M+2{}WQ3XZs04SqL149XC5^V;8=`8}YDkVxR( zjab~fZQkkubV4l8XGmwr`Nm&|L4=ro{4CpYJ6-qQn}a?i2TLDf7}9M^`wrV3AVef> zR;A~@V|^e(WMkck3%&BG$`H&iBOHCjtK>Aqy=vp{|H88XOxpwBPVm}K6(Pexm05tL z%Gfq)7DdkxrJA%?m5NrmQV7bBt=SVVM*TaHDnfdLDwBn$%2=m*hoTe0^Te&{t~w1y zL4=rkb@GlKH=im((m;mb*->P$dUteZrc`mHt*VZ3-H`JS?96ujleop%br@BQYzDIc zdg8hHZrxI(K~E7iOWLbSHCE*{gi=Jl+-cGIcE6}1#2q-ZFIb$JZMK=a1B8ggt*TE( zt6nf6n`=A@xK@-ZLe_##q(7EUB=ySI-JgAKpcA6e5Vxw+qDMzTgls(S$UrC{axsU2rAN6RmYUuw(Az$iEJIdQaEXObm|_ZO$ZJPP6)PMr*R#U7#|T6 zZT)+<;Mmy62yK{gR!Wi3nD~UiA;F;uF>%HYzCTX?`Ee$tL{#wTK+EsYh6RpDv|Pi9 zH~KlJxLW?e@R%@Tid%eQtTrwt)|gT#Av{hSA087KX7nqZX!&j0;P}KiZD4$Gl;z(L zJ=B=|pWo#Xrj3q|NEj0s6`T+kG1{2o5gQyA92u#N47B_SfBqE(Qp)`2mlA>#w1J7S zmj3{)(XT{eVt56AC$I2|$>Ej4tJF`j{C9+V{kbOOq8P0(`mY7uYJV&zUj3LpOP73h zMrTCiNqbctvtaDPXD}o3@rMJG3iqXokusncd4;DJacE;Ar{EPFakE--%JwuovMu4QaQkW13EXW0xZ4@#~Kl zKITmoBOky!&Ei6lDy{oA9iGH15BZTgVAQ`<5t0B>Bn3~3SSRsz zLMMdhiM!S7v-=l@>WrK{Bd`JILKPv?03qYC5MncDx6uhvam3x~jxEU|M2PtnpLRbf zn<_$bL9f~jORs7Oa&Iz1y&9bmwSu%;)iI$r8f=2kGue?9Z}~4SK@}rI03%DVFk+j; zo9qB10%^M{xqRcBLn&hNYS1eG#X_nG!Mzh8h+olu>veQOG#b)wRm#ZrZVeNnERbE~ z$up`584ogK8kP((SnmO-(FqY$#La4>HwVYTgmlTB#YXC=A_Viick9dcGY0GIs#?g5s4UZ~2)~WcF*j>mw40-8Ue#Kk zmwbpSMv4JO{=veCZDPbobVgVOX}2n6T;Dtit~3w39Wiip-2^xWdXc7BdJ#u&oT*rW zxLJ)U@eG~@u(jOAmZp;eRT(lB5HbM^A&$Pmvs`Q@ZB}&*6W{nM+>4miiyG?1=y?-THyw-T1`ytZxx{Ux4C z#gewGmN|)s#p^I5<_WRUb!*eLxmf_U<~W{OW3^}KTZ&X_1#!RnrtA)QCV=_q=(gED zJE^KPnD;h2IzS^)aP zO|^n0E?T$u`3zrB+*ayKgO2N;Qk5aNFF9KWz>i1H5X*D`(xO%Bxk*(5YFl@Nrya4} z44{gTDxhtBgr#jYw9Lrv@L+@kgb1WHt8^{ppb8?yH0oI4rmwYB5fTjunTLfC+e3-x z=!9@;@{%>G)b=}ez3RR(i{g6F^_b>7=tLBFIuYx-qAYYqlstLKn!Y%AEzF3y7PIJ> zimq<;ArSFZv50v6%a|Ey^)I3`!YfHjRvoh<`rZLMMtXcX)vw=7s%lMnaOQoE<;?5o zfN!;mC9PR?OwGjxyXA?ds*5}NIIE~)WEJQ~2I1*Pa`(+yn1lXYLah?Xi`LmeN9Myh zVk+3v?^-ln*Wm{NMpofr#KDUJYPCS#uZ}*T{cgvIa@yRJi+ridktTqV3wRiDaNUSn zqbBZGpFc7t!YAL;h9NKCucnHS%7Bo^cnE2lw60@kBYMXw@TC2!j=AvG^F5p*^1ms& zced|I6(eSF^6iS{{4!-6ISia`j z7CM(hXGF!4HmuUVmOGn3XBzoP;R~-S9HfenU0^j$M=Yyp^w#l-?HwRQB<@$8PP|Bf z2r-M#ru5&njVeOsgH9w0ODCfDe!pQ^gGuOws5RvMsx;*4SGdlYidH<7xHge0Mh1ct z&1yU+n#iLW?=Pd@KC|qmA@5i3bSi7ti7QYAV>CL$q~c!z4cpM*yz{pKJjCkh?$G3DwW<*dZ$Q#z?!-nZ#MobHSxvZVAg{mCs0T|hWg%R7x@4F5# zB9b?(S9iY5gc&i%?k_N5%M_{@DG0vi{lM}y&(RTi0;?fySanPR{gP`iBc_u5m-co4 zP8A~)K#okslOy}C9mxDFqvr^xBJEhEvA6E|LUzQoa?aETD`Tl5WDy`F919@^Yd6vj zoe(8Y+_1j*bh{-?NXei5re7*e6(MQm|K2Ma=7!~7k%ME41fC;pSar~gQr`yuH1Z$ zUT0JyX~QbHE%*wrQHs3<(Fl>LM(?s@^(@<_bC?8WnlFI{Ev1yH3OubpCsj9qXuKq$ObF5FSRX@4qjj zGa@L-+tpJeeC+LNQI|GJfpi)8j)0L}co?zHk=TIFh{%z*t9|oMJ%mp*=GomE>^ZQR zsvPMH7}RHodF};u`r^y=EzzH7!gR@ zRUP9yV8;hLMwH1p$&;g~Vx%89)vU*Js(N^c>+-_zkPJUbsvBB;y2Qy>M5{|D<@tYqep4@exspk--Tu zaYjk5|Wk1B3{q9jo-T>YJ(%A*Oc4 zFV6}vQAG&mQ?G4hUSD)V)N0a(RVsZmMS=+_ZJx8KHeJ0c=I=DA6P-_X^G9D3FKSfe z{c5k$rw-cns!raWBeZnA?DYk8<}jW*W1S(<2t7pvC3(NfzwkK=Ga_F-b1gNGu3PZl z;LgY;EO$n1i{h)JGa|C2{i?KZtYCK|K;8b)%WAn)^&+i6iX6m~B38SK{NBp4cSJ$n zu5MhMZa3{)zS>lIJz*tPjMM~-+`+?0&sCY}hP|jMVqrwUZ&&}%ZdJ#;9Qa{BTxrZz zR$dr6X*X4j7{OPXNGxAzQmtFij-oTds!7{bX_bCSGx$tXq>SsAR>!C!q$fy`%~(>z zcIpj4CxlaxcB?vOZo->|aEh27ZgziI=K@uXlmU#q!orB&I>~u1IwMLYal6`BEKmwc z5m|coyno&qstBnI>dXx+b;dT&$`hRso+WNqL&G}oFd?JnTrK-$7*&MK0vR$2Plh=5 zg@#q|B5Av-V?5lQFWJ?Z88w#{-y293BiliWbjFe*4t~XB6)J(WUzM`Xe-4CF#B{dM zqb-I^st7p;zVotpzVlk=S-nTEGio(?ySo2(ZTm^zT8~ll+^$f?NEoOz>3AxQW3Opg zg@z|?R~PMK$3ZD#-t#3je`FR_gcJdUe8NMBWBaXGg`gyDSEWk-szyMBm?{;^oRnXm zDnbSWLNc)s;_!J!WXZeLW|e3&iFm3QSpygufQ1p;OPUGjy@)6hcdMmJ zKWqf0h}`4Y$Ppvy+Wmb3oM$w6&NGhPIb$t_hP+!H^)=P*J)Y_A;lo$YO{XeFYJ(KH zg(XD{k&C@6^+W%P$FgeDZdJ#O@3O{j`l@Mb@`UH14XI+JKDaM(4aZ)xY8`%QLV^eXQ~KE1eInso=UT;q5jRv(ddLIIns7jY82$t7AE9UqmaRi zUrb+N)gks=QEp+oJv)S_y9tVVj)CtHD_Vygs3#c-Rk+d$^I}Qqdgj@ zy>3YrAz#238h1QjXsmnTo1znWiEMQ)<~8P@B2+Ol3#7;>EGc5BJ8t(s8NTQ#B5=grYF6)9_&j4O z^Jcxrx=^YJnE_6`WAU7L9eg3diY$4zTEG0~Z*YppBXg&Wi+My9BTB%?87zz#3LHQ5 zN#l&3BBDsztx5}BYn6a{k*%#f4!A$2>n6Zgu!q$R&mLCmgrZ<%LO6wnxLJ+((WMwf zi2Qy3I4_p2ZO*vou3F9NNOVG26=}1oWAe7$w%b@Fr_D)R_B@rUI)gby^p3sxW;u>0 z?^avnmAw!5A|~HM_nS=iqKc8-pwe`}Qfc%T{Aag%vI0FvlpJZds$(8-np8VR%JnM} zaJ~;!jHrNJJ%z=t8isV+(!K-oRx8VAUIlTxT2<*%1nx$jow-@sm9D9)U4c6@<8f!! ztyW#oQ-l{u+f^M?{KdR0_9>FDEqao!y;hi~z&kiCk>ykx@_yC1PVr=z5&3D<%p=#5 zsH!wPFe9h&m=UXk7twP>ts?GMQ{OL)hAYkG#)s}?wW5lUKtRY!EQHwJ;z{U)Xn4|o zRZ5+8coam4iSfPpAY=wrgj5IJ>ODN&YRio54i6&H2@yErcJ*6^cWa0cbFuo{8^_Xh zp258B+jgHQ2AvR5LE5hBm`NLJEr&Z1)BPp)Uhc@DDn(v{Ev%kcwy-+-iiQ&f@_tqM zw8tTs5jpHxVeNJURgAO)m1ZxNN@Me@EOL%06&mt>^-+b)EifadI}H!69A1qoMlipl zaWqGitctu}U6p=mnjIrz__ctyv#4TZ7|4+{JUQav#6%^hB<@#V4zJS!?pRlNrT5+a zohm{YK*)D2gcx!Sm5+4jhhAxv9C^PwaL)p}yNTvX5AIwoMAs{cS-^~p!eT}ooC41( zc?D^|D!HC3S{h0b`DjGLX1SZFN)g<>NZ9?eKMEB`PZ3@qZdV6h92)`=VyYVa^6IMM zR1s1ce8+o?uk)iF79s?E0RR%^#i?pAp;RgClnb!G#WI^*D0cvh)a z5%;Ty)83ASQbgWS$mjXv0aOvfffPB5Cq zzNLzh0C1vNhv!7&Uefnu$71M=2rOy8Dos3crzDgjrUq(0CcZaSgmedl$XEz*aN9Sl z6cyy{>h+wJ|H3IEKU`C^1Eq-kqEBqs zDv4APB7zjj!;&JlomO7RgzySAX}79l{O)zw38#oDV`Ro_4>MJau%KT(hoxV&%{tqO z&Iqd_Z&w!`@qP<4Vjfgtd{^cRRg7eSm*1gSUViJXXPS!WjBrZgcGd66ohneJG5^jt zx^AUw27FzRA~&$4Na~0Yr`I+_-k!+vN|v-;)iJsKH)X>qVrugCmS<`ss#0V&=tdH; zbR+uQeRCG(B%`MYuORJLrTdfHyFe+jwfp*rma4H-5h4LXcHkkzIzQr-1B3{q?W&Hs zaVYu`oFeiqSHJkBH>hGH8=QLmu$+2R7uGtudhT#^MpSCjepSi~8#xJ1k*uz(rxsXG z6(OmBkT@)a*e3I$&w%IEJZZbCV_t|UYv2?yt=K=dQ(RN37+DV(>4%4rJ9m>`yB$JL z5si|xUzLK2mVvi@%U@lejXm>&Dnj}JLe}FU#JVQ{eNGWCu*B`ESNPgOP@OS3*UE@) z8cP)+Z@~13(paWP*v`Cl&@)63N!wLvYvoU{6_Mi$-t6D25LJXM1Q`;6B|{9>Nme1~ zgopxpx9aty?Ps_Xk@q!zcWwT8su)QEXWmIz&b+p%n$3|JQ7P2K-D<6vSP!Vq$O~_* z`C5~%`65$5icG|kBDOkH3!M;_C+$|H5lL%D!i0Rv4=UI>jj9Z31Ty3@mJD%p7mbQj z5;v={->=xsC^}j&DaI*+Dngoq?=#1+e4nx1C(1(45G706tV$K7GRy`_^qt z6(P9YyY=?_TL%acNqbctGx>RwpKz~ga+=+;>6C3$F_H^9k!Dyr5xw=T<^gm@cnxW@ zDtXMkIRs9T9~h`Gn|`vrIY zOBEqgL9aRiPp|5Ec1x$H{^*3LdE#F6cJ=lV5FsW*lQ}8vs!&D9Fi>UE@Kl-Qg^Y^_ zbwVdZ!;$u?I%Y=GsO$f=6IsAG6>$3Vql2$mu}bxA4qf_eCKy#T2Fs`-N5@&I1eUa7 zm7L4?*)9A|miF!2-kqvAi2wy>A)bQc;PNw-AQBg>iDjq5>+#G!?dvw&|B)&}K7#Ab zMX_9OHuN0D=6R-~7aUPTT(F*dde;YTNxscmHs%st%f4HHmgESQmc-HP&1!|3xM1yb zd|OeN5YJXu!)mvsDnpusgKrL&gRgCs#2VxbQCqIS8&e98h|>-YjE@+rjW-Um{8ca9 z*N@R!Rv?W?42ehxj0_IZM*jIH^=$vhNo)JLz~7&p|NiXq_veCIZDL4xhm?YCyLM@3 zwEV40{UqZA%b)6M`JWVzc&#?f@-K@@j0{eQi8Jb$OLfe9|7+9Q!PitF$=q%xT}w6} zf;v+bOP#SXvL2lgjw7vDC2h{&4seQ`thvT(M*vkRQXKTEAF%YQ1_xJ3sFe!hg4NJ) zr=1)r+ic2E|2I?-g890Lqa!udN|Cf+)iE>c6ib8ajQqZM-p6WmJ=bJGik!oeB6{o9 zRX6lH!)r(@RvmM0*P2x@Bc^t5KQI3MfvOzo4^A{|v7BgZ|=bh6O?$?PbLM;1=T@<5P zqyKFzmBx0#ITW1`4M*Iq?l~J#2|Cfp-wt2Q$g4vYAtOPC=?AF9{zwCF>h`=qEmUg#=zr#aAh4Iu@{{YrGm6!mFiV8 z^?^?{TSpcev52m3y>CIKDTSxfIJnkIqZCN{Rms23!XTIs*QcvJhSD`MQ3>kI87y_i z5OC0xUVAZmhVUBFc2&pJ4?dR!*BLoK+qm+PCsn-&?q$7>GNMwE_NzL^ssE8TFeBS9 zrOte_Jc}wu8UZ(Q8H*c9JrTaozd{~*j;NKS4XchBn&LDEW<);PeM`p)9jIbtG^jPn zcxuhb>q{5*L;p^r(QxD)>x(jP&e}2JCnb5$D@+w5X7Ht^E1oYk^G2t=^Wo8RL{N}+ ztkS8`of|?OtDJC#9l2yKRfPBfLbCA?;^25*jUbRVtWvMdDg9wWqHC=>j;hyd!$ zaV&MlHXy(OFCwZ*`&B7>MyEj#A?C=3NfDo4QALO!AS4?PA=WCRLas7`LPgrHO1FzH zg@?eKJ^y8;TFW3Kl|a1HQx231O9_-KvfWxi$S0+^d@A=Nq!NccF@rQJ@o< zg{2d*EiKxI&IrenwyQd3cl0$GX2jf7=R0f4DXJLJfE+o2B}eoQ-Ukqr3i5t+-SSP# zU`FJ-)svs*yrYVdu7D9U9!9L)2#cO0N`bUrmA;)QT^;II<;?@$HV>rhR#7G(WH1&& z3}YHJI6C$`Iw8E8yj=}2mpKKeh$;QciH$b~QI#Uq0VDUYFye5fQK`t=RVF%Q8qA1! z(DXN+!{~Z%)e&cbk*Zb40BqZdX0cC8MEAV>;wjw%QN62IHv!A*ZkqqPNZ| za=?seSkiV?$CO;xDFaRs`AXRi!>ZHOjr0MGY{bHdp}_G&pVYt6Q$!<@_N$iFR?MAe zc8nwxdwaELNvgV$$$*i`SQya<@hjSIb)aJv1k#38$CO__axu(^sr%guwTIC)@$8q| z-*=nNe@fRuhtmU%&iL*Y3>O1}bs<_Haq zj0p*j42%sAj@KGH9I`QT9X&@xHF?L{zug9-9V2TdO@6U_I8`~)59G*tEIE?8@7jUP z&zq1L5fwan$9h`m^UIEr<9puq+DTWfDF+yNfrSxA*Gh=2lDuO*`F`p?m=XEqkfwR# z8&Z`c!GMwFco^B$Q2%D-Nc0@xSkjJF$5flUY%9!&$!kN-wvG#_V&n%{rC1QlDn zr+npnM;H-FTUM!6tqDn^1pj;z3vBdPByW&2HbM`uLMk$0@m+jY^y zjK~{a#C){b~ZrU+o3_Z7vtw-5CI z4lp8;cC1p^+3E1zBD3V*u;I^astBnJ2ziW$5bF)aXXu0o8uEtqa;b-QukuXq&pqhX zhOV2=H^CfqY*#TBqd0B&sUS0>H>{Jd9Z96=kDV8cxA-r2VRn`L?m=3YZad z3C;BNe#NL_~P{wR2SKUIX>0$!vx7B6DE!Fmgw5H&~Ku8xea zG!i1jT&KraufC~N5wa9i87-D7V@PpX*LL%JbV4)=@^+P(;B*`ARZUeQGJ4EDKouij zK#I8INfGPa#L*5gB9gYNmid}xe%NoyYkK!I_F)|F~NE((L(OYkxwMS<}(2)15 z?OyiTZI>fW&6~2XmY|A}SkSK;u=J~jo}<`2&s20qL=|bjDqXKr8a~m;M-N4m^qEH$ zArnE0Ou>^P9ZIdvk4C;RVsWcHdAqt;3cYWaB1QI{UY-1aDn=FpMk4Sq;@AyVj%7LW zc6Fhb_5#d^xnRw4P5kJZwa} zIZ_4W$RjK{VtDi|?NvJR1|yE;1k!$0$0Qfseg$SkUZ3zw&Uj80BjZ8GIt@$5s;?fH z_0c^9Jx7!p(uP&X5lf}9&5?ME&IrqrHmuTzkDgvoikMtZ4O!}&LKPwPfjhf~$DQ#- zcV-;yk4}i?J&iG?@CbO0r>`ILXO8EH#Q!q+v)-T4pT3sSpSGV1{QcSa@6RrOe=exi zCWeG}NGaI1YnOIL%ip@xPx>=SG~CtlKPevZT5VWhd_+`YWN<=EoKd>?zD+5J5V?-CbMF*hbfjJlr$S9PLDuYVvNi%=gzj z;7-KsStVCpyAM?<5(YYvbS#~SgIfbQj#rU(t2*ZD^Oz%cjMN>r-gCwZsu(#5UiPZ- zyzIT;KfBeF73h^lr6g@vbWDn@F6e)TSve%0X|QM07|s`O)7 zu`swBad|w~!<0c4Ay0uhtBA*(^<0&iZpcAT5siYhU6sxmmj*zD$oD7T-D$c_6(JQt zhCIcSAy)s6e(#La2*lm$@2AJ$iD#xFa!{7fRH_IG1l{UNEZu7Am9M)$``km%5J64e zt#;e8!2U+j)k`~0-AJa2ktE>XC*kq$)|V1%(HRkW;%+tM{do?mGv8+{mb6+JzNKs>`4_PYQV@zJd8|#wzyq|%E&3AWLeU7 zRmUXGm}fWf%v7R8`Ej4=y1Uv9Fk-^Oh;1k91P2%qN&8i)(v~^!T>z77!P>v0DZ7^l zdXartdJ%(1z=7of=(n4doIu*HO8LF3c7S^kzk?t0Kf6#>XNCbn((n-C*hW@PsZ^79 ztCOXGOR!rt?;QD!3tB@JBlSU@xrU|A7@GE0$DI#FuQNPP+^xQ2r@2EZA}2j~{cZ|f zDN+TPvqyN$ne{bZAUYu`C2_Y}KfYg0n2>GrB5Io4smhR5pw0}!SZ98r6QX8`yVc#= z*3BS7OfI>mWsB(A4c`S+nXOo=jBQR4`YS7?S|sgOrK>(>1|r0491y7qqHFt^Ga%#_ z9zv{};n8O%Dm5D7X7yUha+P30uFpBur1>qXs!TyZ$PX-p%&k1LXoL#=Ub9kAlQyeT zVmeb7BE(e2wfYoA9#w>N0EFzuLWth;?3PYXyP@|XB2U_@O0K1cmxKxN(A{alm#2!5 zX`oXbkEc_$zV_~lObD;wNLy7MvrK9>6E-69YxecSvUGXX?%=#D<2mnI=dPlgcb;X5 zd)0L3PcR{7^{o1ZiXEdWMNFX1bi-0-3~>*#-bdu3rwA*O_NvmpEjRl>bw|6e7gbs?qze7wJ0hV%|h!+rVmhH5a9giisN& z7#|sv5O4G=km4R4Xnja$`9Dlb!RX*9tue(TG$JlEF(N^*JdIGQiCfiaP1O@2LgahJ zkH$O@smhQ~;AKP+EH5Jr)_qpr&(-Ckyd!D$e0EVj*h+P03#x4v#MjFy`AhfC(3;Trq=g7O%)@9 z0VA1s7_r_Z`hm`fMnl}KR?pwl7OFJzoQh5QG^T4qfCunq`FOlpunqH=+dH$QeA{i1nT3Ui1_ZdD3oG#|-SAm2St#x?WMf%f?ex zX;grbQ&)*Qt$HqoRXv2)NQi_De#3uv} z2@d@;cd>)-kJEpCoJlDW6+Al7@;fYJ8Nqid=M-1V9~d4JW=wI5PmI;Z#l#v@3MGWc zY2(9VBEyV+g%d5mO&c7a7^e-4500|@8={9AlmGL(Ji@fm@ev7Q0;7Tx;vz;{K6u3j z#|1}5Y9j+Je}e71SegI)QbKToHZU>P@*kiz`jtpb46oqtFoEnV)5JLevW4c6G%oH~2=8 zx!(uwPUc;z2&oS0%sni1#t^yKyHda14iF;zKiky>?oI`q{`?qZ#5274X=;jSN7|iy^fy=J(WZiBc32fUgOCT>*BMT=!}R;(wbGr>`I@#)GkLp zk6(3gPA94uQ2|CyVPph-Ii6aV#F8Z$YCrwqW6BkVOfI&bVgL{|FdYt7Mp-~l*`2+^zTAte!nGlVFC2v=+yR2RSr-*#v z^Oi4bW2j1zn&3Qh2g`XzZyk9y+5tvH(sotHbTpjKvSZ|S*)p%b>8WC*J@6uX@OTmH z70_H461dWNW2(q>i1cwdP;4)?02 zDqDt_gw|B0$VI?NV=Rm~x;#;%5=pyN9kVvh-Hs9S7A83SJYAJ$95~NR$8w&r^&-*e zIieOw+f`}algw^VrIEjzir0A@OI3t&b`dBJP#yN)%eV&nig)3nBNrm>Cs z9*oY2$dR|JqkUFRg&8r`uUBql3qPtDDG$uZb1Y`WHn8XeG9!Y5C2d!A%#t+&_QQ;r z&levR*^#a{o4AL4Tm7oh0Y*gPesy(>sDV0GQ+>tQe2=wMrN}~Xris9Erg3zsgurTu z`&F-zZUtaMOp$FqeJx8DA)ptDz|xD@?u(2?&k#;c+OO)E-vL_|!*xc!5_`Yd>xxt{ zB7-wccPwWbgZ18-fX;}LCvR9A)SbK6j*%BV%XB+gg(^nA0Y+T0FyiQ7Ji)Tz%9v7k zM4WbLV0^?_ZM<=i<*$0-zJ83>@^;HQQ7$ktI7A!y=bvDiLZf3I%)Pf3X2k5ZX6~n; zVN@|v9CRZeuyi8^2bXOMDweci)iHsOCg@;BYk@CU+E}-i~^BBDAt&Hbg zuXP}N7335V6(VWFD$W02?45T|R7<t@I31KDjesxcU|HGuBd~xdZwsomu zq$aoza0AbM0NZOT^qF|Mtq5tqDo54LQyfYWwf(CBOMU6OF;XA&BA2lAB93;eMvfmc(2GVvl_a6N1 z)~jGfRQ`duGO84)GYepPO39Mc-EG%Nay`*tOjDng<_ zFESTPFJeFSRzN325{TQ?*K_jy4H1$q28aLkkS_n805T*RONQ7t1(?wZF>vJV>NR1D zb_&gkd+{TqYg3gXel%O?31a*2xx3ab%T zH_S84t8Q1@hGMtih@kM;|J)J%b9cV zB6+uZWPF}&ntrv!tf&dkmr=z?QIH~Uv80HDTdg>qBoKG2Zl6EF(|Of$UH07C=|mMF zE`X4)SO{_O8y=@KaKzne$5w*ooz>9QKJDAQq>7LQfRMph2r;`BZ+_CJ5PF?4vZURr z!Wb*G)xOs3@bgYmr!7=5@(Y}3^58kq*tU&~KxTx^{X|3fEuOsipOqb;Zq-_EdC9T2 zj!{L(CO}9xEQB~XznNom3k_jH6z1bsgQi-tkBUOyl06B6KPmb8W(o9D0S9zAST~(O* zpFd578Bw3_T-^VjL=__=0VA`pFk&|&z6akRjL>X28<-* zVZ^({>UWVF&>0a7#Qo~>ve7)$v09hSGE|%1lqy2{142@<5Rx!H&&keyB03?WNZPL| zOy#mO{()1(@~BSX(AHh3Vg&P)BJ-z9B?q6|g3gG!B<`I@kW50Pe4V@4pOWv@a ztu|A$lg4UTzwhfQjw(j(0t;USi-k9RcADD4_n8BX7)cveg|R#;s+j|?Ry&lsE}%PA zjLZW$G89XWm>k;*&*^m%dB-}X%Z5#wZlq*F*QR?$P{l}lz{pNKjAUiZS$KF3a*pU( zk-TGNS3UTwVZ^!b=PozqQ^iOqU}Py4MjYHZ!s+!qdB+;MyF!MB5x%5X-blK3ZF+)l zHJ9;xtFd`_^qy7E>B&1*U7^%hFeBDhg__C_J*mo(iXcZGV962t42ikuwT5SjJJze# zBXQ8lSAB8oVTZQN0bt1B4h!J63t!=%rmCLM&_c4=LD)t{r&; z0U=B95MujIlZH-+Adxn#^0gNi21A6X`D+Iby;hZ~47m@?NF_XG#CC&qEIJ{gNZPL| z%sMXN8{COl#&vBhiXW(AZ0wDLfR5Nn`^&*`e0s3K$_AY=&^Ld?#`Ge3&I93aF<+O5iI?qgygLexBamsPua znJPlUz-eX?meY*A4?*6a$o+ZNOFBcEY-0vNgji-2_3u-z4poHUo>Me!Z=I-RkB~Ej zV+HbFb=I3rbKujAy5eW!x-02=CxLms_uNTEzV2yCrHHIYK0n$y`eMBb}zL_j9(5_DZ+yk zIgKSn?DvV#U(#@*K-#S;%$ZW+WH?1EufNE@ug;^25k0t1bQa5fB9m)VH6_b{UTGwb zv|Ux00tvN0Y8W|u!ozJ~3#u5wydTeGoAb@0Gh)ya_p6?>*B5{)jb&AlIe~w_r;3oe zpwe8yQfcgOt=^y$V$>1$tL=&&i-riXO8pyG+Wng!> z?IVx4LxiYxevFFGL)ZM71>h#YU@SKQ?6-+-qGw3%YfZx6XA~y+{(!fd^X|B2Wm~j* zOjU|32Tmjij}u8LkhHj8dvr#49ci#wD~8h7-#?db{ zJZ~WHRx^7_n(4e2Id$(O`4v@+R0cV64@-{NCpb?;&k;c+?N(*x!ib_!H)8GI{nMr; zbZv5O3kcbZhmiZq&XxVpXB6?GK-#P-%!+(%k83JT(=9s<#ps%26#zQcl~_7fNB3Is z5=YvtDop6B=U+99l+u-W*(!mmN;3*{BQvpdBPQEjfP?6j#=sJ{s{>me(%gV|nHAWS zrR(nM9`F*c9iEqX4sHtIjXKhHRbjgO{dE~mk#sLh=+@nIZMM1rZWPtTbE9Z-36yFKn1jRi&v5x{)h*x{(3=igxMekr@$mB5A{_FsUu> z{eT&<>`gyWY9?K8X(B;4l8B`nF%Rs#rJc8m&Il`zcdQopgNoRPR+?R3to6HLgOx^I%Y>Z!_*c7TvQ zcnGoi)mP{l!W+o@RqnUfJWVHZc=F1I=HgT_;sff;E-ZD%WSexh7M&46B<)va*PwcJ zp%k&)p0|8+&RnVp!TLsGem*B>r$2wZGwm1Qd301np15ZHF~?X9LPc$NwceT)2C7iO z{BYBL5&k7QArePkvo<(!bSYeL)crFD4vBn76(c>tN8b&2KKj}QTA^P-%iVxRUb8+~ zRpUO)h~;;$M*h1VQN@TiXk2$=XO|s_ zb@aeP@WV~DVW&|K%S2F>Ax1#RF+7C07H@virwBSBEKgjrF1&iQ7n~tIU#C^7)t4$l zHUd4;1B)Ip`;TOgxuXy074>@Jk~M4Awn&H&>yVPMT?%feijZgE+DI8J*G3W+);O|y zZWwxoa4dPrdgRUZMeun>t+uwJu;c|*j6{PJNx+jLj@B8@NL;cmxv~%@#B%Zc8Mir` zsUoB&=tMT)=|rBlE|s}?K6;Aq5^=ZMC&SeZsx#_>zdny#+KMVdFb@c@yH)fNy}8q@ z$h*~TBNv|4q{xfGpN}lRK@}sPKrd1dOD|$S@wP%w5s@eDR^{t2%65QK#G1kv_B%?~ zd1eNvGo!K88Al&(ijtnZS^cNmea+)uYxx0N7EHWLRf=>2jBLWfh&ev*x;C59$61L6 zmbh815>vk$oFe7+EC>%CP8A`Tm!Fx7^xmJ+yA*nzF&IgkRfXx-xRhp$gxV+Xq@+x` zRwyN~GPY!n7$>YPF_cy|TT3`DS#jbAAq<<(02)P6ZsgH*c+eP?|4iI7_?^ioLK9~vD z8P%y^v2Wj8sA8lEs54nu>WsGPR=< zUv4f_r8}7A4mJz5TWF;UZ01F}Z z^GpSFLJT_cc2#Z=cw5u0HoR6SWmpVVjEn;>t)^gkX=Q&!Gr|Ez45aOXRf_ZkCz=g-PBgZDRX}FM zpc6>D)!YHB5Bg1mD~a1X9Cme;pp3OBt>Rf=G)GxiBI4)h|NfwWy!m{*Ub4KO3t zImb8tu8>9*BNsr9G{BQ1X-g7YPxuQxM|g?6UsX3P+5jEEe0!+Q5h&kGtxqJk0z&yA#t5r1Gc%-`Ep~b2$=`Yy+iSwdu=ZzJkSX-=tvt@S(>|CGsZcr#-3S#89WauHhmi@<8fy{?W+%gNu$EFk=Rg9blQ$~0!Q%39-o<*-ToQ||%m6MMrSAbGPt>IcR z-}`A)5waSjNMAfD;(m5Z`^TLfAjCl4ujbj8s#!dup4ztjYVuyH7}*6Jybl%!@8}(8 zBQKKnt8%MJZ`|P&;l@lnx16qR62(D^yvCCvwl|v<(Njd=iQCl%_tqDI3905@>(}tv zRAtC;K!^zoA!gfb03$jfB1hV;Doo3$aVs_5s>|#m8Gj9=ije@o$Vx1XI6CpnD6ypd zs$AHkLO(b~^o=tj)m>B(vKUyAL3pf)Yg08P%YdFDl99Y!-EJ~#UgW7Yod(Y;NY~A? z-{4k}GoD*Twi6Bd!d|1nK-#X#Z|1gd0;fn#CMN%kYgDC30Z?Z?W2rMH+iLiW=qX|p ziM!Q)TYi;-32|{{e{Lv36(PSshUCGLA?5+D4Tp>CQ3>I7I-a~+4e&@gsOeT+Gu3&j7~udTXRt8hV7JQaIEl1dRhY^T&ued;al_js8C|JjWGi6A4oOqrfP0LCq&efcdLiDcbKF(^S&$Lv~_ANsu+3e@$Z?ps0)rWuQ{

#+^tqmuvCHSjOEaj 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 BjoAPI literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_circuit_depth new file mode 100644 index 0000000..9f72858 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_circuit_depth @@ -0,0 +1 @@ +88 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_transpiled_circuit_depth new file mode 100644 index 0000000..3d41066 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.max_transpiled_circuit_depth @@ -0,0 +1 @@ +410 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_circuit_depth new file mode 100644 index 0000000..97caa14 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_circuit_depth @@ -0,0 +1 @@ +84.43408203125 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_transpiled_circuit_depth new file mode 100644 index 0000000..577b6a8 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +395.65673828125 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r2.result new file mode 100644 index 0000000000000000000000000000000000000000..0d4e8d036a8df89d6d5d74cfeaecc3ee79b97ade GIT binary patch literal 1120639 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 literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_circuit_depth new file mode 100644 index 0000000..e3b5acb --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_circuit_depth @@ -0,0 +1 @@ +107 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_transpiled_circuit_depth new file mode 100644 index 0000000..34c3a20 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.max_transpiled_circuit_depth @@ -0,0 +1 @@ +487 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_circuit_depth new file mode 100644 index 0000000..c3d216e --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_circuit_depth @@ -0,0 +1 @@ +97.3681640625 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_transpiled_circuit_depth new file mode 100644 index 0000000..616391b --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +444.54833984375 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r32.result new file mode 100644 index 0000000000000000000000000000000000000000..da0e4832de3b6a84b39d124c9fa6da570a7649ec GIT binary patch literal 1122653 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�kJYZYpChtN+OX<7u9mgjUHx=MnK@?+ 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 literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_circuit_depth new file mode 100644 index 0000000..3fdc173 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_circuit_depth @@ -0,0 +1 @@ +122 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_transpiled_circuit_depth new file mode 100644 index 0000000..ea5ca36 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.max_transpiled_circuit_depth @@ -0,0 +1 @@ +547 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_circuit_depth new file mode 100644 index 0000000..b223445 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_circuit_depth @@ -0,0 +1 @@ +111.03125 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_transpiled_circuit_depth new file mode 100644 index 0000000..a6326f6 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +495.94775390625 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r64.result new file mode 100644 index 0000000000000000000000000000000000000000..ed1a41a2a0a78b19c48250256964d9ab222f73e0 GIT binary patch literal 1122635 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

&XsF*E$=x( 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 literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_circuit_depth new file mode 100644 index 0000000..90be1cd --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_circuit_depth @@ -0,0 +1 @@ +95 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_transpiled_circuit_depth new file mode 100644 index 0000000..2ae9f6c --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.max_transpiled_circuit_depth @@ -0,0 +1 @@ +441 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_circuit_depth new file mode 100644 index 0000000..0fc1736 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_circuit_depth @@ -0,0 +1 @@ +87.0048828125 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_transpiled_circuit_depth b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_transpiled_circuit_depth new file mode 100644 index 0000000..7567a63 --- /dev/null +++ b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.mean_transpiled_circuit_depth @@ -0,0 +1 @@ +405.3291015625 \ No newline at end of file diff --git a/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.result b/results/3qswaptest_ibmqathens_backendqasm_simulator_noisemodelibmq_athens_shots8192_experiments2048_paulitwirlingFalse_r8.result new file mode 100644 index 0000000000000000000000000000000000000000..d4a7a625f44048771273e05bc8ce76282fd271fc GIT binary patch literal 1120703 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 WE9gb8W9dauAB{+&9=}-)?)xu7VR^v- literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse.circuit b/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse.circuit new file mode 100644 index 0000000000000000000000000000000000000000..e64c0d72a686c95c801756cdda59360376a2eb0d GIT binary patch literal 11907 zcmeHNU2GIp6yBC@e<=OMmZi3~RAXC&4YUPpEa`>~+)ZzE(&zX% zZh8~Hh8y*quri=xJ)g~7gLS7IP@)R%gNKcR)KJhDQ6i&mEvkeAN+clfQKG8mj;+Lc z?)H@uT*L+E$|1$4hH#f&Ct*z~tx!av&B_s8CQk1`A+4I}pV&Umw<=5>#gn ziKu&mT2zgIncZY)_t|6eZQV72g3n%1niC-!oH;0=(!{L7q)snxqPVi z1+>hYJ?(_rFW)95O*AVozWFqU`qBhIfrO;QFNZ z==C#i-%((agWOa4@L_B_=FKGL%}Fsw#a*a`2DllcGH(_t_d3u*a0!p0OFB=3=~7We z7pm++i;#=N3pLTz8-%c>K->r{-nk=balOE&XsUroj5g@bL$@UwQ zvbp;4NqVVFVC#=YLJ8O{q&FZdAORqzU=IO7lX_ncZ6OYANwO)fQLH6N?MBIyef`z_ zEla+aJoU!lvNU#$)&kM9HHK%=PMYvsB%GMD5jaj(kx>zxC9@Rlf#MhX=Q z@=6osN#o^)R+p5x?~E|JsWK9Kc@x?!h}oJbCh=uc@ot#GLW6qZGtf4`TQB#16LK5g zM{5Q7o<#YL5_OrwA$h36S5jDOA%?$g$`i$;-EQ0AE<1Z~_1MK1rH)%i|84HSa7Waf zh5MmLjOU9bP$}@Qm=TjWbVbb>@Mi`pYcACyP?^~lac3|GWoY_Ti8`b`?iLC^ws^O& z+YA)zKa0dbr5)xL3R?z>q1!@?Wns!RyE|?geW*b4ET#=f43tf~X_c7Z`;7`w471y! zOtR|WaTErK!5?XO65YvlxgFV<|B6o|bQR9&AtRsqNp_wEg*A z5-X)syf+8)%z(KWsJT7ubl;LPD81=7uOc(6Qx>NC>Tp-3_Dl4bz&qTORAn8`;*h`- zU26Y~$`h+j+B4pw#j~x=(s)ZAyEwh(Y2WNvxcad@)>%c2ra);t1;$H^HnT&-n!OH3 zclnhM*5Md@R!HqBP?KqRw|_>km+i6dib=cO7FCVJr)T|gm(=lVbLZXp z6Kf?;bz|qm$A@1RHMiH;*}>&$-p}FaN>B3>qCDn_nbU?vBVSCLv}d;sH^L9R@Z;dU zx=kz4&MkbfErr?XOLz;-S-^_VCEF#`6;HDJ!@HlR+;Di6nMAj7fehI|K#_SC?@R*KeN*q$}2>tWhl63JG)&x zyHg$4GOfHV_}^xC#l3Sk&z*in1ggDmPId=ITQdi|x{3M8fN#}oZW{6&yjr--u!!=~ zp6?a~irdY%Gmj0+!lKU6BW|AvpV_T*K%O!`e zs%WtY@No0Cuu0zwu&S6-bFnLkEqC5TUqW?o81c<(j1I##+;3?uIxX;MId^zCfDq(*x1WJM^y+{V5 z2pyRafHn9*2B?_^WmpAvuN+l;A@HWiiZ&;(=fy7(k}-Ls*LWe$@y%r-K(15XtBz{; z7|=6iLi{B|VlSu|Qbq@3QJ^>%$$LVBJ|!d%0o4~4t{1{!F076WMO26gFroE@=IR^b zcjGFQC)lHn4)_K`hM9%&+lEpLWcpAhqOo2MS3{$2|6oLQ169?hMl>*CV`xwzA#Vhx zbx~WJudQ{r(z?3Uzq<`@x;8mE>1~bTgSdyd(J6z5e(YVP`TD0<|lBia}26A I;qAKr1F}2WY5)KL literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r1.result b/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r1.result new file mode 100644 index 0000000000000000000000000000000000000000..86625ea83e14aafbface81d9d1e1cd8fa0126557 GIT binary patch literal 11935 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 literal 0 HcmV?d00001 diff --git a/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r9.result b/results/3qswaptest_ibmqathensnoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots16777216_paulitwirlFalse_r9.result new file mode 100644 index 0000000000000000000000000000000000000000..4bcda740a5d9ec49ec373296c55ab9e18f801472 GIT binary patch literal 48400 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 W&Y`w|ZK}eu9coCACx(cYzW4>53hMFz literal 0 HcmV?d00001 diff --git a/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r1.result b/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r1.result new file mode 100644 index 0000000000000000000000000000000000000000..f9808a3c9e164289f85b2b98470cb909e27a125c GIT binary patch literal 4959 zcmdT|TW=dh6keNbVkc_T0!2lrs1cVsf?6bQrGQ#F#gU9^SkWj^iy)bfcgLA^*Sq%a zY_X#vii8@dM&f}%Jir4_ydZuvFqZN;NzZ-E$qTBt_CLX-(ame zkuyp2l=$$2EwL;zrH6RpjLOTB$_}FHCEgA}b@Ip9I2-iEYkJ-3J1fPs7=TFUndt_jS#TulR>GNxu zWf!}xtjDlzVAnt!m=Q1Q&qIQ%^FO;qDm3~8Ps$CG00V0H zWfM{#V`b^&QNq)@V;hl2o<@f628_YeROG{> z091nszq}^+lYL1<;J9SN^cVro)C)3-Fmg>YnnvwK`U0Phz*~+t1k4A9DhlySG$d@E zxk&^NsG=YXh@9r=JXDFarKjlvtWfMxaWnPB58tp$UtgZ%D zveE>-$kpD}I6aDjr82HiWO3iJPl=Fr7Hph}0jCi4crE%Cs~ga*PsFQH2au2rq`Z=#t?cR- zWrX~ApJUy^o@ave(Qc@@T98eCr`x8ds{*tQez*|Z{ZP4=g)R0yd?-%8}M)`B+v!SRXrM1Ka);CXNV+-uv?dh z6y_owB7PJI0@&6~3jzc;`~ZT4q!JL2B?Xv6llSwX{*=0kT@wI- XemqsZ4KNnK;P|(TkN*}L_~q>10a&ne literal 0 HcmV?d00001 diff --git a/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r11.result b/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r11.result new file mode 100644 index 0000000000000000000000000000000000000000..0344603083c6de25a228bf8aa8f10945af8e27d5 GIT binary patch literal 24040 zcmeHP-D@0G6rbH@lTAZgE7lgIVnA(zc4-m=QCgC^fk;;u8yZ^CWO{e@CU?@=kIY9+ zLd6QwXt|)^_00#Ld=X##2kJvB_#z_MDyYwj4}BH|J$F8`vuk!;v&oEEP9WLL+;hKv z=iGD8{n+32o)3STSKJ?de4UyVwOr9Hs?t^4B-M&RY`s!ewQ|K4{Gq%|I$Nq5`l3#Y zv($17TYMmf-x6<#A-k3bbz`)*YdnnX}`Le$WHM? zK6Osq)QEPb5{&|pe+djTzHV{8=6M9Q*pHUTM&SWMhZe|-10ed)8y zBfMAD%SE~h2sk%Hp-!5ey_x>~%#okztDofA^SPuHpz`IlZxVMN{OH!}ZVq_<`q|5e zrxsptKuD4A$h_DPY|yh$_IRE>0id%d*@;|&4doOzyfvomsXTi+&rY(8gpEz^Ofl1L zG5kb>5}H`jDi~7sQoSMd7YK|@X=#F8oBF?7MB5W6OuM~vBXxc+=o`$IBXzEA=GL#?EJ(tG13b3pYIol@#v=28 zSQDr1vDEo-6a$ z(XBIMNCzwHV5ee-md`OvcDueT!#;K5aS^?}g5G3ATWn(tYwBcyiRdAE;VtVJ##8IS zYAX4|wKvBGzir$r8}m*#T4!z+mH8oE1hYMkFC1Snk1w?HZ5%bk;0L2V?>)4L zR4djPeEY5&F7^o{nAjtjZnW~&t_(NdcH>ACHx$GB6`M!SZQaMl=(&@LpsUeqd-JWy zu31}`M4AP6QEj>5@p)(VAJz9pP*13*`hYbCi`ZUphpw!X@B|$UqE~-fj25v27SVQa z7koQ8TqjILQ8~4)zI?sw8z6{YCs7lkx5v=K_$)XQ#W^xOU;WoDF+>m1i#g_O?aJcb zHN%;4kIjr2X>Q{t1X}rySo!u`SzD(E&CXM!TAjwQ2f6Db8T-_U)gyX{UVP^icoU+N zg$tsG=+!U#y4WIGM`g_dtEleWcJ;-Y2tv3nHe5t+8%x=)9#5T~W%}QnZ@ZW#_uafj zCx5ts6}Uu+<(R-o-S?9JUqG`BtkHczs?Q*okVM9E76y9b5O1+;A%Co)V9g+wr2_}| zCb2V5WhL2kjrEz0FaOe~DEx3Xko_m&GkcCFG{H{8%y(v9EdK`bL^3kJ{bKI>Prp01 z9xyUryqEqlo4oVqCL{BPpggq#l}kcvHbHnw^BXPl33dUGIC%sc3HD2&|0fDDHwocBRBY_fS-QwWy!NGb6jvU z)X1%S{UV^;lzN4(S>iolDRmjI<-fA8&_si*RU8|5w-2aGMx{UuwF(^9K$ooWbcmI^ z$0g;K)Y3qFPOCN(xqG~iu2$8n#1Jga26%FDqDF(x4sAh#o|Z)5U+nvQ(j!7oUnQmv ZfB-Ladif|MX5sh!qx#+Zo`6%x{0(3R)9(NP literal 0 HcmV?d00001 diff --git a/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r13.result b/results/3qswaptest_paulinoisemodel__ZNE_CNOT_REP__backendqasm_simulator_errorctrldFalse_shots8388608_paulitwirlFalse_r13.result new file mode 100644 index 0000000000000000000000000000000000000000..ad65b3afb88ec90efe4f4145f6b8a70022a0081c GIT binary patch literal 27856 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 No2|{?d;zzZ`Wr=&dTsAV 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 R4g}J-e*5%SPrxZ;{{hlx0Eqwq literal 0 HcmV?d00001 diff --git a/results/3qswaptest_paulinoisemodel_noisemodelamplification_ampfactors7_shots8388608 b/results/3qswaptest_paulinoisemodel_noisemodelamplification_ampfactors7_shots8388608 new file mode 100644 index 0000000000000000000000000000000000000000..6ad6de2893d0f1cf4be035c5d1768dae20ca35bd GIT binary patch literal 203 zcmZo*nR+ zhtXz=pP!%Ce;@!8-V7yEk~*C&Kn@8IyJ-)i-Irek(>#|>faw#~2f?(=`t4wv;n{jH Nz2fOo`zb)}dH^{JNoN26 literal 0 HcmV?d00001 diff --git a/zero_noise_extrapolation.py b/zero_noise_extrapolation.py index 9f9df45..c4b3689 100644 --- a/zero_noise_extrapolation.py +++ b/zero_noise_extrapolation.py @@ -1,6 +1,12 @@ import re #because we need regular expressions import numpy as np #because we need the random number generator +from numpy.linalg import solve from qiskit import * + +from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap +from qiskit.transpiler.passes import Unroller, Optimize1qGates +from qiskit.transpiler.preset_passmanagers.level3 import level_3_pass_manager + from qiskit.tools.monitor import job_monitor import sys @@ -201,7 +207,7 @@ def Richardson_extrapolate(E, c): for k in range(1,n): A[k,:] = c**k x=np.linalg.solve(A,b) - return np.dot(np.transpose(E),x) + return np.dot(np.transpose(E),x), x def mitigate(circuit, amplification_factors,\ expectationvalue_fun,\ @@ -354,13 +360,11 @@ def mitigate(circuit, amplification_factors,\ else: raise ValueError("not yet implemented, coming soon") - R=Richardson_extrapolate(E_av.reshape(len(amplification_factors),num_experiments),\ + R,_=Richardson_extrapolate(E_av.reshape(len(amplification_factors),num_experiments),\ np.array(amplification_factors)) return R, E_dict, E_av_dict,\ max_depth_dict,mean_depth_dict,\ max_depth_transpiled_dict,mean_depth_transpiled_dict,\ - experimentname - - + experimentname \ No newline at end of file diff --git a/zero_noise_extrapolation_cnot.py b/zero_noise_extrapolation_cnot.py index 2a2de66..b9958f6 100644 --- a/zero_noise_extrapolation_cnot.py +++ b/zero_noise_extrapolation_cnot.py @@ -1,104 +1,434 @@ -from qiskit import QuantumCircuit, execute, Aer +from qiskit import QuantumCircuit, execute, Aer, transpile + +from qiskit.result.result import Result +from qiskit.providers.aer.noise import NoiseModel from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap from qiskit.transpiler.passes import Unroller, Optimize1qGates from qiskit.transpiler.preset_passmanagers.level3 import level_3_pass_manager -from numpy import asarray, ndarray, shape, zeros, empty, average, transpose, dot +from numpy import asarray, ndarray, shape, zeros, empty, average, transpose, dot, sqrt from numpy.linalg import solve -import random +import random, os, pickle, sys, errno +from dataclasses import dataclass + +abs_path = os.path.dirname(__file__) +sys.path.append(abs_path) +sys.path.append(os.path.dirname(abs_path)) +from typing import Callable, Union """ -- ZERO NOISE EXTRAPOLATION for CNOT-gates -- -This implemention does quantum error mitigation using the method of zero noise extrapolation, by amplifying noise in -a quantum circuit by a set of noise amplification factors, then using Richardson extrapolation to extrapolate the -expectation value to the zero-noise limit. +This is an implementation of the zero-noise extrapolation technique for quantum error mitigation. The goal is to +mitigate noise present in a quantum device when evaluating some expectation value that is computed by a quantum circuit +with subsequent measurements. The main idea of zero-noise extrapolation is to amplify the noise by a set of known +noise amplification factors, such as to obtain a set of noise amplified expectation values. Richardsson extrapolation +is then used to extrapolate the expectation value to the zero-noise limit. -The noise amplified and mitigated is specifically noise in CNOT-gates. The noise is amplified by n amplification -factors 1, 3, 5, ..., 2n + 1, where 1 means the bare circuit without noise amplification, and 3 means every -CNOT gate is extended as CNOT*CNOT*CNOT. +The noise that is here amplified and mitigated is specifically general noise in CNOT-gates. Note that in modern quantum +devices the noise in the multi-qubit CNOT-gates tend to be an order of magnitude larger than in single-qubit gates. -As CNOT*CNOT = Id, the identity, in the noise-free case the amplified CNOT have the same action as a single CNOT, -but ~3 times the noise. +To amplify the noise we use that the CNOT-gate is its own inverse, i.e., CNOT*CNOT = Id, where Id is the identity gate. +Thus an odd number of CNOT-gates in a series will in the noise-less case have the same action as a single CNOT-gate. +The noise is amplified by replacing each CNOT-gate in the original bare circuit with a series of (2*i + 1) CNOT's, +using noise amplification factors c=1, 3, 5, ..., 2*n - 1, for n being the total number of amplification factors. +For c=3, each CNOT is thus replaced by the sequence CNOT*CNOT*CNOT, and while this has the same action in the noise-less +case, in the noisy case the noise operation associated with the noisy CNOT-gate will be applied thrice instead of once. """ +# Dataclasses, containing partial (noise amplified) and final results + +@dataclass(frozen=True) +class NoiseAmplifiedResult: + amp_factor: int + shots: int + qc: QuantumCircuit + depth: int + exp_val: float + variance: float + + +@dataclass(frozen=True) +class ZeroNoiseExtrapolationResult: + qc: QuantumCircuit + noise_amplified_results: ndarray + noise_amplification_factors: ndarray + gamma_coefficients: ndarray + exp_val: float + + @property + def bare_exp_val(self) -> float: + return self.noise_amplified_results[0].exp_val + + @property + def noise_amplified_exp_vals(self) -> ndarray: + return asarray([result.exp_val for result in self.noise_amplified_results]) + + @property + def noise_amplified_variances(self) -> ndarray: + return asarray([result.variance for result in self.noise_amplified_results]) + + @property + def shots(self) -> ndarray: + return asarray([result.shots for result in self.noise_amplified_results]) + + @property + def total_shots(self) -> float: + return sum(result.shots for result in self.noise_amplified_results) + + @property + def depths(self) -> ndarray: + return asarray([result.qc.depth() for result in self.noise_amplified_results]) + + +# Zero-noise extrapolation class: class ZeroNoiseExtrapolation: - def __init__(self, qc: QuantumCircuit, exp_val_func, backend=None, noise_model=None, - n_amp_factors: int = 3, pauli_twirl: bool = False, shots: int = 8192, - pass_manager: PassManager = None): + def __init__(self, qc: QuantumCircuit, exp_val_func: Callable, backend=None, exp_val_filter=None, + noise_model: Union[NoiseModel, dict] = None, n_amp_factors: int = 3, shots: int = 8192, + pauli_twirl: bool = False, pass_manager: PassManager = None, + save_results: bool = False, experiment_name: str = "", option: dict = None, + error_controlled_sampling: bool = False, max_shots: int = 2048*8192, error_tol: float = 0.01): """ - :param qc: The circuit to be mitigated - :param exp_val_func: A function which computes the observed expectation value of some operator as a function of - the measurement counts from the circuit qc - :param backend: The backend on which to execute the circuit - :param noise_model: Optinal custom noise model for execution on a simulator backend - :param n_amp_factors: Number of amplification factors to be used. For n amplification factors, the - amplification factors will be 1,3,5,...,2n + 1 - :param pauli_twirl: Do pauli twirl True / False - :param shots: Number of shots of the circuit to execute - :param pass_manager: Optional custom pass manager to use when transpiling the circuit + CONSTRUCTOR + + Parameters + ---------- + qc : qiskit.QuantumCircuit + A complete quantum circuit, with measurements, that we want to perform quantum error mitigation on. + When run on a quantum backend, the circuit should output a set of measurements results from which the + desired expectation value can be estimated. + + exp_val_func : Callable + A function that computes the desired expectation value, and its variance, based on the measurement results + outputted by an execution of a quantum circuit. + The function should take two arguments: a list of qiskit.result.result.ExperimentResult objects as its first + argument, and a possible filter as its second. + The function should return: A numpy.ndarray of expectation values corresponding to each ExperimentResult, + and a numpy.ndarray of variances in similar fashion. + + backend : A valid qiskit backend, IBMQ device or simulator + A qiskit backend, either an IBMQ quantum backend or a simulator backend, for circuit executions. + If none is passed, the qasm_simulator will be used. + + exp_val_filter : any, (optional) + Optional filter that is passed to the exp_val_func expectation value function. + + noise_model : qiskit.providers.aer.noise.NoiseModel or dict, (optional) + Custom noise model for circuit executions with the qasm simulator backend. + + n_amp_factors : int, (default set to 3) + The number of noise amplification factors to be used. For n number of amplification factors, the specific + noise amplification factors will be [1, 3, 5, ..., 2*n - 1]. Larger amounts of noise amplification factors + tend to give better results, but slower convergence thus requiring large amounts of shots. + Higher noise amplification also increases circuit depth, scaling linearly with the amplification factor c_i, + and at some point the circuit depth and the consecutive decoherence will eliminate any further advantage. + + shots: int, (default set to 8192) + The number of "shots" of each experiment to be executed, where one experiment is a single execution of a + quantum circuit. To obtain an error mitigated expectation value, a total of shots*n_amp_factors experiments + is performed. + + pauli_twirl : bool, (optional) + Perform Pauli twirling of each noise amplified circuit, True / False. + + pass_manager: qiskit.transpiler.PassManager, (optional) + Optional custom pass_manager for circuit transpiling. If none is passed, the circuit will be transpiled + using the qiskit optimization_level=3 preset, which is the heaviest optimization preset. + + save_results: bool, (optional) + If True, will attempt to read transpiled circuit and experiment results for each noise amplified from disk, + and if this fails, the transpiled circuit and/or experiment measurement results will be saved to disk. + + experiment_name: string, (optional) + The experiment name used when reading and writing transpiled circuits and measurement results to disk. + The experiment name will form the base for the full filename for each written/read file. + This argument is required if save_result = True. + + option: dict, (optional) + Options for the writing/reading of transpiled circuits and measurement results. + option["directory"] gives the directory in which files will be written to/attempted to be read from. + If no option is passed, the default directory used will be option["directory"] = "results". + """ - if backend == None: + # Set backend for circuit execution. If none is passed, use the qasm_simulator backend. + if backend is None: self.backend = Aer.get_backend("qasm_simulator") + self.is_simulator = True else: self.backend = backend - - # Do an initial heavy optimization of the input circuit - self.qc = self.transpile_circuit(qc, custom_pass_manager=pass_manager) + self.is_simulator = backend.configuration().simulator self.exp_val_func = exp_val_func + self.exp_val_filter = exp_val_filter self.noise_model = noise_model self.n_amp_factors = n_amp_factors - self.noise_amplification_factors = asarray([(1 + 2*i) for i in range(0, n_amp_factors)]) + self.gamma_coefficients = self.compute_extrapolation_coefficients(n_amp_factors=self.n_amp_factors) + self.noise_amplification_factors = asarray([(2*i + 1) for i in range(0, self.n_amp_factors)]) self.pauli_twirl = pauli_twirl - # Max number of shots for one circuit execution on IBMQ devices is 8192. - # To do more shots, we have to partition them up into several executions. - if shots <= 8192: - self.num_executions = 1 - self.shots = shots + # Total number of shots + self.shots = shots + + # variables involved in error controlled sampling: + self.error_controlled_sampling = error_controlled_sampling + self.max_shots = max_shots + self.error_tol = error_tol + + # Variables involved in writing and reading results to/from disk + self.save_results, self.option = save_results, option + if self.option is None: + self.option = {} + self.experiment_name = "" + if self.save_results: + self.set_experiment_name(experiment_name) + self.create_directory() + + # Initial transpiling of the quantum circuit. If no custom pass manager is passed, the optimization_level=3 + # qiskit preset (the heaviest optimization preset) will be used. If save_results=True, will attempt to read + # the transpiled circuit from disk. + circuit_read_from_file = False + if self.save_results: + qc_from_file = self.read_from_file(self.experiment_name + ".circuit") + if not (qc_from_file is None): + circuit_read_from_file = True + self.qc = qc_from_file + if not circuit_read_from_file: + self.qc = self.transpile_circuit(qc, custom_pass_manager=pass_manager) + + """ + --- Initialization of other variables for later use: + """ + + self.noise_amplified_results = empty((self.n_amp_factors,), dtype=NoiseAmplifiedResult) + + self.result = None + + @staticmethod + def partition_shots(tot_shots: int) -> (int, int): + """ + IBMQ devices limits circuit executions to a max of 8192 shots per experiment. To perform more than 8192 shots, + the experiment has to be partitioned into a set of circuit executions, each with less than 8192 shots. + Therefore, if shots > 8192, we partition the execution into several repeats of less than 8192 shots each. + + Parameters + ---------- + tot_shots : int + The total number of circuit execution shots. + + Returns + ------- + shots, repeats: (int, int) + Shots per repeat, number of repeats + """ + if tot_shots <= 8192: + return tot_shots, 1 else: - self.num_executions = (shots // 8192) + 1 - self.shots = int(shots / self.num_executions) + if tot_shots % 8192 == 0: + repeats = (tot_shots // 8192) + else: + repeats = (tot_shots // 8192) + 1 + return int(tot_shots / repeats), repeats - # Initialization of variables for later use: + # We use the @property decorator for certain useful data that we might want to retrieve that are stored within the + # noise amplified results - self.counts = [] + @property + def bare_exp_val(self) -> float: + return self.noise_amplified_results[0].exp_val - self.depths = empty(n_amp_factors) + @property + def noise_amplified_exp_vals(self) -> ndarray: + return asarray([result.exp_val for result in self.noise_amplified_results]) - self.bare_exp_vals = zeros(0) - self.all_exp_vals = zeros(0) - self.mitigated_exp_vals = zeros(0) + @property + def noise_amplified_variances(self) -> ndarray: + return asarray([result.variance for result in self.noise_amplified_results]) - self.result = None + @property + def depths(self) -> ndarray: + return asarray([result.qc.depth() for result in self.noise_amplified_results]) + + @property + def mitigated_exp_val(self) -> float: + if self.result is None: + return None + return self.result.exp_val + + # Functions for computing the Richardson extrapolation + + def extrapolate(self, noise_amplified_exp_vals: ndarray): + """ + The Richardson extrapolation reads + + E^* = \sum_i gamma_i * E(\lambda_i), + + where the gamma_i-coefficients are computed as a function of the amplification factors by solving a system + of linear equations, this is done in self.compute_extrapolation_coefficients(), and E(\lambda_i) is the + i-th noise amplified expectation value, corresponding to the amplification factor \lambda_i. + + Ref: https://doi.org/10.1098/rsta.1911.0009 + + Parameters + ---------- + noise_amplified_exp_vals: numpy.ndarray + The noise amplified expectation value, in order corresponding to amplification factors 1, 3, 5, ... , 2n-1. + + Returns + ------- + mitigated_exp_val: float + The mitigated expectation value, which is the exp val extrapolated to the zero-noise case. + """ + if self.n_amp_factors == 1: + return noise_amplified_exp_vals[0] + if not shape(noise_amplified_exp_vals)[0] == shape(self.gamma_coefficients)[0]: + raise Exception("Shape mismatch between noise_amplified_exp_vals and gamma_coefficients." + + " length={:}".format(shape(noise_amplified_exp_vals)[0]) + + " does not match length={:}".format(shape(self.gamma_coefficients)[0])) + return dot(transpose(noise_amplified_exp_vals), self.gamma_coefficients)[0] + + def compute_extrapolation_coefficients(self, n_amp_factors: int = None) -> ndarray: + """ + Compute the gamma_i-coefficients used in the Richardson extrapolation. We assume the specific noise + amplification factors to be 1, 3, 5, ..., 2n-1, where n=n_amp_factors is the number of noise amplification + factors. + + Parameters + ---------- + n_amp_factors: int + Number of amplification factors. + + Returns + ---------- + gamma_coefficients: numpy.ndarray + The set of coefficients to be used in the Richardson extrapolation. + """ + if n_amp_factors is None: + n_amp_factors = self.n_amp_factors + if n_amp_factors == 1: + return asarray([1]) + + amplification_factors = asarray([2*i + 1 for i in range(n_amp_factors)]) + + A, b = zeros((n_amp_factors, n_amp_factors)), zeros((n_amp_factors, 1)) + + A[0, :], b[0] = 1, 1 + + for k in range(1, n_amp_factors): + A[k, :] = amplification_factors**k + + gamma_coefficients = solve(A, b) + + return gamma_coefficients + + # Functions involved in saving and loading results from disk + + def set_experiment_name(self, experiment_name): + """ + Construct the experiment name that will form the base for the filenames that will be read from / written to + when save_results=True. The full experiment name will contain information about the backend, number of shots, + and pauli twirling, to ensure that different experiments using different parameters don't read from the same + data. + + Parameters + ---------- + experiment_name : str + The base for the experiment name that will be used for filenames + + """ + if self.save_results and experiment_name == "": + raise Exception("experiment_name cannot be empty when writing/reading results from disk is activated.") + self.experiment_name = experiment_name + self.experiment_name += "__ZNE_CNOT_REP_" + self.experiment_name += "_backend" + self.backend.name() + self.experiment_name += "_errorctrld" + str(self.error_controlled_sampling) + if self.error_controlled_sampling: + self.experiment_name += "_tol" + str(self.error_tol) + self.experiment_name += "_maxshots" + str(self.max_shots) + else: + self.experiment_name += "_shots" + str(self.shots) + self.experiment_name += "_paulitwirl" + str(self.pauli_twirl) + + def create_directory(self): + """ + Attempt to create the directory in which to read from/write to files. The case whereby the directory already + exists is handled by expection handling. - def set_shots(self, shots: int): - if shots <= 8192: - self.num_executions = 1 - self.shots = shots + The directory is given by self.option["directory"], with the default being "results". + + """ + if not self.save_results: + return + directory = self.option.get("directory", "results") + try: + os.makedirs(directory) + except OSError as e: + if e.errno != errno.EEXIST: + raise e + + def read_from_file(self, filename: str): + """ + Attempts to read data for a given filename, looking in the directory given by self.option["directory"]. + + Parameters + ---------- + filename : str + The full filename for the file in question + + Returns + ------- + data : any + The data read from said file. None if the file wasn't found + """ + directory = self.option.get("directory", "results") + if os.path.isfile(directory + "/" + filename): + file = open(directory + "/" + filename, "rb") + data = pickle.load(file) + file.close() + return data else: - self.num_executions = (shots // 8192) + 1 - self.shots = int(shots / self.num_executions) + return None + + def write_to_file(self, filename: str, data): + """ + Writes data to file with given filename, located in the directory given by self.option["directory"]. + + Parameters + ---------- + filename : str + The full filename of the file to be written to. + data : any + The data to be stored. + + """ + directory = self.option.get("directory", "results") + file = open(directory + "/" + filename, "wb") + pickle.dump(data, file) + file.close() + + # Functions for processing and executing the quantum circuits def noise_amplify_and_pauli_twirl_cnots(self, qc: QuantumCircuit, amp_factor: int, - pauli_twirl: bool) -> QuantumCircuit: + pauli_twirl: bool = False) -> QuantumCircuit: """ Amplify CNOT-noise by extending each CNOT-gate as CNOT^amp_factor and possibly Pauli-twirl all CNOT-gates Using CNOT*CNOT = I, the identity, and an amp_factor = (2*n + 1) for an integer n, then the extended CNOT will have the same action as a single CNOT, but with the noise amplified by - a factor amp_factor. + a factor amp_factor. This thus method allows for circuit-level noise amplification. + + For efficiency, this function does both noise amplification and pauli twirling (optionally) at the same time. + Separate functions for noise amplification and for pauli twirling are included at the end of this file, for + completeness. :param qc: Quantum circuit for which to Pauli twirl all CNOT gates and amplify CNOT-noise :param amp_factor: The noise amplification factor, must be (2n + 1) for n = 0,1,2,3,... @@ -107,18 +437,19 @@ def noise_amplify_and_pauli_twirl_cnots(self, qc: QuantumCircuit, amp_factor: in """ if (amp_factor - 1) % 2 != 0: - print("Invalid amplification factor:", amp_factor) + raise Exception("Invalid amplification factors", amp_factor) # The circuit may be expressed in terms of various types of gates. # The 'Unroller' transpiler pass 'unrolls' (decomposes) the circuit gates to be expressed in terms of the # physical gate set [u1,u2,u3,cx] - # This is still general for backends with possibly different native gate sets, as we can still express the - # circuit, and do the noise amplification + pauli twirling, in terms of the [u1,u2,u3,cx] gate set, and then - # if necessary convert to the native gate set of the backend at a later point + # The cz, cy (controlled-Z and -Y) gates can be constructed from a single cx-gate and single-qubit gates. + # For backends with native gate sets consisting of some set of single-qubit gates and either the cx, cz or cy, + # unrolling the circuit to the ["u3", "cx"] basis, amplifying the cx-gates, then unrolling back to the native + # gate set and doing a single-qubit optimization transpiler pass, is thus still general. - unroller = Unroller(["u1","u2","u3","cx"]) - pm = PassManager(unroller) + unroller_ugatesandcx = Unroller(["u1", "u2", "u3", "cx"]) + pm = PassManager(unroller_ugatesandcx) unrolled_qc = pm.run(qc) @@ -139,215 +470,320 @@ def noise_amplify_and_pauli_twirl_cnots(self, qc: QuantumCircuit, amp_factor: in new_qc = QuantumCircuit.from_qasm_str(new_circuit_qasm_str) - # The "Optimize1qGates" transpiler pass optimizes chains of single-qubit gates by collapsing them into - # a single, equivalent u3-gate. We want to collapse unnecessary single-qubit gates, but not CNOT-gates, as - # these give us the noise amplification. + # The "Optimize1qGates" transpiler pass optimizes adjacent single-qubit gates, for a native gate set with the + # u3 gates it collapses any chain of adjacent single-qubit gates into a single, equivalent u3-gate. + # We want to collapse unnecessary single-qubit gates to minimize circuit depth, but not CNOT-gates + # as these give us the noise amplification. + unroller_backendspecific = Unroller(self.backend.configuration().basis_gates) optimize1qates = Optimize1qGates() - pm = PassManager(optimize1qates) + + pm = PassManager([unroller_backendspecific, optimize1qates]) return pm.run(new_qc) def transpile_circuit(self, qc: QuantumCircuit, custom_pass_manager: PassManager = None) -> QuantumCircuit: """ - Transpile and optimize the quantum circuit using qiskits PassManager class and the level_3_pass_manager, - which contains the transpiler passes for the optimalization level 3 preset (the preset with highest - level of optimization). + Transpile and optimize the input circuit, optionally by using a custom pass manager. + If no custom pass manager is given, the optimization_level = 3 preset for the qiskit transpiler, + the heaviest optimization preset, will be used. As we want to add additional CNOTs for noise amplification and possibly additional single qubit gates - for Pauli twirling, we need to transpile the circuit before, to avoid the additional gates to be removed - by the transpiler. + for Pauli twirling, we need to transpile the circuit before both the noise amplification is applied and + before circuit execution. This is to avoid the additional CNOT-gates beinng removed by the transpiler. The Optimize1qGates transpiler pass will be used later to optimize single qubit gates added during - the Pauli-twirling - - :return: The transpiled circuit + the Pauli-twirling, as well as the Unroller pass which merely decomposes the given circuit gates into + the given set of basis gates. + + Parameters + ---------- + qc : qiskit.QuantumCircuit + The original bare quantum circuit. + custom_pass_manager : qiskit.transpiler.PassManager, (optional) + A custom pass manager to be used in transpiling. + + Returns + ------- + transpiled_circuit : qiskit.QuantumCircuit + The transpiled quantum circuit. """ - if custom_pass_manager == None: + if custom_pass_manager is None: pass_manager_config = PassManagerConfig(basis_gates=["id", "u1", "u2", "u3", "cx"], - coupling_map=CouplingMap(self.backend.configuration().coupling_map), backend_properties=self.backend.properties()) + if not self.is_simulator: + pass_manager_config.coupling_map = CouplingMap(self.backend.configuration().coupling_map) + pass_manager = level_3_pass_manager(pass_manager_config) else: pass_manager = custom_pass_manager - self.passes = pass_manager.passes() + self.passes = pass_manager.passes() # Saves the list of passes used for transpiling - return pass_manager.run(qc) + transpiled_circuit = pass_manager.run(qc) - def execute_circuits(self, circuits: list) -> list: - """ - Execute all circuits and return measurement counts. If shots > 8192, we need to partition the execution - into several sub-executions. + # As there is some randomness involved in the qiskit transpiling we might want to save + # the specific transpiled circuit that is used in order to access it later. + if self.save_results: + filename = self.experiment_name + ".circuit" + self.write_to_file(filename, transpiled_circuit) + + return transpiled_circuit - :param circuits: All circuits to be executed - :return: A list of count-dictionaries + def execute_circuit(self, qc: QuantumCircuit, shots=None) -> Result: """ + Execute a single experiment consisting of the execution of a quantum circuit over a specified number of shots. + One experiment may need to be partitioned into a set of several identical circuit executions. This is due to the + IBMQ quantum devices limiting circuit executions to a maximum of 8192 shots per. + + Parameters + ---------- + qc : qiskit.QuantumCircuit + The specific quantum circuit to be executed. + shots : int, (optional) + The number of shots of the circuit execution. If none is passed, self.shots is used. + Returns + ------- + circuit_measurement_results : qiskit.result.result.Result + A Result object containing the data and measurement results for the circuit executions. + """ + + if shots is None: + shots, repeats = self.partition_shots(self.shots) + else: + shots, repeats = self.partition_shots(shots) # The max number of shots on a single execution on the IBMQ devices is 8192. # If shots > 8192, we have to partition the execution into several sub-executions. - execution_circuits = [] - for qc in circuits: - execution_circuits += [qc.copy() for i in range(self.num_executions)] + # Note that several circuits can be entered into the IBMQ queue at once by passing them in a list. + execution_circuits = [qc.copy() for i in range(repeats)] - # - - if self.noise_model == None: - counts = execute(execution_circuits, backend=self.backend, - pass_manager=PassManager(), shots=self.shots).result().get_counts() + # non-simulator backends throws "unexpected argument" exception when passing noise_model argument to them + if self.is_simulator: + job = execute(execution_circuits, backend=self.backend, noise_model=self.noise_model, + pass_manager=PassManager(), shots=shots) else: - counts = execute(execution_circuits, backend=self.backend, noise_model=self.noise_model, - pass_manager=PassManager(), shots=self.shots).result().get_counts() + job = execute(execution_circuits, backend=self.backend, + pass_manager=PassManager(), shots=shots) - self.counts = counts # Saving the counts in a member variable. Might remove. + circuit_measurement_results = job.result() - return counts + return circuit_measurement_results - def compute_exp_vals(self, counts: list) -> ndarray: - """ - From the given exp_val_func, which computes the expectation value as a function of measurement counts, we - compute the exp val of all executed circuits taking into account that we might have partitioned up circuit - executions due to IBMQ's restriction of shots<=8192 per execution. + # Functions involved in computing the noise amplified and mitigated expectation values and related measures. - :param counts: A list of measurement counts-dictionaries - :return: A list of computed expectation values + def compute_exp_val(self, result: Result) -> (float, float, ndarray): + """ + Compute the expectation value and variance for a set of circuit executions. We assume that all separate circuit + execution was run with the same number of shots. + + Parameters + ---------- + result : qiskit.result.result.Result + A qiskit Result object containing all measurement results from a set of quantum circuit executions. + + Returns + ------- + averaged_experiment_exp_vals, averaged_experiment_variances experiment_exp_vals : Tuple[float, numpy.ndarray] + The final estimated experiment expectation value and variance, averaged over all circuit sub-executions, + and a numpy array containing the expectation values for each circuit sub-execution. """ - n_distinct_circuits = int(len(counts) / self.num_executions) - exp_vals = zeros(n_distinct_circuits, dtype=float) + experiment_results = result.results - for i in range(n_distinct_circuits): - exp_val_k = 0 - for k in range(self.num_executions): - exp_val_k += self.exp_val_func(counts[i*self.num_executions + k]) - exp_vals[i] = exp_val_k / self.num_executions - return exp_vals + experiment_exp_vals, experiment_variances = self.exp_val_func(experiment_results, self.exp_val_filter) - def extrapolate(self, exp_vals, noise_amplification_factors=None, n_amp_factors=None, - custom_extrapolation_func=None) -> float: - """ - Do extrapolation to the zero-noise case based on the expectation values measured from the - noise amplified circuits. + return average(experiment_exp_vals), average(experiment_variances), asarray(experiment_exp_vals) - :param exp_vals: Expectation values in an array of length n_amp_factors - :param noise_amplification_factors: Optional custom noise amplification factors - :param n_amp_factors: Number of amplification factors to be included in the extrapolation - :param custom_extrapolation_func: - :return: Extrapolated/mitigated expectation value + def compute_error_controlled_exp_val(self, noise_amplified_qc: QuantumCircuit, gamma_coeff: float, shots: int = None, + conf_index: int = 2, verbose: bool = False) -> (float, float, float): """ - if noise_amplification_factors == None: - noise_amplification_factors = self.noise_amplification_factors - if n_amp_factors == None: - n_amp_factors = self.n_amp_factors + Handles optional error controlled sampling of the quantum circuit. Returns the resulting estimated expectation + value and variance, and the total number of shots used. - # Sanity checks. For now, only prints for debugging purposes - if shape(noise_amplification_factors)[0] < n_amp_factors: - print("Noise amplification factors is of shape", shape(noise_amplification_factors), - "but must be of length equal or greater than n_amp_factors=",n_amp_factors) - if shape(exp_vals)[0] < n_amp_factors: - print("Array of exp vals is of shape", shape(noise_amplification_factors), - "but must be of length equal or greater than n_amp_factors=", n_amp_factors) - - if custom_extrapolation_func == None: - return richardson_extrapolate(asarray(exp_vals[0:n_amp_factors]), - asarray(noise_amplification_factors[0:n_amp_factors])) - else: - return custom_extrapolation_func(asarray(exp_vals[0:n_amp_factors]), - asarray(noise_amplification_factors[0:n_amp_factors])) + Parameters + ---------- + noise_amplified_qc: qiskit.QuantumCircuit + gamma_coeff: float + shots: int + conf_index: int + verbose: bool - def extrapolate_array(self, all_exp_vals, noise_amplification_factors=None, - extrapolation_method=None, n_amp_factors=None) -> ndarray: - """ - Redo the extrapolation to the zero-noise limit for an array of runs. + Returns + ------- + exp_val, variance, shots: float, float, int - :param all_exp_vals: - :param noise_amplification_factors: - :param extrapolation_method: - :param n_amp_factors: - :return: Array of mitigated expectation values for each run """ - if noise_amplification_factors != None and n_amp_factors == None: - n_amp_factors = shape(noise_amplification_factors)[0] - results = zeros(shape(all_exp_vals)[0]) - for i in range(shape(all_exp_vals)[0]): - results[i] = self.extrapolate(all_exp_vals[i], noise_amplification_factors, - extrapolation_method, n_amp_factors) - return results + if shots is None: + shots = self.shots - def mitigate(self, repeats: int = 1, verbose: bool = False) -> float: - """ + result = self.execute_circuit(qc=noise_amplified_qc, shots=shots) + exp_val, variance, _ = self.compute_exp_val(result) - :param repeats: Number of repeats of the extrapolation to perform. The result is averaged over all repeats. - :param verbose: Prints during the computation, True / False - :return: The mitigated expectation value - """ + if not self.error_controlled_sampling: + return exp_val, variance, shots + + if verbose: + print("Error controlled sampling, " + + "min_shots={:}, max_shots={:}, error_tol={:}, conf_index={:}".format(shots, self.max_shots, + self.error_tol, conf_index)) - n_amp_factors = shape(self.noise_amplification_factors)[0] + total_shots = int(self.n_amp_factors * (gamma_coeff**2) * (conf_index**2) * (variance / self.error_tol**2)) if verbose: - print("shots=", self.shots, ", n_amp_factors=", self.n_amp_factors, ", paulitwirl=", self.pauli_twirl, - " repeats=", repeats, sep="") - print("noise amplification factors=", self.noise_amplification_factors, sep="") + print("Variance={:.4f}, gamma_coeff={:} need a total of {:} shots for convergence.".format(variance, + gamma_coeff, + total_shots)) + + if total_shots <= shots: + return exp_val, variance, shots + elif total_shots > self.max_shots: + total_shots = self.max_shots + + new_shots = int(total_shots - shots) if verbose: - print("Constructing circuits") + print("Executing {:} additional shots.".format(new_shots)) + + result = self.execute_circuit(qc=noise_amplified_qc, shots=new_shots) + + new_exp_val, new_variance, _ = self.compute_exp_val(result) - circuits = [] + error_controlled_exp_val = (shots/total_shots) * exp_val + (new_shots/total_shots) * new_exp_val + error_controlled_variance = (shots/total_shots) * variance + (new_shots/total_shots) * new_variance - for i in range(repeats): + return error_controlled_exp_val, error_controlled_variance, total_shots - if verbose and ((i + 1) % 25 == 0): - print(i+1,"/",repeats) + def compute_noise_amplified_exp_val(self, amp_factor, gamma_coeff, verbose: bool = False): + """ + Creates the noise amplified circuit for a given amplification factors and computes the corresponding estimated + expectation value and variance. + + Parameters + ---------- + amp_factor: int + gamma_coeff: float + verbose: bool - for j, amp_factor in enumerate(self.noise_amplification_factors): - circuits.append(self.noise_amplify_and_pauli_twirl_cnots(qc=self.qc, amp_factor=amp_factor, - pauli_twirl=self.pauli_twirl)) - if i == 0: - self.depths[j] = circuits[-1].depth() + Returns + ------- + noise_amplified_result: NoiseAmplifiedResult + + """ + noise_amplified_qc = self.noise_amplify_and_pauli_twirl_cnots(qc=self.qc, amp_factor=amp_factor, + pauli_twirl=self.pauli_twirl) if verbose: - print("Depths=",self.depths, sep="") + print("Circuit created. Depth = {:}. Executing.".format(noise_amplified_qc.depth())) - print("Executing circuits") + exp_val, variance, total_shots = self.compute_error_controlled_exp_val(noise_amplified_qc, + gamma_coeff=gamma_coeff, + shots=self.shots, verbose=verbose) - counts = self.execute_circuits(circuits) + noise_amplified_result = NoiseAmplifiedResult(amp_factor=amp_factor, shots=total_shots, + qc=noise_amplified_qc, depth=noise_amplified_qc.depth(), + exp_val=exp_val, variance=variance) + return noise_amplified_result - exp_vals = self.compute_exp_vals(counts) + def estimate_error(self) -> float: + """ + Estimate the error in the mitigated expectation value based on the variance found in the noise amplified circuit + executions. - # Process the resulting expectation values: + Returns + ------- + error: float + Estimated error in the mitigated expectation value. + """ + error = 0 + for i, amp_res in enumerate(self.noise_amplified_results): + variance, shots = amp_res.variance, amp_res.shots + gamma_coeff = self.gamma_coefficients[i] - self.bare_exp_vals = zeros((repeats,)) - self.all_exp_vals = zeros((repeats,n_amp_factors)) - self.mitigated_exp_vals = zeros((repeats,)) + error += gamma_coeff**2 * (variance / shots) - if verbose: - print("Processing results:") + error = sqrt(error) - if repeats == 1: - self.result = richardson_extrapolate(self.all_exp_vals[0,:], self.noise_amplification_factors) - else: - for i in range(repeats): - self.bare_exp_vals[i] = exp_vals[i*n_amp_factors] + return error + + def mitigate(self, verbose: bool = False) -> float: + """ + Perform the full quantum error mitigation procedure. - for j in range(n_amp_factors): - self.all_exp_vals[i, j] = exp_vals[i*n_amp_factors + j] + Parameters + ---------- + verbose : bool + Do prints throughout the computation. - mitigation_results = richardson_extrapolate(self.all_exp_vals[i, :], self.noise_amplification_factors) - self.mitigated_exp_vals[i] = mitigation_results + Returns + ------- + result : float + The mitigated expectation value. + """ - self.result = sum(self.mitigated_exp_vals) / shape(self.mitigated_exp_vals)[0] + for i, amp_factor in enumerate(self.noise_amplification_factors): - if verbose: - print("Mitigation done. Result:") - print("Bare exp val =", average(self.bare_exp_vals)) - print("Mitigated exp val =",self.result) + if verbose: + print("Amplification factor = {:}.".format(amp_factor)) + + noise_amplified_result, result_read_from_file = None, False + + # If self.save_results=True, attempt to read noise amplified result from disk + if self.save_results: + temp = self.read_from_file(filename=self.experiment_name + "_r{:}.result".format(amp_factor)) + if (temp is not None) and (type(temp) is NoiseAmplifiedResult): + noise_amplified_result = temp + result_read_from_file = True + if verbose: + print("Noise amplified result successfully read from disk.") + else: + if verbose: + print("Tried to read results from disk, but results were not found.") + + gamma_coeff = self.gamma_coefficients[i] + + if not result_read_from_file: + noise_amplified_result = self.compute_noise_amplified_exp_val(amp_factor=amp_factor, + gamma_coeff=gamma_coeff, + verbose=verbose) + + if self.save_results: + self.write_to_file(filename=self.experiment_name + "_r{:}.result".format(amp_factor), + data=noise_amplified_result) + if verbose: + "Noise amplified result successfully written to disk." + + self.noise_amplified_results[i] = noise_amplified_result - return self.result + if verbose: + print("Noise amplified exp val = {:.8f}, ".format(noise_amplified_result.exp_val) + + "variance = {:.8f}, ".format(noise_amplified_result.variance) + + "total shots executed = {:}.".format(noise_amplified_result.shots)) + mitigated_exp_val = self.extrapolate(self.noise_amplified_exp_vals) -# PAULI TWIRLING AND NOISE AMPLIFICATION HELP FUNCTIONS + self.result = ZeroNoiseExtrapolationResult(qc=self.qc, + noise_amplified_results=self.noise_amplified_results, + noise_amplification_factors=self.noise_amplification_factors, + gamma_coefficients=self.gamma_coefficients, + exp_val=mitigated_exp_val + ) + + if verbose: + print("-----\nERROR MITIGATION DONE\n" + + "Bare circuit expectation value: {:.8f}\n".format(self.result.bare_exp_val) + + "Noise amplified expectation values: {:}\n".format(self.result.noise_amplified_exp_vals) + + "Circuit depths: {:}\n".format(self.result.depths) + + "-----\n" + + "Mitigated expectation value: {:.8f}\n".format(self.result.exp_val)) + + return mitigated_exp_val + +""" +--- PAULI TWIRLING AND NOISE AMPLIFICATION HELP FUNCTIONS +""" # Conversion from pauli x/y/z-gates to physical u1/u3-gates in correct OpenQASM-format PHYSICAL_GATE_CONVERSION = {"X": "u3(pi,0,pi)", "Z": "u1(pi)", "Y": "u3(pi,pi/2,pi/2)"} @@ -355,15 +791,22 @@ def mitigate(self, repeats: int = 1, verbose: bool = False) -> float: def find_qreg_name(circuit_qasm: str) -> str: """ - Finds the name of the quantum register in the circuit. + Finds the name of the quantum register in the circuit. Assumes a single quantum register. + + Parameters + ---------- + circuit_qasm : str + The OpenQASM-string for the circuit - :param circuit_qasm: OpenQASM string with instructions for the entire circuit - :return: Name of the quantum register + Returns + ------- + qreg_name :str + The name of the quantum register """ for line in circuit_qasm.splitlines(): if line[0:5] == "qreg ": qreg_name = "" - for i in range(5,len(line)): + for i in range(5, len(line)): if line[i] == "[" or line[i] == ";": break elif line[i] != " ": @@ -373,16 +816,23 @@ def find_qreg_name(circuit_qasm: str) -> str: def find_cnot_control_and_target(qasm_line: str) -> (int, int): """ - Find indices of control and target qubits for the CNOT-gate in question + Find the indices of the control and target qubits for a specific CNOT-gate. - :param qasm_line: OpenQASM line containing the CNOT - :return: Indices of control and target qubits + Parameters + ---------- + qasm_line : str + The line containing the CNOT-gate in question taken from the OpenQASM-format string of the quantum circuit. + + Returns + ------- + control, target : Tuple[int, int] + qubit indices for control and target qubits """ qubits = [] for i, c in enumerate(qasm_line): if c == "[": qubit_nr = "" - for j in range(i+1, len(qasm_line)): + for j in range(i + 1, len(qasm_line)): if qasm_line[j] == "]": break qubit_nr += qasm_line[j] @@ -392,7 +842,8 @@ def find_cnot_control_and_target(qasm_line: str) -> (int, int): def propagate(control_in: str, target_in: str): """ - Propagates Pauli gates through a CNOT in accordance with the following circuit identities: + Finds the c,d gates such that (a x b) CNOT (c x d) = CNOT for an ideal CNOT-gate, based on the a (control_in) + and b (target_in) pauli gates by "propagating" the a,b gates over a CNOT-gate by the following identities: (X x I) CNOT = CNOT (X x X) (I x X) CNOT = CNOT (I x X) @@ -400,11 +851,18 @@ def propagate(control_in: str, target_in: str): (I x Z) CNOT = XNOT (Z x Z) Note that instead of Pauli-twirling with [X,Z,Y] we use [X,Z,XZ] where XZ = -i*Y. - The inverse of XZ is ZX = -XZ = i*Y. Propagating over the CNOT, the complex factors cancels. - - :param control_in: Pauli gates on control qubit before CNOT - :param target_in: Pauli gates on target qubit before CNOT - :return: Equivalent Pauli gates on control and target qubits after CNOT + The inverse of XZ is ZX = -XZ = i*Y. The factors of plus minus i are global phase factors which can be ignored. + + Parameters + ---------- + control_in : str + The Pauli operator on control qubit before the CNOT, i.e., a + target_in : str + The Pauli operator on target qubit before the CNOT, i.e., b + Returns + ------- + control_out, target_out : Tuple[str, str] + The operators c and d such that (a x b) CNOT (c x d) = CNOT """ control_out, target_out = '', '' @@ -443,17 +901,26 @@ def propagate(control_in: str, target_in: str): def apply_qasm_pauli_gate(qreg_name: str, qubit: int, pauli_gates: str): """ - Construct a OpenQASM-string with the instruction to apply the given pauli gates to - the given qubit - - :param qreg_name: Name of quantum register - :param qubit: Index of qubit - :param pauli_gates: The Pauli gates to be applied - :return: The OpenQASM-string with the instruction + Construct an OpenQASM-string line with the given Pauli-gates applid to the given qubit. + + Parameters + ---------- + qreg_name :str + The name of the qiskit.QuantumRegister containing the qubit. + qubit : int + The index of the qubit. + pauli_gates : str + A string determining the Pauli-gates to be applied. Must be a sequence the characters I, X, Y and/or Z. + Returns + ------- + new_qasm_line : str + An OpenQASM string with the Pauli-gates applied to the qubit. """ new_qasm_line = '' for gate in pauli_gates: if gate != 'I': + if gate not in PHYSICAL_GATE_CONVERSION.keys(): + raise Exception("Invalid Pauli-gate used in Pauli-twirl: {:}".format(gate)) u_gate = PHYSICAL_GATE_CONVERSION[gate] new_qasm_line += u_gate + ' ' + qreg_name + '[' + str(qubit) + '];' + '\n' return new_qasm_line @@ -461,13 +928,28 @@ def apply_qasm_pauli_gate(qreg_name: str, qubit: int, pauli_gates: str): def pauli_twirl_cnot_gate(qreg_name: str, qasm_line_cnot: str) -> str: """ - Pauli-twirl a CNOT-gate from the given OpenQASM string line containing the CNOT. - This will look something like: cx q[0],q[1]; - - :param qreg_name: Name of quantum register - :param qasm_line_cnot: OpenQASM-line containing the CNOT to pauli twirl - :return: + Pauli-twirl a specific CNOT-gate. This involves drawing two random Pauli-gates a and b, picked from the single-qubit + Pauli set {Id, X, Y, Z}, then determining the corresponding two Pauli-gates c and d such that + (a x b) * CNOT * (c x d) = CNOT, for an ideal CNOT. + + The original CNOT gates is then replaced by the gate ((a x b) * CNOT * (c x d)). This transforms the noise in the + CNOT-gate into stochastic Pauli-type noise. An underlying assumption is that the noise in the single-qubit Pauli + gates is negligible to the noise in the CNOT-gates. + + Parameters + ---------- + qreg_name : str + The name of the qiskit.QuantumRegister for the qubits in question. + qasm_line_cnot : str + The OpenQASM-string line containing the CNOT-gate. + + Returns + ------- + new_qasm_line : str + A new OpenQASM-string section to replace the aforementioned OpenQASM line containing the CNOT-gate, where not + the CNOT-gate has been Pauli-twirled. """ + control, target = find_cnot_control_and_target(qasm_line_cnot) # Note: XZ = -i*Y, with inverse (XZ)^-1 = ZX = i*Y. This simplifies the propagation of gates a,b over the CNOT @@ -493,11 +975,17 @@ def pauli_twirl_cnot_gate(qreg_name: str, qasm_line_cnot: str) -> str: def pauli_twirl_cnots(qc: QuantumCircuit) -> QuantumCircuit: """ - General function for Pauli-twirling all CNOT-gates in a quantum circuit. - Included for completeness. + Pauli-twirl all CNOT-gates in a general quantum circuit. This function is included here for completeness. - :param qc: quantum circuit for which to Pauli twirl all CNOT gates - :return: Pauli twirled quantum circuit + Parameters + ---------- + qc : qiskit.QuantumCircuit + The original quantum circuit. + + Returns + ------- + pauli_twirled_qc : qiskit.QuantumCircuit + The quantum circuit where all CNOT-gates have been Pauli-twirled. """ # The circuit may be expressed in terms of various types of gates. @@ -532,31 +1020,53 @@ def pauli_twirl_cnots(qc: QuantumCircuit) -> QuantumCircuit: return pm.run(new_qc) - -# Richardson extrapolation: -def richardson_extrapolate(E: ndarray, c: ndarray) -> float: +def noise_amplify_cnots(qc: QuantumCircuit, amp_factor: int): """ - Code taken from github.com/OpenQuantumComputing/error_mitigation/ -> zero_noise_extrapolation.py and slightly modified - :param E: Expectation values - :param c: Noise amplification factors - :return: Extrapolation to the zero-limit + Noise amplify all CNOT-gates in the given QuantumCircuit by expanding each CNOT-gate as CNOT -> CNOT^a, where a is + the noise amplification factor, a = 2*n - 1. Included here for completeness. + + Parameters + ---------- + qc: qiskit.QuantumCircuit + Quantum circuit to be noise amplified + amp_factor: + The noise amplification factor. Must be odd + Returns + ------- + noise_amplified_qc: qiskit.QuantumCircuit + The noise amplified circuit """ - if isinstance(E, list): - E = asarray(E) - if isinstance(E, list): - c = asarray(c) - - n = E.shape[0] - if c.shape[0] != n: - raise ValueError('E and c must have the same dimension.') - if n <= 1: - raise ValueError('the dimension of E and c must be larger than 1.') - A = zeros((n, n)) - b = zeros((n, 1)) - # must sum to 1 - A[0, :] = 1 - b[0] = 1 - for k in range(1, n): - A[k, :] = c ** k - x = solve(A, b) - return dot(transpose(E), x)[0] \ No newline at end of file + + if (amp_factor - 1) % 2 != 0: + raise Exception("Invalid amplification factors", amp_factor) + + # The circuit may be expressed in terms of various types of gates. + # The 'Unroller' transpiler pass 'unrolls' (decomposes) the circuit gates to be expressed in terms of the + # physical gate set [u1,u2,u3,cx] + + # The cz, cy (controlled-Z and -Y) gates can be constructed from a single cx-gate and single-qubit gates. + # For backends with native gate sets consisting of some set of single-qubit gates and either the cx, cz or cy, + # unrolling the circuit to the ["u3", "cx"] basis, amplifying the cx-gates, then unrolling back to the native + # gate set and doing a single-qubit optimization transpiler pass, is thus still general. + + unroller_ugatesandcx = Unroller(["u", "cx"]) + pm = PassManager(unroller_ugatesandcx) + + unrolled_qc = pm.run(qc) + + circuit_qasm = unrolled_qc.qasm() + new_circuit_qasm_str = "" + + # qreg_name = find_qreg_name(circuit_qasm) + + for i, line in enumerate(circuit_qasm.splitlines()): + if line[0:2] == "cx": + for j in range(amp_factor): + new_circuit_qasm_str += line + "\n" + else: + new_circuit_qasm_str += line + "\n" + + new_qc = QuantumCircuit.from_qasm_str(new_circuit_qasm_str) + + return new_qc +