From fcf85f7632fdbfe1818dfcfadcb266a4efc2f855 Mon Sep 17 00:00:00 2001 From: ashsaki Date: Wed, 26 Jun 2024 21:16:54 -0400 Subject: [PATCH 1/3] zne challenge-1 automation --- .../zne/automated_zne_challenge1.py | 218 ++++++++++++++++++ docs/challenges/automation/zne/circuit.py | 39 ++++ 2 files changed, 257 insertions(+) create mode 100644 docs/challenges/automation/zne/automated_zne_challenge1.py create mode 100644 docs/challenges/automation/zne/circuit.py diff --git a/docs/challenges/automation/zne/automated_zne_challenge1.py b/docs/challenges/automation/zne/automated_zne_challenge1.py new file mode 100644 index 0000000..dcb2402 --- /dev/null +++ b/docs/challenges/automation/zne/automated_zne_challenge1.py @@ -0,0 +1,218 @@ +import itertools +import json +import numpy as np +import os +import seaborn as sns +import matplotlib.pyplot as plt + +from qiskit.quantum_info import SparsePauliOp +from qiskit_ibm_runtime import Batch, EstimatorV2 as Estimator +from qiskit_ibm_runtime.fake_provider import FakeSherbrooke +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager +from qiskit_aer import AerSimulator +from qiskit_ibm_runtime import RuntimeEncoder, RuntimeDecoder +from datetime import datetime, timezone + +from circuit import ExampleCircuit + +def create_logical_circuit(num_qubits, depth, seed=0): + logical_circuit = ExampleCircuit(q, d // 2) # Halved depth + + # Compute-uncompute construct (doubles the depth) + inverse = logical_circuit.inverse() + logical_circuit.barrier() + logical_circuit.compose(inverse, inplace=True) + + # Parameter values + rng = np.random.default_rng(seed=0) + parameter_values = rng.uniform(-np.pi, np.pi, size=logical_circuit.num_parameters) + parameter_values[0] = 0.3 # Fix interaction strength (specific to MBL circuit) + logical_circuit.assign_parameters(parameter_values, inplace=True) + + return logical_circuit, parameter_values + +def create_wt1_logical_operator(num_qubits): + paulis = ['I'*i + 'Z' + 'I'*(num_qubits-i-1) for i in range(num_qubits)] + coeffs = 1/len(paulis) + + return SparsePauliOp(paulis, coeffs) + +def heatmap_plotter( + rel_err, + widths, + depths, + filename, + title, + directory, + xlabel="2-qubit depth", + ylabel="Number of qubits", +): + nrows = len(widths) + ncols = len(depths) + + ax = sns.heatmap(rel_err, annot=True, cbar=False, vmin=0, vmax=100, cmap="binary", fmt=".0f") + # Drawing the frame + ax.axhline(y=0, color='k', linewidth=2) + + ax.axhline(y=nrows, color='k', linewidth=2) + + ax.axvline(x=0, color='k', linewidth = 2) + + ax.axvline(x=ncols, color='k', linewidth=2) + + xticks = np.array(list(range(ncols))) + 0.5 + ax.set_xticks(ticks=xticks) + ax.set_xticklabels(labels=depths) + + yticks = np.array(list(range(nrows))) + 0.5 + ax.set_yticks(ticks=yticks) + ax.set_yticklabels(labels=widths[::-1]) + + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + + # plt.show() + + plt.savefig( + f"{directory}/{filename}", + bbox_inches="tight", + dpi=200, + ) + + plt.close() + +if __name__ == "__main__": + num_qubits = [2, 4, 8] + depths = [8, 16, 32, 64] + extrapolators = ["exponential", "polynomial_degree_2", "linear", ("exponential", "linear")] + backend = FakeSherbrooke() + # backend = AerSimulator.from_backend(backend) + # backend = AerSimulator(method="matrix_product_state") + + # create all circuits and observables + logical_circuits = [] + logical_observables = [] + circuit_parameters = [] + for q in num_qubits: + for d in depths: + logical_circuit, parameter_values = create_logical_circuit(num_qubits=q, depth=d, seed=0) + logical_circuits.append(logical_circuit) + circuit_parameters.append(parameter_values.tolist()) + + logical_observable = create_wt1_logical_operator(num_qubits=q) + logical_observables.append(logical_observable) + + # optimize circuit and observables + pm = generate_preset_pass_manager(optimization_level=3, backend=backend) + physical_circuits = pm.run(logical_circuits) + + physical_observables = [ + logical_observables[idx].apply_layout(layout=physical_circuits[idx].layout) + for idx in range(len(logical_observables)) + ] + + pubs = list(zip(physical_circuits, physical_observables)) + + timestamp = datetime.now(timezone.utc) + with Batch(backend=backend) as batch: + estimator = Estimator(mode=batch) + options = estimator.options + options.default_shots = 1000 + options.optimization_level = 0 + options.resilience_level = 0 + options.resilience.zne_mitigation = True # Activate ZNE error mitigation only + + jobs = {} + for extrapolator in extrapolators: + options.resilience.zne.extrapolator = extrapolator + job = estimator.run(pubs) + jobs[str(extrapolator)] = job + print(f" - {job.job_id()} ({extrapolator})") + + + results = {} + tmp = list(itertools.product(num_qubits, depths)) + expvals_all = {str(extrapolator): np.empty(len(tmp)) for extrapolator in extrapolators} + for idx, (qubit, depth) in enumerate(tmp): + label = f"pub_{idx}" + results[label] = {} + results[label]["num_qubits"] = qubit + results[label]["depth"] = depth + + # physical circuit is encoded using `RuntimeEncoder`. Use `RuntimeDecoder` to decode + encoded_physical_circuit = RuntimeEncoder().encode(physical_circuits[idx]) + results[label]["physical_circuit"] = encoded_physical_circuit + + obs = physical_observables[idx] + paulis = obs.paulis.to_labels() + coeffs = [str(coeff) for coeff in obs.coeffs] + results[label]["physical_observable"] = { + "paulis": paulis, + "coeffs": coeffs + } + + # layout + layout = physical_circuits[idx].layout + final_layout = None if layout is None else layout.final_index_layout(filter_ancillas=True) + results[label]["final_qubit_layout"] = final_layout + results[label]["circuit_parameters"] = circuit_parameters[idx] + + results[label]["expvals"] = {} + results[label]["job_ids"] = {} + + for extrapolator in extrapolators: + extrapolator = str(extrapolator) + job = jobs[extrapolator] + + primtive_results = job.result() + results[label]["job_ids"][extrapolator] = job.job_id() + + pub_result = primtive_results[idx] + evs = pub_result.data.evs.tolist() + expvals_all[extrapolator][idx] = evs + + results[label]["expvals"][extrapolator] = evs + + all_data = { + "num_qubits_list": num_qubits, + "depths": depths, + "extrapolators": extrapolators, + "batch_id": batch.session_id, + "job_ids": [job.job_id() for job in jobs.values()], + "backend_name": backend.name, + "timestamp": timestamp.isoformat(), + "results": results + } + + + name_signature = f"challenge_1_{timestamp.strftime('%Y_%m_%d_%H_%M_%S_%f')}" + name_signature = "1" + if not os.path.exists(name_signature): + os.mkdir(name_signature) + + with open(f"{name_signature}/data_{name_signature}.json", "w") as jf: + json.dump(all_data, jf, indent=2, sort_keys=False) + + # plot heatmaps + for extrapolator in extrapolators: + extrapolator_str = str(extrapolator) + + evs = np.flipud( + expvals_all[extrapolator_str].reshape((len(num_qubits), len(depths))) + ) + rel_err = 100 * (1 - evs) + + if isinstance(extrapolator, str): + extrapolator = [extrapolator] + + heatmap_plotter( + rel_err, + widths=num_qubits, + depths=depths, + filename=f"rel_err_{name_signature}_{'_'.join(extrapolator)}.png", + title=r'Error (%): ' + r'$\overline{\langle{Z_{q}}\rangle}$', + directory=name_signature, + xlabel="2-qubit depth", + ylabel="Number of qubits", + ) diff --git a/docs/challenges/automation/zne/circuit.py b/docs/challenges/automation/zne/circuit.py new file mode 100644 index 0000000..ff71e50 --- /dev/null +++ b/docs/challenges/automation/zne/circuit.py @@ -0,0 +1,39 @@ +from numpy import pi +from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit + +class ExampleCircuit(QuantumCircuit): + """Parameterized MBL non-periodic chain (i.e. 1D) quantum circuit. + + Parameters correspond to interaction strength (θ), and + disorders vector (φ) with one entry per qubit. In 1D, + θ < 0.16π ≈ 0.5 corresponds to the MBL regime; beyond such + critical value the dynamics become ergodic (i.e. thermal). + Disorders are random on a qubit by qubit basis [1]. + + Args: + num_qubits: number of qubits (must be even). + depth: two-qubit depth. + barriers: if True adds barriers between layers + + Notes: + [1] Shtanko et.al. Uncovering Local Integrability in Quantum + Many-Body Dynamics, https://arxiv.org/abs/2307.07552 + """ + + def __init__(self, num_qubits: int, depth: int, *, barriers: bool = False) -> None: + super().__init__(num_qubits) + + theta = Parameter("θ") + phis = ParameterVector("φ", num_qubits) + + self.x(range(1, num_qubits, 2)) + for layer in range(depth): + layer_parity = layer % 2 + if barriers and layer > 0: + self.barrier() + for qubit in range(layer_parity, num_qubits - 1, 2): + self.cz(qubit, qubit + 1) + self.u(theta, 0, pi, qubit) + self.u(theta, 0, pi, qubit + 1) + for qubit in range(num_qubits): + self.p(phis[qubit], qubit) \ No newline at end of file From 73ca8b2708135648c8f3c269b5a32d132c526b41 Mon Sep 17 00:00:00 2001 From: ashsaki Date: Thu, 27 Jun 2024 09:09:07 -0400 Subject: [PATCH 2/3] heatmap plots --- .../automation/zne/automated_zne_challenge1.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/challenges/automation/zne/automated_zne_challenge1.py b/docs/challenges/automation/zne/automated_zne_challenge1.py index dcb2402..be79086 100644 --- a/docs/challenges/automation/zne/automated_zne_challenge1.py +++ b/docs/challenges/automation/zne/automated_zne_challenge1.py @@ -47,6 +47,7 @@ def heatmap_plotter( xlabel="2-qubit depth", ylabel="Number of qubits", ): + plt.rcParams.update({"text.usetex": True, "font.family": "Helvetica"}) nrows = len(widths) ncols = len(depths) @@ -83,12 +84,12 @@ def heatmap_plotter( plt.close() if __name__ == "__main__": - num_qubits = [2, 4, 8] - depths = [8, 16, 32, 64] + num_qubits = [4, 8, 16, 32, 64] + depths = [4, 8, 16, 32, 64] extrapolators = ["exponential", "polynomial_degree_2", "linear", ("exponential", "linear")] - backend = FakeSherbrooke() + # backend = FakeSherbrooke() # backend = AerSimulator.from_backend(backend) - # backend = AerSimulator(method="matrix_product_state") + backend = AerSimulator(method="matrix_product_state") # create all circuits and observables logical_circuits = [] @@ -211,7 +212,7 @@ def heatmap_plotter( widths=num_qubits, depths=depths, filename=f"rel_err_{name_signature}_{'_'.join(extrapolator)}.png", - title=r'Error (%): ' + r'$\overline{\langle{Z_{q}}\rangle}$', + title=r'Error (\%): ' + r'$\overline{\langle{Z_{q}}\rangle}$' + f' {extrapolator}', directory=name_signature, xlabel="2-qubit depth", ylabel="Number of qubits", From 7c638cc24834617305195fb0470397b387e5b533 Mon Sep 17 00:00:00 2001 From: ashsaki Date: Thu, 27 Jun 2024 10:53:03 -0400 Subject: [PATCH 3/3] challenge 2 3a 3b and sample data for 3b --- .../challenges/automation/zne/3b/data_3b.json | 964 ++++++++++++++++++ .../zne/3b/rel_err_3b_exponential.png | Bin 0 -> 24199 bytes .../zne/3b/rel_err_3b_exponential_linear.png | Bin 0 -> 24603 bytes .../automation/zne/3b/rel_err_3b_linear.png | Bin 0 -> 23570 bytes .../zne/3b/rel_err_3b_polynomial_degree_2.png | Bin 0 -> 25265 bytes .../zne/automated_zne_challenge2.py | 226 ++++ .../zne/automated_zne_challenge3a.py | 221 ++++ .../zne/automated_zne_challenge3b.py | 233 +++++ 8 files changed, 1644 insertions(+) create mode 100644 docs/challenges/automation/zne/3b/data_3b.json create mode 100644 docs/challenges/automation/zne/3b/rel_err_3b_exponential.png create mode 100644 docs/challenges/automation/zne/3b/rel_err_3b_exponential_linear.png create mode 100644 docs/challenges/automation/zne/3b/rel_err_3b_linear.png create mode 100644 docs/challenges/automation/zne/3b/rel_err_3b_polynomial_degree_2.png create mode 100644 docs/challenges/automation/zne/automated_zne_challenge2.py create mode 100644 docs/challenges/automation/zne/automated_zne_challenge3a.py create mode 100644 docs/challenges/automation/zne/automated_zne_challenge3b.py diff --git a/docs/challenges/automation/zne/3b/data_3b.json b/docs/challenges/automation/zne/3b/data_3b.json new file mode 100644 index 0000000..95aa03f --- /dev/null +++ b/docs/challenges/automation/zne/3b/data_3b.json @@ -0,0 +1,964 @@ +{ + "num_qubits_list": [ + 4, + 8, + 16 + ], + "depths": [ + 4, + 8, + 16, + 32, + 64 + ], + "extrapolators": [ + "exponential", + "polynomial_degree_2", + "linear", + [ + "exponential", + "linear" + ] + ], + "estimator_options": { + "exponential": { + "_VERSION": 2, + "environment": { + "log_level": "WARNING", + "callback": null, + "job_tags": null + }, + "simulator": {}, + "default_shots": 1000, + "optimization_level": 0, + "resilience_level": 0, + "dynamical_decoupling": {}, + "resilience": { + "measure_mitigation": true, + "measure_noise_learning": {}, + "zne_mitigation": true, + "zne": { + "extrapolator": "exponential" + }, + "pec": {}, + "layer_noise_learning": {} + }, + "execution": {}, + "twirling": {} + }, + "polynomial_degree_2": { + "_VERSION": 2, + "environment": { + "log_level": "WARNING", + "callback": null, + "job_tags": null + }, + "simulator": {}, + "default_shots": 1000, + "optimization_level": 0, + "resilience_level": 0, + "dynamical_decoupling": {}, + "resilience": { + "measure_mitigation": true, + "measure_noise_learning": {}, + "zne_mitigation": true, + "zne": { + "extrapolator": "polynomial_degree_2" + }, + "pec": {}, + "layer_noise_learning": {} + }, + "execution": {}, + "twirling": {} + }, + "linear": { + "_VERSION": 2, + "environment": { + "log_level": "WARNING", + "callback": null, + "job_tags": null + }, + "simulator": {}, + "default_shots": 1000, + "optimization_level": 0, + "resilience_level": 0, + "dynamical_decoupling": {}, + "resilience": { + "measure_mitigation": true, + "measure_noise_learning": {}, + "zne_mitigation": true, + "zne": { + "extrapolator": "linear" + }, + "pec": {}, + "layer_noise_learning": {} + }, + "execution": {}, + "twirling": {} + }, + "('exponential', 'linear')": { + "_VERSION": 2, + "environment": { + "log_level": "WARNING", + "callback": null, + "job_tags": null + }, + "simulator": {}, + "default_shots": 1000, + "optimization_level": 0, + "resilience_level": 0, + "dynamical_decoupling": {}, + "resilience": { + "measure_mitigation": true, + "measure_noise_learning": {}, + "zne_mitigation": true, + "zne": { + "extrapolator": [ + "exponential", + "linear" + ] + }, + "pec": {}, + "layer_noise_learning": {} + }, + "execution": {}, + "twirling": {} + } + }, + "batch_id": null, + "job_ids": [ + "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "3713c011-16b7-404e-a771-0812962dfba3", + "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + ], + "backend_name": "aer_simulator_matrix_product_state", + "timestamp": "2024-06-27T14:37:11.222476+00:00", + "results": { + "pub_0": { + "num_qubits": 4, + "depth": 4, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4UBAZhAUlC2eHJmUXJpZomuoZmZzQSIWHVtISNYCyNjIQMqYEQyAgSY4TKsaCrQQYR7YklqIVgBG5ohaOYzOkfB1DIgNDDjMTvUGK4hDSrEYQwGl+3hAhbNL2YcUGE/ABeQ0HUJ+a3IeYAE4xlxG3+38FzaHiFsxhMdMswkhAwTQgNxTmfC7XSu9nXMfr4cOEKGOPeAUwoTrYOSDt4lznhm3Maz3ntwa+VRJizGs0NFWBiwA6fEoqLM1CJEwicrovFkAZhihMC8XVtXXz6/nzrxhmH8jZtrs79XXiDFeDzxhmH8gYNbhFZN3bV/gJIpfu8S5x5oAUdi4UnjoKQ4C2AYH2DT+9S18CUpIQNN9yQUngwM/5EATAEAtMXEjA==\"}", + "physical_observable": { + "paulis": [ + "IIZZ", + "IZZI", + "ZZII", + "ZIIZ" + ], + "coeffs": [ + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_1": { + "num_qubits": 4, + "depth": 8, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4UBAZhAUlC2ZnJmUXJpZomuoZm5zQKIWHVtISNYCyNjIQMqYEQyAgSY4TKsaCrQQYR7YklqIVgBG5ohaOYzOkfB1DIgNDDjMTvUGK4hDSrEYQwGl+3hAhbNL2YcUGE/ABeQ0HUJ+a3IeYAE4xlxG3+38FzaHiFsxhMdMswkhAwTQgNxTmfC7XSu9nXMfr4cOEKGOPeAUwoTrYNyhKUcOsQuccYz4zae9d6DWyuPMlEUWSM3MQ/d2GWHirAwYAdOiUVFmalFiLxIVkTjyZUwxQiBebu2rr58fj914g3D+Bs312Z/r7xAivF44g3D+AMHtwitmrpr/wAlU/zeJc491CxzMdwzjGKX4lyJYXyATe9T18KXpEQWNctc/N4lzj2DNDGT2KwdQSmHhGYtA8N/JABTAACf1WWw\"}", + "physical_observable": { + "paulis": [ + "IIZZ", + "IZZI", + "ZZII", + "ZIIZ" + ], + "coeffs": [ + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_2": { + "num_qubits": 4, + "depth": 16, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4UBAZhAUlC2b3JmUXJpZomuoZmFzQaIWHVtISNYCyNjIQMqYEQyAgSY4TKsaCrQQYR7YklqIVgBG5ohaOYzOkfB1DIgNDDjMTvUGK4hDSrEYQwGl+3hAhbNL2YcUGE/ABeQ0HUJ+a3IeYAE4xlxG3+38FzaHiFsxhMdMswkhAwTQgNxTmfC7XSu9nXMfr4cOEKGOPeAUwoTrYNyhKUcOsQuccYz4zae9d6DWyuPMlEUWaOJGb97RhMzTGA0MY8m5tHEPJqYiXbPCIxddqgICwN24JRYVJSZWoTIi2RFNJ5cCVOMEJi3a+vqy+f3UyfeMIy/cXNt9vfKC6QYjyfeMIw/cHCL0Kqpu/YPUDLF713i3EPNMhfDPcModinOlRjGB9j0PnUtfElKZFGzzMXvXeLcM5qYaeTd0cRMTe8S557RxEwj744mZmp6lzj3DNLETOJQ8AhKOSQMBTMw/EcCMAUAeyin2A==\"}", + "physical_observable": { + "paulis": [ + "IIZZ", + "IZZI", + "ZZII", + "ZIIZ" + ], + "coeffs": [ + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_3": { + "num_qubits": 4, + "depth": 32, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4UBAZhAUlD21OTMouTSzBJdQzNLmwMQseraQkawFkbGQgZUwIhkBAgww2VY0VSggwj3xJLUQrACNjRD0MxndI6CqWVAaGDGY3aoMVxDGlSIwxgMLtvDBSyaX8w4oMJ+AC4goesS8luR8wAJxjPiNv5u4bm0PULYjCc6ZJhJCBkmhAbinM6E2+lc7euY/Xw5cIQMce4BpxQmWgflCEs5dIhd4oxnxm08670Ht1YeZaIoskYTM373jCZmmMBoYh5NzKOJeTQxE+2e0cRMnHdHEzM1vUuce0YTM428O5qYqeld4twzmphp5N3RxExN7xLnntHETCPvjiZmanqXOPfQLzEP3dhlh4qwMGAHTolFRZmpRYi8SFZE48mVMMUIgXm7tq6+fH4/deINw/gbN9dmf6+8QIrxeOINw/gDB7cIrZq6a/8AJVP83iXOPdQsczHcM4xil+JciWF8gE3vU9fCl6REFjXLXPzeJc49o4mZRt4dTczU9C5x7hlNzDTy7mhipqZ3iXPPaGKmkXdHEzM1vUuce0YTM428O5qYqeld4twzmphp5N3RxExN7xLnntHETCPvjiZmanqXOPcM0sRM4pLjEZRySFhyzMDwHwnAFAAACDcsJg==\"}", + "physical_observable": { + "paulis": [ + "IIZZ", + "IZZI", + "ZZII", + "ZIIZ" + ], + "coeffs": [ + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_4": { + "num_qubits": 4, + "depth": 64, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJztnLsvBFEUxu+d8Vh0Kq2EUkIUFBKJR0SEECSiE9lNNqrZUIioFCqlRKVHqGg2EqvQItEgIRoJf4FC4bF2d9i1k284x/M71ebOvSff757fTLlDvcN9vSNV1lrzUjbqmaqYiTz9LDF+Oc+PMjvqJ+OJyZn4dENTS2Pb8cvi3Lxn00es9czbsq9aPJebe1KatyO/xnompqNeekNZXpO8/rZzPLvX+AfcgN6jzbkDscxSpDldJ+25hdaFm5VUXXkqt1DT0DVyX1uRCtHeFm9/4R3Gdqvfaw/fjBviZhz/ABbdKR69cnHLHeiPFLkZLE/aFEf7Kv+ZOV8wXay9W7x96eXV+dqB86lhUebgPJQ5u0CZKTNlpsxwHsqM4VJmSVwsD2VWwqXMkrhYHsqshEuZJXGxPJRZCZcyS+JieSizEi5llsTF8lBmJVzKLImL5aHMSriUWRIXy0OZlXApsyQulocyK+FSZklcLA9lVsKlzJK4WB7KrIRLmSVxsTyUWQmXMkviYnm+TubfO93yzEqJeb86JhKJeDThv4sfGnTAW5nd7C+sJnc2To72ZOZW0P70bHPqbvY4TPuAuRW0T+1vV68vJ/e+SdNgXCyP5De3IM8fmu6n38qC9oNtS9fd3m2YYUl+c4NxsTyUWQmXMkviYnkosxIuZZbExfJQZiVcyiyJi+WhzEq4lFkSF8tDmZVwKbMkLpaHMivhUmZJXCwPZVbCpcySuFgeyqyES5klcbE8lFkJlzJL4mJ5KLMSLmWWxMXyUGYlXMosiYvlocxKuJRZEhfLQ5mVcCmzJC6WhzIr4VJmSVwszw+VOeRfKP8jc0L8hbIxD68qu+ER/R0zmg==\"}", + "physical_observable": { + "paulis": [ + "IIZZ", + "IZZI", + "ZZII", + "ZIIZ" + ], + "coeffs": [ + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)", + "(0.25+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_5": { + "num_qubits": 8, + "depth": 4, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4MBAZhAUlC2cXJmUXJpZomuobmhzQaIWHVtISNYCyNjIQMqYEQyAgSYoTQLlGaF0mxQmh2uEybDyIAdRLgnlqQWghXANDNhqgLpZnSOgqllQGhgxmN2qDFcQxpUiMMYDC7bwwUsml/MOKDCfgAuIKHrEvJbkfMACcYz4jb+buG5tD1C2IwnOmSYSQgZJoQG4pzOhNvpXO3rmP18OXCEDHHuAackJloHJR28S5zxzLiN16lZftan7r89BQmBlYSAZ0FoIM7pLLidHheTfy9oP4sDJQmBGWwHrYOSDt4lznhW3Mb/+Xpk+96Cp5QkBHYSAp4NoYE4p7PhdnqP59k2P6HvOAKeOPewgu2gdVDSwbvEGc8O12yEbnzIi0jp110PsRgPqz45GLADp8SioszUIkRViCj6EXmfrMjHU1HCFCME5u3auvry+f3UKd0xjL9xc23298oLpBiPp3THMP7AwS1Cq6bu2j9AlRl+7xLnHmgziMQmFo2DkuLSHcN4lnsPbq08+smeOqU7hvEvnIKvLwRmwwGqzPB7lzj3QFt9JLYoaRyUFJfuGMbPeh/07PRRZgfqlO4Yxi8R2K24wvA3KQFPzcoMv3eJcw+01Udii5LGQUlqRYnD+AN7EFlkc26vA7CFRnoziIQmFgPDfyQAUwAAiKWl6g==\"}", + "physical_observable": { + "paulis": [ + "IIIIIIZZ", + "IIIIIZZI", + "IIIIZZII", + "IIIZZIII", + "IIZZIIII", + "IZZIIIII", + "ZZIIIIII", + "ZIIIIIIZ" + ], + "coeffs": [ + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_6": { + "num_qubits": 8, + "depth": 8, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4MBAZhAUlB2bHJmUXJpZomuobmRzQGIWHVtISNYCyNjIQMqYEQyAgSYoTQLlGaF0mxQmh2uEybDyIAdRLgnlqQWghXANDNhqgLpZnSOgqllQGhgxmN2qDFcQxpUiMMYDC7bwwUsml/MOKDCfgAuIKHrEvJbkfMACcYz4jb+buG5tD1C2IwnOmSYSQgZJoQG4pzOhNvpXO3rmP18OXCEDHHuAackJloH5QhLOXSIXeKMZ8ZtvE7N8rM+df/tKUj3rCTEKwtCA3FOZ8Ht9LiY/HtB+1kcKElnzGA7aB2Uo+UCwzDOKHRIzMQZz4rb+D9fj2zfW/CUkmzOTkKyYUNoIM7pbLid3uN5ts1P6DtF2YoVbAetg3K0GGQYxhmFDomZOOPZ4ZqN0I0PeREp/brrIUVpc+Tm3aEbu7B+HAcDduCUWFSUmVqEaFkj2hqI4oisyMfT7oYpRgjM27V19eXz+6nTnMAw/sbNtdnfKy+QYjye5gSG8QcObhFaNXXX/gFqPeH3LnHuoWavCsM9wyh2Ka4DMYxnuffg1sqjn+ypUwdiGP/CKfj6QmDJMEBVPn7vEuceavZ8MNwzfPIuieN0oxkF1XiUjEJxcwLD+Fnvg56dPsrsQJ3mBIbxSwR2K64w/E1KtqJm6wm/d4lzDzV7PhjuGT7FIImDzqMZBdV4lIxCarsbh/EH9iDidXNurwOwDzpAvSr83iXOPYO0XCBx0HkEpRwSxukYGP4jAZgCAOcrHPg=\"}", + "physical_observable": { + "paulis": [ + "IIIIIIZZ", + "IIIIIZZI", + "IIIIZZII", + "IIIZZIII", + "IIZZIIII", + "IZZIIIII", + "ZZIIIIII", + "ZIIIIIIZ" + ], + "coeffs": [ + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_7": { + "num_qubits": 8, + "depth": 16, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJwL9Az29gzhZmRkZIAAxtRCBu40Bg4gk4MBAZhAUlD2xuTMouTSzBJdQ3NjmwsQseraQkawFkbGQgZUwIhkBAgwQ2kWKM0KpdmgNDtcJ0yGkQE7iHBPLEktBCuAaWbCVAXSzegcBVPLgNDAjMfsUGO4hjSoEIcxGFy2hwtYNL+YcUCF/QBcQELXJeS3IucBEoxnxG383cJzaXuEsBlPdMgwkxAyTAgNxDmdCbfTudrXMfv5cuAIGeLcA05JTLQOyhGWcugQu8QZz4zbeJ2a5Wd96v7bU5DuWUmIVxaEBuKczoLb6XEx+feC9rM4UJLOmMF20DooR8sFhtFyYbiUC3TIu8QZz4rb+D9fj2zfW/CUklKNnYRUyYbQQJzT2XA7vcfzbJuf0HeKShFWsB20DsrRUp9htNQfLfVHS31U4wdjqU+Hkpk449nhmo3QjQ95ESn9uushRQXJaEWE3z2jFRF+94zcimi0ZB4tmaGaR0tmbO4ZLZnxu2c07+IxfjTvEudd4txDv7w7dGMXNrPFwYAdOCUWFWWmFiF6l4jmD6I4Iivy8fQ9YYoRAvN2bV19+fx+6rRwMIy/cXNt9vfKC6QYj6eFg2H8gYNbhFZN3bV/gBp0+L1LnHuoObKA4Z5hFLsU14EYxrPce3Br5dFP9tSpAzGMf+EUfH0hsGQYoCofv3eJcw81O2MY7hnNu6N5l2Eo5F2KWzgYxs96H/Ts9FFmB+q0cDCMXyKwW3GF4W9Scjo1G3T4vUuce6jZGcNwz2jJPFoyo7tntGTGY/xoyYzHeLJLZlL7njiMP7AHEfabc3sd9rOQUtBSc2QBv3eJc89oRYTfPaMVEX73DNKKiMTFzaOlPqrxo6X+aKnPMFrqD7ZSn8SNCaPlAqrxo+UCIfcM0nKBxI0JIyjlkLC4mYHhPxKAKQAAnL0K9A==\"}", + "physical_observable": { + "paulis": [ + "IIIIIIZZ", + "IIIIIZZI", + "IIIIZZII", + "IIIZZIII", + "IIZZIIII", + "IZZIIIII", + "ZZIIIIII", + "ZIIIIIIZ" + ], + "coeffs": [ + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_8": { + "num_qubits": 8, + "depth": 32, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJztnUtoE0Ecxmd2Nw/tRXISeip4tIdaQQ9CQhUkqAXbCFZEKCWBIKIJ9SA+LkIF0aMgHgRB8IVeVIRaSQR7kqrQgw+w1IMS8CAI0kOF2mx3s9nuzt+Z7m6att9ctkxmvnwzO/P9ZgNlD2cHD2RzHZxztlR4vsQ6Ciy5+GeSOUWrf2S1GBoplkfOFke7e3bt3DO7VHn+YombXTgvMXfhTRL1oltXw7rGrGvcuiYaPe1POPMvR/cPj+ZLZgO7s+ZtVe/N9x6z2zKng05oH+ltdChYVcles0ynGxW7L9duVrclqo2Krd37cvNdm6oK8lws/7X0rjCR8pOXnhldYWY0p4OcdU1sffOVJ3r/oaRgZuT8mCtJi3oqN9jKacHdlZPXxfLbL9ybOnhpIR1g3ccU7qvhdJCzboitnzh+emagYmSCrDPd/I6opxK5wJAL6yUXWrB35eRjYvm/f968eHXme5BUSyisyrjTQc56XGz9WnZqrD81FyhFYuZ3RD2VSH2G1EfqI/Xd8u2Y+i1IZjn5RKPzjuXyudpQ58+r3wIFCUBE+wGIaD8AEe0HILIrACKAqLkARACRVQEQMYAIIAKIpOQBItoPQET7AYhoPwCR3HABIoDI6gwQ+fkBiGg/ABHtByCSGy5ABBBZnQEiPz8AEe0HIKL9IJkJeSQzIY9kpv0gmWk/2LuEPPau3HDl/LRu767du2v/91OS+Ze+4XK5mC87T5fO8ceJoxXdfOLZ027sVNwef/5o+n0lnBOOR/7T58cn5859UJEnTjge+errZ6mHN8Yrq3Sgo4cr5yfMXxY8ftbR3Q3MQI+8MTP75cHk73Q4DPTI1/oGP95ZTIZVQj49XDk/YT6Mefxg72LvsrWwdwOfcDzyt34N/Hg7qWfCOeF45O9uedl1v2deZaeHeaCjhyvnJ8yHMY8fJDOSebkfJDMhj2Qm5FeczKrPngL56oQz909PXc9UDJWgDfOXBXq4cn4AItoPQET7AYgiGi5A5JYHiAAiBhABRAI/AFFEwwWI3PIAEUDEACKASOAHIIpouACRWx4gAogYQAQQCfwARBENFyByywNEABEDiAAigZ82BZHiSxKQ+m55pD5SnyH12y31FV9wglxwyyMX/uenTXNB8QUnG2jlKLwkgbGFpmI3+Afq+uXN\"}", + "physical_observable": { + "paulis": [ + "IIIIIIZZ", + "IIIIIZZI", + "IIIIZZII", + "IIIZZIII", + "IIZZIIII", + "IZZIIIII", + "ZZIIIIII", + "ZIIIIIIZ" + ], + "coeffs": [ + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_9": { + "num_qubits": 8, + "depth": 64, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJzt3U9IFGEYx/F39o9ueQlPQSehYx5Mog6BYkFIJaQGFhGIKEhE7WKH6M8lKIg6BtEhCIKyqEtFYIYb5CmswEN/IKlDIXQogvBgYO767s6OM+/TO+7O+qfvXFZm9338PbMzz2fGiwfau/a2d9c5jqMWNqc/reoGVGr+x5Ryt1juLf3jcN9gpu/U4FBj0/ZtO38u7DxzLu3klzhOWnk3p6REbovr14R+TerXGv1aW1xZeMdRwVvPnt6h/nT+A4XFMf+ncqudXYcLn1XugrhQ+2BzccGA3pVqzm+TLcUdOy5MX89urs0Wd2xs3N0927AuG6K8Yy7/Kf16YLQ+qLz1kYmHODIxd4Fd9Jg5+vpLD+Md+1OGI2OXJ38mxaI+lP/ZmVOFb9eufNxcfsvZOxP7zs+1lHHeJ0N8rwl3gV30hDn60SMnpjrHEq3lnGfx/O+I+lAyFxRzYa3MhSpcu3blk+byf36/fPr85NdyplptiLOyxl1gF73GHP1K+8TFjvqZsqZIMv87oj6UTH3F1GfqM/W95Vfi1K/CZLYrX1tcvHVx+e7pQ5u+X/5S1iABIjkPEMl5gEjOA0SFHUAERKUbEAGR3gFECoiACIisygORnAeI5DxAJOcBIrt2gQiI9GIgCsoDRHIeIJLzAJFdu0AERHoxEAXlASI5DxDJeYDIrl0gAiK9GIiC8gCRnAeI5DxAZNcuEAGRXgxEQXmASM4DRHIeILJrF4iASC8GoqA8QCTnASI5DxDZtQtEQKQXA1FQHiCS8wCRnAeI7NoFIiDSi4EoKA8QyXmASM4DRHbtAhEQ6cVAFJQHiOQ8QCTnASK7doEIiPRiIArKA0RyHiCS8wCRXbtABER6MRAF5QEiOQ8QyXmYzEJ5JrNQnsks52Eyy3m4doXyXLt27drlqd61u3q/3cJ/UUqp4K2tN5MZ7M+4T5fu7Y87jpb05QvPnoUPuztujjy5P/lmrDJ3OL7y7z88ODZz+m2Y8sIdjq989sXj+nvXRsaW6YZObtcuTyX/suDLs4a+3bIN9JVPTH3+ODz+q6UyBvrKT7d1vbs1PxmWiXy5Xbs8lXwY8+Xh2uXaVavh2i37DsdX/saPzm+vxuOtlbnD8ZW/veFZw92m2TBXeiVv6OR27fJU8mHMl4fJzGRenIfJLJRnMgvllzyZwz57GspnR91j/+j41daxRJhBW8m/LMjt2uUBIjkPEMl5gCiidoHIWx6IgEgBERAZ8gBRRO0Ckbc8EAGRAiIgMuQBoojaBSJveSACIgVEQGTIA0QRtQtE3vJABEQKiIDIkAeIImoXiLzlgQiIFBABkSEPEEXULhB5ywMRECkgAiJDHiCKqF0g8pYHIiBSQAREhjxAFFG7QOQtD0RApIAIiAx5gCiidoHIWx6IgEgBERAZ8gBRRO0Ckbc8EAGRAiIgMuQBoojaBSJveSACIgVEQGTIA0QRtQtE3vJABEQKiIDIkGeFQpQseTdo6ynGYeoz9Zn6/8rD1JfzVGfqW0+1MEAwF4TyzAU5T3XmgvV5H2aErIkzx/rI5P4T01zJVvjAXzivnIs=\"}", + "physical_observable": { + "paulis": [ + "IIIIIIZZ", + "IIIIIZZI", + "IIIIZZII", + "IIIZZIII", + "IIZZIIII", + "IZZIIIII", + "ZZIIIIII", + "ZIIIIIIZ" + ], + "coeffs": [ + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)", + "(0.125+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_10": { + "num_qubits": 16, + "depth": 4, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJzFWF1IVEEUvnfv/q+7Lj5E4ItCT+E+iFA+GCsWlKVCapAlwSJrmA+2iz2I5UNCgvWQUBBBQpD/JT0oill7haRAzEQhMxILCiOhzSgRQ8vr3B1jdoaZ5s51Xs4y3vPNdz4Pd+53ThaWnSgs98iyLG0vORyRPNWS8+9PvwSXZetP4HdtVU206lJNfSD74IG8nu29xisRWUuR5Yj075J3QGwtBUQriDYQ7SA6QHSC6ALRDaIHxBQQvSD6QExNnKwjy1LydfpoqD4c0R7QD7egT21ly4fP6M9KMEEhYJ/KSSRU6wXlaGsmmNjIbV66o+5zqImNvYEj5euZLpUBXsbDv4+8qh5NSwZPrYzCoIwFJtBRt+Cpu1v6lZJiJ0YZOj5aJ1pES2lCuXTwCh4+63LXZFHTZpCjEWwMwlthAh11K576ucq6hdKYNZ+nERTtDNFSmlAuHbwND//75/Ohpxc/8TSCg0F4O0ygo27HU79ROHmtJG0VIzwdH5t2hmgpTSiXDt6Bhz+2VJH+tXWapxFcDMI7YQIddSee+sC7jo2mBRvXG8GhnSFaShPKpYN34eFnp84OvlS5rgYPg/BumEBH3Y2nPhqq2v9sg+8bwaWdIVpKE8qlg/fg4Y/78h77V+UkfUbdCF4G4VNgAh31FMK7MtQxPhnBfZzR8fFoZ4iW0oRy6eC9ePjKoqGy8J5kNw91I6QyCO+DCXTUfXjqaxUvpjuLJa5G8GpniJbShHLp4FPx8A3nFw/VXV2PofC6RfdLyVdBKBqtCUehXYb2EPoD+IEIvxDgFQHfEf/VJATTrT8MN9pHBvtmpmLGOEUEfu7to9rVhtcs8ASniMCrYwNpvbdHYrtkjMnl0vEBIxXGcY1gKbmdIgJvXVic7xlfCRrjFBH4pYKyN/dbPwR3yRiTy6XjAyZIjNMpwVJyO0UE/u630s8T40q+MU4RgX/gf5LZnb3OIryRxphcLh0fMEFinE4JlpLbKW4HNS+x4Y/Pxe/F7SyNQHCKCPuM6ysPP6bPszSCkcaYXC4dHzBBYpxOCZaS2yki8JWtWT8CzUxXA8EpIvBSfzh+q72N5U420hiTy6XjAyZIjNMpwVJyO0UEPrcx42Zv3zJLIxCcIgKvDi9/mbNMsDSCkcaYXC4dHzBBYpxOCZaS2yki8LPe6fK2ANPNQ3CKCHx+55q1p/s7SyMYaYzJ5dLxARMkxumUYCm5TTcCP7zSdaFl7BfLfwq4ZYZxjSRt7lj6A38ADa1tpg==\"}", + "physical_observable": { + "paulis": [ + "IIIIIIIIIIIIIIZZ", + "IIIIIIIIIIIIIZZI", + "IIIIIIIIIIIIZZII", + "IIIIIIIIIIIZZIII", + "IIIIIIIIIIZZIIII", + "IIIIIIIIIZZIIIII", + "IIIIIIIIZZIIIIII", + "IIIIIIIZZIIIIIII", + "IIIIIIZZIIIIIIII", + "IIIIIZZIIIIIIIII", + "IIIIZZIIIIIIIIII", + "IIIZZIIIIIIIIIII", + "IIZZIIIIIIIIIIII", + "IZZIIIIIIIIIIIII", + "ZZIIIIIIIIIIIIII", + "ZIIIIIIIIIIIIIIZ" + ], + "coeffs": [ + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985, + 2.7336406607023154, + 1.9845664104768632, + -3.1243861495570098, + 2.2456372993781644, + -2.930568260297326, + 1.4429677267223928, + -2.0379158390962826, + 2.281920468786123 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_11": { + "num_qubits": 16, + "depth": 8, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJztWk9IVEEYn7f//7jr4iECLwqdwj2IBz0YKxaUpUJqkCXBImtYB9vFDmJ5SEiwDgkFESQE+b+kg6KYtU9oKRAzUciMxILCSGgzSsTQ8vnejo/ZN8w0b9d6vrl8yzjzm9/M+34f4/fN8aLyY0UVTo7jwFbjAkHgrAG2Pz89ADbD5p/E35Hq2lD1xdp6b3Zubv4wL/Q1Xg5ywhSOCwJ547ZBbDajaE2iNYvWIlqraG2itYvWIVqnaFNE6xKtW7SpsZUlZA7EbycP++sDQWGAtLgBHbU5mzt4ShoL4AQjBvtETmxCjbShHKFN+2Idec2Lt/l9Vj7Wsdd7qGIt085TwHPK8O+CL2tG0+LBE5+MkeJkDHACGXWDMnVHS7+xtMSmcDJkfARPNCT6KHeZ5yTh65LBG5Xhsy51TRQ3bfgY/N5M8V1NcAIZdZMy9TNVdfNlYVMBi58ZhTUSfZR6XAAaFkoSnJkM3qwM/+vHs6EnFz6yyNxK4TYWOIGMukWZ+vWiiaulaStMsjILayT6KPUwCDQslCQ4Mxm8VRn+yGJl+pfWKRaZ2yncxgYnkFG3KVMfeNux3jRvZnJjq7BGoo9SD4NAw0JJgjOTwduV4WcmTw++4Jku7U4Kt3HACWTUHcrUR/3V+5+us11K7cIaiT5KPQwCDQslCc5MBu9Uhj/qzn/kWeHiHA6xzF0UbpMCJ5BRT8GEb39HZCLIlgNyCmsk+ij1MAg0LJQkODMZvEsZvqp4qDywJ95Vh1jmqRRu44YTyKi7lamvVj6f6iwBTG7sEtZI9FHqYRBoWChJcGYy+FRl+IazCwfqrqyFWXxh92r3//26Uo3WA+K3Qn8oVBsIwaoXrAPAVCHMJsB/OOCdBIatv3ISTO1MGgw72kcG+6Ynw+qUBBD42TcPz680vKKBx5QEEHh+bCCt99ZIeIcqIPjtkvFRszKK8NHQ12XOYyPwpvmFuZ7Isk+dPDYCv1hY/vpe63vfDqXt8dsl46Nm9RLhox3tUr610YUih5cJhTmPjcDf+Vr2aTxiLFAnj43A3/c8zuzOXqORlZppe/x2yfioWb1E+GgnDFI+HNOFIoeXCYU5j71l+PxYhyc6G70btdCwx+SxEfYZ15YffEifo3EbNdP2+O2S8VGzeikN1mAYpHwnpwtFzl4mFOY8NgJf1Zr13dtMdRfB5LEReNAfiN5sb6O5BKqZtsdvl4yPmtVLhI92wiDlOzldKHJ4mVCY89gIfF5jxo3eviUa9pg8NgLPDy99njWM08hczbQ9frtkfNSsXiJ8tBMGKd/J6UKRw8uEwlwSQOBnXFMVbV6qqw6mJIDAF3Sumnq6v9G4sZoVEPx2yfioWb1E+GgnDFK+k9OFIoeXCYW5dobADy93nWsZ+0njZ2pWRvHbJePzj8YFyodju8hzKN7aALCxrUkDfgNYqpXi\"}", + "physical_observable": { + "paulis": [ + "IIIIIIIIIIIIIIZZ", + "IIIIIIIIIIIIIZZI", + "IIIIIIIIIIIIZZII", + "IIIIIIIIIIIZZIII", + "IIIIIIIIIIZZIIII", + "IIIIIIIIIZZIIIII", + "IIIIIIIIZZIIIIII", + "IIIIIIIZZIIIIIII", + "IIIIIIZZIIIIIIII", + "IIIIIZZIIIIIIIII", + "IIIIZZIIIIIIIIII", + "IIIZZIIIIIIIIIII", + "IIZZIIIIIIIIIIII", + "IZZIIIIIIIIIIIII", + "ZZIIIIIIIIIIIIII", + "ZIIIIIIIIIIIIIIZ" + ], + "coeffs": [ + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985, + 2.7336406607023154, + 1.9845664104768632, + -3.1243861495570098, + 2.2456372993781644, + -2.930568260297326, + 1.4429677267223928, + -2.0379158390962826, + 2.281920468786123 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_12": { + "num_qubits": 16, + "depth": 16, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJztXE9IVEEcnrd/3F3X1cVDBF4UOoUexEMejBULylIhNciSQGQN62C72EEsDwkJ1iGhIIKEIP+XdNAUs1whKRAzUciMxILCSMiMEjG09vl2n+u8N840b//o/t7BWZ5vvvlm3sz3/dz5OSdyi47nFlsFQUAbl+B0IWsFMv/7aEfypfP+SnqiprzSXX6psjot/UBm1hOPeLP2iksQqwiCCwVewiYI76WXSoNUGqUyRipNUmmWSotUxkqlVSrjpNImlfFSmeBv2YcsIOXr1JGyaqdLfMDXuA5/yltbOHTa9yySK+gJ2Ccz/BUqfB3KEK9Jh/9GZv38Hc8+k8d/Y2/a4eLVFIuHAV5Qh//gel0xmKgETz0yeoaR0ckV6Kjr1KnHNnTrC/LNKiNDx0ecibpgD2WUzZwQvF06eL06fOrltrG8unUHx7w3MrxXg1yBjrpBnfrZ0qrZwiFDNs8804ttBHsoQRcQ6MJu0YUQrF06eKM6/J9fL/qeXfzMo2omhlkZI1egox6jTv1G7ti1gsRlLhUxim0EeyhB9RGoPqg+qH4gfCSqfgiUmQ7epA5/dL4k6VvjBI9nWRjWlFmuQEfdrE69533LWt2skUuTTWIbwR5K8HQEng6eDiYHJqcMHzaTC4ER0cFb1OGnxs/0vvJwfVlmZViysXIFOuqx6tQHy8r3P1/jkxCL2EawhxJCGAQhDIQwYHJgcsrwYTO5EBgRHbxVHf5YfNZj+7KgMDjUFm1jWLJxcgU66nGEWVnWMjLm4vumzCq2EeyhhBAGQQgDIQyYHJicMnzYTC4ERkQHb1OHL83rK3LuUZqY1BadwLBk4+UKdNTj1amvlLycaM1HXBZkE9sI9lBCCIMghIEQBkwOTE4ZPmwmFwIjooNPUIevOTd3sOrq6hDPOgTfJfMB3yXziV7fBWUGZVaDB2VGoMzb8YG1S4CHtUvXXTo+oVu7O/ft+v5L046Ur5wyt7vS6fbib2Q6e3/o5B1h+Ytn+e9bOSKRFUJ+H6yThJAv7XtYvtE80Ns1OT6kTSoZBj/97tGF5Zo3LPCEVDIM3jPck9h5e2AoTJlz5O7S8dEyGx7js4veLncOBQZvmJ2b6RhZcmiTQ4HBz+cUvb3f+NERppQRcnfp+GiZ9YrxgbULaxfthLXLvTWMwd/9XvhldESfrc3WMAb/wP40pT19lWWla7kTTu4uHR8tk/kwPqDMoMxb+YAyE+BBmQnw/63M3PuZG4Uny3/Dvji9eG8xhoU9YT8TY598fenhp6QZFp3ScvuW3F06PlpmoPkeBt+l5AO+Gy2+y3j+GJhcIDyYXISYHPfWMAZf2pj6M62eaeYQtoYxeNTtXLzV3MSyZLXcCSd3l46PlhloGB8IYSCE2conOkMYxoMwweQC4cHkIsTkuHMoMPjM2uSbnV0LLOwJORQYvKd/4eu0bpTForVMGSF3l46Plsl8GB8IYSCE2conOkMYxjN7weQC2YPJRYjJcaeSYfBTtonipjSmiUlIJcPgs1tXDB3tP1gsSMvMOXJ36fhomfWK8YEQBkKYrXyiM4RhPIAaTC4QHkwuQkyOO18ag+9fajvfMPybRQO1zIYnd5eOD3g6mQ94OplPhHo64wHUoPqB8KD6oPoIVD/SVJ/xzF7QhUB40IXt+ESoLjAehBlFM4fh/DGE1jddvgf+Ar4v47o=\"}", + "physical_observable": { + "paulis": [ + "IIIIIIIIIIIIIIZZ", + "IIIIIIIIIIIIIZZI", + "IIIIIIIIIIIIZZII", + "IIIIIIIIIIIZZIII", + "IIIIIIIIIIZZIIII", + "IIIIIIIIIZZIIIII", + "IIIIIIIIZZIIIIII", + "IIIIIIIZZIIIIIII", + "IIIIIIZZIIIIIIII", + "IIIIIZZIIIIIIIII", + "IIIIZZIIIIIIIIII", + "IIIZZIIIIIIIIIII", + "IIZZIIIIIIIIIIII", + "IZZIIIIIIIIIIIII", + "ZZIIIIIIIIIIIIII", + "ZIIIIIIIIIIIIIIZ" + ], + "coeffs": [ + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985, + 2.7336406607023154, + 1.9845664104768632, + -3.1243861495570098, + 2.2456372993781644, + -2.930568260297326, + 1.4429677267223928, + -2.0379158390962826, + 2.281920468786123 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_13": { + "num_qubits": 16, + "depth": 32, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"eJztXV1oHFUYndmf7G42myx5EKEvLfgkzUPpgxUiCVXQaFuwidBqEELYSPShbqgPpdoHCxaiDxYURLAg2H8tPrS21Gq2YFAosYYWjBVDKygRC8aIhhJp7U5md7Z7955+NzOzptlzIXvD7Nwz59659/vOydwhT/f0PtXTl7Zt21osdi5vpYes5O1fs5ZXIsWv3F+vDQ6PDL4yvLNj3UMPd35WcA7ufi1vO01sO2/dWewKiGKJunXMreNu3eTWCbdOunXKrZvdOu3WLW6dcetWt24rX7mEbFu1y7bHB3bm8s4JpYtH1LOKre1Hny2da3kNogD7mfXlBkOlDq13yqWu8oENe2feKzyQKJQP3N/xWN/CmlTBAN7Ww/+U/3boXHstePHIRA1GJuI1kFGP6Kk37zsR3bI5qRkZGR9nJkbCHsoGmzl1uLsy+Kgefu2rhyc27bnV5WPexw3ua8xrIKMe01N/vn/H9NaxWLefeRZ1rhH2UDIuWIwLKyUu1GHtyuDjevh///7q9Bcv/+InqiUMZmWT10BGvUlP/a2eiTe2tM/7iiJx5xphDyWjvsWoz6jPqH8n/HKM+nWIzDL4hB7+iZntq34fnfSTs1IGayrpNZBRT+qpn/zx4M0903FfMTnhXCPsoWROt5jTmdOZ04PrLnM6c7oOHieikPOuDD6lh7988blT3xR8/W0wbRARmr0GMurNeurnBgYf/PKmv4iZcq4R9lBSsVlUbFRsVGxUbFRsiweo2KjYAPySZUbIqkoGn9bDP9na+Wl23q4xOGK9mTGIZy1eAxn1FjArBw6OT+T9xde0c42wh5J63KIepx6nHqcepx6nHqcepx6nHq8Nj0VkyJpZBp/Rw/dvOt2bu6/WxBS7iTaDaNzqNZBRb9VTv7H968lDmy1f2SHjXCPsoaTbsui26Lbotui26Lbotui26LbotrTwdFsN6Lbq4Ihk8G16+F0vXH1kx+sLY34SBA0g5kMDiPnQAGI+NICYDw0g5kMDiPk0rgGkI6Ij0sHTEdERAXg6ospCR0RH5B6gI7LoiO7Gh44I86EjwnyomQE8NTOAp2YG8NTMAJ6aGfOhZsZ8qJkxH2pmzIeaGfOhqgLwVFUAnqoKwFNVybor40NVhflQVWE+VFWYT/1UFfMu864OnnmXeRfzYd7FfBo37zIyMzLr4BmZLUbmu/Hh2gXwXLuy7sr41G/t3rt3t/SfGrNW7bJxYGRkODdSxF9807T4sbglu/gR8/4W7vlbT5F4EcK7H6aTBLyvWjrZO3Dg7Knjly6OGcCD3dkK/NQPn7w0v+s7E3iwO1uBL5w/2X7s3bNjBlM8yM3ouLsyPkG+jazwWUF31/c+IgU+Nn31ytHxua5g9hEp8DMbe7//cPRa1/+0bQp3V8YnyBdJFD5cu1y71r2wdn0/rVbg3/9j668XxqPdwTytVuA/yn6+5si6BZOVHuTDedxdGZ8gN7QqfBiZGZmr+TAyA3hGZgC/5Mjs+3nmYlXoLB/Izk7NfjDbZMIePM9U2K9+c+7jn1ddMYlTQT6+xd2V8QlyU1zpZOZdIR/mXebdaj7MuwCeeRfAN2je9f20WoHvH137V8deo5kDnlYr8NaJ3Ow7B/abRJEgH87j7sr4BLkpTuFDVUVVVc2HqgrzoarCfKiqADxVFYCnqgLwy1VV+d5HpMBv2L367WPHr5uwB/uIFPjCmeu/TUUumMTAILdN4e7K+AS5oVXhQ81MzVzNh5oZ86FmxnyomTEfamYAT80M4KmZATw1M4Bfsmb2vTtbgb+cmezb32E0McHubAW++9CN2NEjf5pE8CA3o+PuyvgE+SKJwoeOiI6omg8dEeZDR4T50BFhPnREmA8dEYCnIwLwdEQAno4IwDeoI/L9vqoCf2bu8Iv7zv9jkiCCfBsZd1fGhwYQ86EBxHxoADEfGkDMhwYQ86EBxHyWqQGMV3xbq2wr06Hbotui24LwdFsAnm6rstBt0W3p+NBt0W1V86HbwnzotjCf+rgtsZswMWbU4wCeehzAU48DeOrxykI9Tj2u40M9Tj1ezYd6HPOpjx4X600T6U7FBuCp2AA8FRuAp2LDfKjYMB8qNsyHig3zqY9iEysSE3HHnA7gmdMBPHO6rLsyPszpmA9zOuazTHO6OGeZpH9GfQDPqF9ZGPUZ9XV8lh71xVHNJEEwLgB4xgXMpz5xQTzvTULIipg54pFpu/1zq6KUTvgP9CuAew==\"}", + "physical_observable": { + "paulis": [ + "IIIIIIIIIIIIIIZZ", + "IIIIIIIIIIIIIZZI", + "IIIIIIIIIIIIZZII", + "IIIIIIIIIIIZZIII", + "IIIIIIIIIIZZIIII", + "IIIIIIIIIZZIIIII", + "IIIIIIIIZZIIIIII", + "IIIIIIIZZIIIIIII", + "IIIIIIZZIIIIIIII", + "IIIIIZZIIIIIIIII", + "IIIIZZIIIIIIIIII", + "IIIZZIIIIIIIIIII", + "IIZZIIIIIIIIIIII", + "IZZIIIIIIIIIIIII", + "ZZIIIIIIIIIIIIII", + "ZIIIIIIIIIIIIIIZ" + ], + "coeffs": [ + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985, + 2.7336406607023154, + 1.9845664104768632, + -3.1243861495570098, + 2.2456372993781644, + -2.930568260297326, + 1.4429677267223928, + -2.0379158390962826, + 2.281920468786123 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + }, + "pub_14": { + "num_qubits": 16, + "depth": 64, + "physical_circuit": "{\"__type__\": \"QuantumCircuit\", \"__value__\": \"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\"}", + "physical_observable": { + "paulis": [ + "IIIIIIIIIIIIIIZZ", + "IIIIIIIIIIIIIZZI", + "IIIIIIIIIIIIZZII", + "IIIIIIIIIIIZZIII", + "IIIIIIIIIIZZIIII", + "IIIIIIIIIZZIIIII", + "IIIIIIIIZZIIIIII", + "IIIIIIIZZIIIIIII", + "IIIIIIZZIIIIIIII", + "IIIIIZZIIIIIIIII", + "IIIIZZIIIIIIIIII", + "IIIZZIIIIIIIIIII", + "IIZZIIIIIIIIIIII", + "IZZIIIIIIIIIIIII", + "ZZIIIIIIIIIIIIII", + "ZIIIIIIIIIIIIIIZ" + ], + "coeffs": [ + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)", + "(0.0625+0j)" + ] + }, + "final_qubit_layout": null, + "circuit_parameters": [ + 0.3, + -1.4464727375963786, + -2.8841484100105235, + -3.03774645687452, + 1.9683349641197863, + 2.5934197786078093, + 0.6700123395200417, + 1.441969420022903, + 0.27410390540137985, + 2.7336406607023154, + 1.9845664104768632, + -3.1243861495570098, + 2.2456372993781644, + -2.930568260297326, + 1.4429677267223928, + -2.0379158390962826, + 2.281920468786123 + ], + "expvals": { + "exponential": 1.0, + "polynomial_degree_2": 1.0, + "linear": 1.0, + "('exponential', 'linear')": 1.0 + }, + "job_ids": { + "exponential": "fe6d86e9-06a4-40f3-ae6e-31aa7d43ec83", + "polynomial_degree_2": "3713c011-16b7-404e-a771-0812962dfba3", + "linear": "7939d5af-95bc-4cb4-a119-a4fc255dc079", + "('exponential', 'linear')": "09c1d62f-4a39-47c6-aa2d-823b4b84413b" + } + } + } +} \ No newline at end of file diff --git a/docs/challenges/automation/zne/3b/rel_err_3b_exponential.png b/docs/challenges/automation/zne/3b/rel_err_3b_exponential.png new file mode 100644 index 0000000000000000000000000000000000000000..651d27a3e511c7afbfdc6f23a5f150a82d144fb9 GIT binary patch literal 24199 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 z z8Q;FA?A`N8zZvJL5LwL6ojZ4@=wh6x>BUp&T!oIIiPt;6^p~eQltcXYT4{nU|C9)_ zUF$ge1JF@?-E_-IxbLi`aHr7spl?s zRzhz<==f$y-B_RIg-Omeb-A#3$RL+Y6~Vr+s}{P8b)QOqe>74!s+2O-3`f74o@<-B zC8H!=F2a(%p24~rLU-vbZ?+P-8ezdURMuHOJ}V?7hIU`c?!@r%yrzD^ZVYg^{|K#O zFqpIQ_P4|g)|4pgFTcR;xVO=Zin7UadWQ~a@xm><8P(9)bOh~G{!fP%pWkBGBTu_x&Q%`u+kh^itvp0~rp!JV58 zkNPd`U3}6h`&-#huZ|Krci?gNm|er+tcJd0$;Rs0%H3epkJS`6e3e=DOgf~+shm`e zP@Okt);%%6T!RIrW89!&CX?3IWW6aU?Y@Gh-cXI%>P4g3BO~;0vWw>Ce%kWOUxj+a z47TG96gL>S^QY1DkoDQN=vM@Q1|%keWKn55e;c$q)LTnLbfcjJMEywS@u5>z)jPQz zT6Z?zOZ|AFs%Zo733hVUcBrr3HhYJUA?ZJ&&7u9-sUh^n_ZU39a7#M)cT@ngz?@Y2v?)^s06|bh$0Y@ zLvRHa-)2noLJB@mzxf8uF#|Ov2=)L2l!atm!G8#^{I4C-QWl2T03|h)O4MNpt(CyG z;8#2w?b4U*gr`r*`7%7iI5DmQS+^Hv6Oh>jQW!=?>3ITzADs5bq9P*yfi95H*GS$r zO1-=pC}<=B!&KOP(2A_AnonU70@oZDC8A*nMK$F~9ff?3HQ*YNagB3%!Di}NFx9>P znA262oyA?6rN;kCh6=WtRwAVY{!~Z3{P+`1J0`k zOcM0TMb4~l*#I-aSkQN)eyOM&5j=bY4s~>N@TuD%B4ZjNKc|77NbfaOx0$T#sZ9Gm zY=STjs8RmT}cBCq7*_UY-?(GxMcBZw6PHMQGEzl~lRqZJ5xc-u*h$QDJx zQ#?uZ26wM|GGufmOTDwZPf$tJuC5~6jnbTf30V|X{=_FRGPedhNMcU1d{Kszv0~V6 z)vxC|{nlZTqzg{YGwa8n{npV`($&?~yp1mL6vPMlD+={1AJxg%LK#M6Gl_2X5wfhJ zw&ZX;6ny+Ze5LD0zY3}Z0*7bu#bn$$U?1s&Z-^=eM7%dv_FO-Hvobv^GT5hoY&$QTvCB}0OLf@F9&V_!SLExCab2t-mBFdqGx`OjpU@lre!3Z zLCOKpIBQzo0d(W>-DLLJEzd^>Y)6rD-t#U!{E~!rJin2P0`;p@|1` zE_!?)vsZrTc>2wgc<>Mo_GRp+V@&K_Mo&rQjar{+#SU4R@N)gqG(ArZqL&v6_MyVO zviel(&10&%uSR}!Rm$t_a?SG7ka)9*QoIZ+eolr3L$;tQbs|AO-cMZa)7W^|W>1wT z_u7e=NJFFkS+schU`mI%`@$OEQAOTB81r6{KltrgtJDogRh!U)2a=;)sqA#&<&$d< zQNlohe)pHX06Q{;JMGv%U%n*YHD+Y<^)Utp$*V2Z=sPg>*1dM9Oi&Y^4VJ4D!O>2(9O()VFxloWXZw?9fmuObfWGD!^vU@OT_e<5JyRN{=py%?e&+jn&_DMbBHrH@8VO^p1F_UiiJinC|0!TK*bDowIExd(~{&_mAp1 zXi7`vyBC0Nc7`HzJk32ID@YlZo3NoH!zeP59xDQK&Lo5qr z2r1Q2YiLE6Eg9|s8uSxbOlCRW@>_c1Hw@ds+(=IiSI>O_8s7_M2B~imf-fyfSZ?(Yq+gKS+Vn7^X?_-qrHuFu}29XG$G1zOrJApA!%w!rj4ygIvEa`xvcqJw$Ru7TU zZim;-ujOW-tWlO`yCR;x)6=FdW}5j4KHBh`?W zce~TXuCJF>y79QC%DtnJWANFN)>sBV|MS*)q1w=*oFTFkdN8B literal 0 HcmV?d00001 diff --git a/docs/challenges/automation/zne/3b/rel_err_3b_exponential_linear.png b/docs/challenges/automation/zne/3b/rel_err_3b_exponential_linear.png new file mode 100644 index 0000000000000000000000000000000000000000..25968b0df3291e0fae1c1ea4067db0612f3b3f43 GIT binary patch literal 24603 zcmeIa2UwF?yDl8Zf)xgJ1gVMz3q?dF)QF-Cq9Dp3O;C|8y?2#yL}@AlDpe69gMjoJ ziV9JY-djTN5NZO1B>%I5^L@@f`|SUmfB$En>+G}Vy1p-xx8!}-ddmIW&%M@ziyEq1 zHu7!6U@%+MepR`I!K~58U{(jNUkBe@qYp*Ghph7%UFXYoX3lQc9ZfM8t~=Y`vU9#= zd1IHWsiTvnovpM4Rzg~AmxZ&ly_1}zq|HB0kg#(!mn07AUWS`&u>V!h34;;(fd042 zw$?=ngE06kQ6t zp2fz7XyBzs-e52ShwtvV&Asv7hs#$7hlWHM+e1~a z-@cs}laLT9X!!(xXLU>*2tTKFD4f%<*eFdkT{kE(F>%Z#z~bfY|zJWUX+MTxRfL?a!Ddmv}@eN^7{4N zA|iaj6}2|}{QOdiih`Aul?>xG@-Z6ljuqd&eY?Xk*JUdc5gAGIUM3ip_$n53*%}tQ zPSnzN=62-TsebC))ptZLraHt}Yi!>0U0NEkxmo9?-U;Wn_V!T@tpUfy+Oakp2L~y* z4&FhufOUN$mt1NKZwzB&;_9lS`P2SMtS^iNZTvMq#=bKpElsmv1OCJ4sMW1ow^Z^C zh1w2Zx3x`W1sbR51i}=wc6J6eH8sJ@r|0GI@<R*ju7-bN9R2|^Bndx zH#fiPvQfipkXPl-lgsM6#;nH3lW^V>FQ4dK>)YTo)|>)w=$U2T3qSm4*mS!cedR~Nb4+>Cc4KBBo2=xUFQ@3lS+vEHTKVZ$zYfgAnygazBFAN7YC2Flec987 zlH!%t5m??EGUhe(iQ-a{FdQ7bm0K^lsog1`B**2cq4^48%c202(f-0zKJH42j@OI9 ziDd0V`+Sx^j?3I{vN*>1F8ET?F~@H&Qc_Y*6G;B^^%lomJ5Ma|9gC`Z*JNc{e#3!G zg@60RH8eESCtvUjh+3u*`C3kBG{yQ)N@J@v^9@NfMPDbUOq^1!awNlQYHyHVhA}^_ zLnDdyQp{_KaiFrk$hB`lL1El{v%Q=E+0Ezn2EOG};a|IXa?AWb>!(B<=L;4zE(*!G z6)~}Vw6oASTfgehrqNoSYQm`p38}O1IX7x$+#2GkbYSP5-I1jP&T3cI-C{Zq4PN+w zXQ*4P!?#uiGn<+8YeW${bnrwd?&Ar8yfm+0&HLTaFT&8rF#)G|JSbYyH_`YZ!O` z{$kK7jr)D{RIVe+bipa%!J}4Iq%uiY4#A7Urfp@b|75&bBc!kp(CYWFMw?^Vf2`Ba zlN76ye0(m@J6%_xfYMzyq4h>t>2r7FToHbwMEE&1zkzYVT@x--IL;=k<7!hbjSMqM ze|o)g$w@Auiy?BK`8$V1m{W%ry2}QQb~jAM55(IXYmMmIt@fuU+2>IaS?Oq=pqpf* z6+hmpW^#zRSGls=tH&4rc5`v6*V?=02Q55aw1_qNJ{`^GCk|bYxImR&_c^l6e%1c& zrTHG}CPVMyz& zvX}fQLIPAk8+8+|5Lx%fC=TTh#g4HQu^39;{F`NkueVOq^>lTIxy~0B7sqxur$VT! zv(1h3yxpBJDU$$sbWRwrpCW`^KU@_hL-!*WxL6NUZ=~~9nPsy4>>?hMcEx4uPt^Kv z7CvS_d(FVMGp~;2WjOC!n>Fk|w)0(JW5pMge`Mu&b~M>36t6b=f zsoNeUl7vFYac{K`?V&V`I4?D9=ko2D)Vq2$cyVzNaGBD~`Ct6UI;_{dcF@(+d*GPw z{n{og5|R_MjHS%Mp9FqzU`L>)Vsb^;q>TSM<5|L+EyBliGrg)}wUe}$dd}Fnh8yv7 z$=ghJA4{WWC(?=vyKMcuf|5yGRy9V~Td+CP4Oyb$j`;%N=S<18GSWA!0`*v$-dBc& zK-$%>dN23S?_AwaX;YKIbc@M-E$j2G&ezQ!|`1f#ifB%9Jo2$G*6 zDHBax0Z>LobxfBRx;-k$$=LxzTI%1^6&e|tot=GJ_$|fU#U)$#RLZ+|{YP!aZ3z>G zX)SRJQkTYMqN1W0B|JPlp^XL>CGGIOBeavFJI6;HAAM}rNzxuoOK2ETNz#^comWb= zi8jZ&KMD>G&U2#}-LkcXv^`=xPaZ3%o<+3+LcMHZ7A@Zw}Q+=`*=t6@r{z5L(HowI`liu z*FE2EmOEEl-ypw>{|Z4k*G6Gd=!~AH|X~A7WCoFaLvVy z5J_I#OuOce7j5#)C+6y-)Z)fTw|M#13I$DLT|>i8so4rGFp9Ie9gxJG-=?1e=;*rn z$%{*N6)*7<;$b&RWUXxG%zQ?xqK|z=HOz5+J-wYT?hT^?p?G!K+41OmiMnD`T34SA zrLVOj>;%?gN||u@8(-MjKN-V&i(JE&f>zClTCBpBr5fhfvyR(O%{|vb)kWL2*tuij z3BMlyi0T3s&$8CU;qK z5QeMzQ-%R$lW)3ir?l9xU@281X^vAUB*UAMPs(>1x|lWu&iS-*Kryc4!-rGv-n~;v zZhB~zxik3ep25Mv8x9WBr9?`whyBx?r>Re@N_K8eh1yEhmTa3_XtHt2F<)U$-QDiF zR%nOCv84_(7nk{qipNoj@P4ps?0HN~SGq7~GtJ>0O}oS0FvN4TEm1vk$&Z}pU{XUg z)YWaBHY7^qaIHS0@xKHYE_&Jso zm*Z2@OtDHpkRc}`&n3Qtat6{Y96Ftws5^9hUMSa40$0a?dT|H0UbcRhTYj0%#T1>) z@bK_krlzLEc_^UhN@vq`zln$dIP#KcxOKwqRt-Q#Q4jso0K+o^0LC@nsXW0K%v|Ei zTt)?!i^Va%J&{RGR(g>0J(UP_!8rx~;IlenJGgFDURRv(Z2)xZR%BFuLkbY7UW!gf zdJWAM;TM|J*@@FIH}XOzv>d)7A2-E_$^m$2&L(@6n^k5`{Z8k!DE>7g@hv$z$@7tl z7WCJx6`CCgqX~`yLefj9Yn_f&$lKyJM&O#8G)`;DJe%+s>Oa96b6Sq=F}~CD3$H23 z1e(7;fIg~qpKr&(0qY$4bgVP(+7!IvXTux6fYlp*bGp5{fk|X|ti7;B`3|S-B^-3gTkOQk%Nu z&q2JLYdQQQ5EkVME)dwhQOSmYSNhfWg^fZ8bzJEYiEx3o>1QZb-2~oKXucVAmsUdP zdVL}JZ`L_p`J!#1mk9sF-dLCQ-A^sD^#Q@W(n+4cUWjKC924YNH@AVZoqI#%FlLme zFS}|ip8^y?Gf=T%M3F|Cr|%TtxppZN5A;VxdwYBF)iw?y1tL(;sh3A)j!H{!o1LAN zFZj$Aa_`97T$@xQLP6h>Z7zR|#!%@*9e>e$e7b5#uO&6A3j)*)!0#5g(cnceA`>4U zAB&F7A%&O3cF+WGxle6>1&P@QACjVzyr<*xq3~Bmh`(sQvwEX&uBTtUje-PV9iqE( z`Hkt?z7ODmt?lg(A^Y`d7m|X^{VAdZT9i0FrHBz;Se0j1lp)-gknO+f$?=vX%vV=th&Y9xCEyIijetdsVkfr6NI z_=h3x0vX?`s?OwgC{D#+Gc`>V4hZ__K(f0Q4J4C^rR71Z>=#M5HS_xB;N?E@ievgw zwJryQR9c#9zG1AhlSnUD-y@idev=@DBvKOA!&gO8Qc@LxOh+Yod49mY^pKi*e%vdW zso^{UB4hACP~8Wu`482}SJDRMjJAyk5&>!~18ulVhB$qNU}Qjz(%NrFXt1AAxcUaz zHHfYdiG(xD~=1z>UkA zZBZW(IUpDFwq=ZHwfT22Yd8dGS}Og-oKYOZ^HGpB8vPDmCv8GYCZH~$*j`7i?(fe- z4A@ZPZj2*PhYsDll0AT(f@~E!FmeEawfFC9DSA(GPrZCkIrbVDISIqOpN;((F1CHD z0+GP+9SNB=-+aUfhW^@p(le2YZL2WY0&`JdY`fhNQwHe|@}dZ{cA~2l*xUPf)fLuu z-A6>?{@cv#d5ZV>UpC%TlR+e|2B9%bYOHRB0TvP`b_z4{*Py{|LYh3 zSM&w`PaM@sp`6@Y(XKV%0NuaKhACIx7xv|)5NM>@c^ZWr+G6A-9_uxkj~W!_u^#)G z<26h%-|0Z(^YP*5zf!5L%aN=ZW8m99`7LR(4oX}t*v=xeXsmL74zB%O$DZ-JtV&4Q z!uv+z+Oq_xYk8JwBkVn;Y?$x3PejDk?#Zc_KTAtX zPfrttiJK&g9;q8_x_3%NrD%Dka(V7tmttr#Pfj zb~9-c?**IEBQC2xHkMC2e|K_`8`#zE`sRl$Wc`@l3Z8QZGQTYGR8&?d_ds}x%*@Pb9BYX6EivV8#ImCM)UHF}=TubAU$}4vx&T*J`K_k(t@`EMJ>alDX=e3(J^O(0h-=Kfu#0e3RrLG)LAw|#a zUAAuhHvXP{xpPAI8wReFEd9o!5UN83#=p|)RE2{H7miqt{&e;-|B>@oVY(b#W1h!D zRd!b8)5rTobi594RD1Kmha#`Yd;CYl_mbX-qQlXD)=Y+=(;xFaDeB^;6*G z&j7i^n#M7SAswE5Y0GnXT-PiUDjev@72|mv92LQOL~f8@drVOYZ_NA~RIZjNM#0aO4Blavoa1WCL_RI;1z%cfT7dP26hvzWqyn?V z2v?!!7W=1Q3B8NL>C)pqI`8`v^W+bA)rf-xdRxI~=8Ncb7sXemc%e5CQBi;mfO&EN zo(?`9o9Y2yjS70P9d!SG>Ko4jAG&MN)Q3%)O@H{;pAX3;DXm(*Q*gVkaUDz-40^PZ z`5RUBPkl~(fTR0j+(-|^D&e6Kv;^SJymiXIg~kMzNG~oHvMXL3{5@_}U%kBDO#G|} zSRol&ZmUwdv*1=Q+QGtp`XebYbL{-Q#Yj@im{wX#AGEU&;0C@Zw_~E_*T%6P#9O@8 zNp|S@aPQ`r(l|!dv$#Jwm*6#|HJM0T^6)bkYlaL=MtF!UPK&Fv* z+?=Q??6V!moDQWGF*tAw%0&!nhiuOJ{hB{mKnT7vQj%yM=d*)5)Ld9Yt=94U2L1g* zW&Ruvvx8L&O=-TrKn##Ne*Bk6Nn@C4Pjxq?YOx>R&v%Wu=Ez4bT#!z3cz-%P#Bv{w zY4U_9XQ9Z=?wJ2-6RlkN{26JnFBBI7LC4p9I%|gAJ-;0`bbgIEc)-^IMB+c`5ozrKu`?--py{gP!)YY|6cXY+8a5$;m|dK z>i(qD=%hZVRN>>_295uP+x|C+B>qnXL;qn4lK-58GXu(rpSjZs1i|FwWYjhS45yW% z(|3=@=$UgSa@ml*x$&l6Uh)WMOt{M1l8ScP6-}R2Q9+pOT;e6vrOp8E8=6LalB^lY zSt}v9s`PTDxP?d0J)YjW1l7|m#)Yopz`luyyfTzP(FiCPAY!JcdOiXy`kMRz{gCFq zNGW}i53LJ|PDqU)6%mK<#ma$*f}}JV8CwBG1!~~8LE9Oypc~0UG;|O}lf94CYaNlm z0L}uWMk!(W`YnfZDJ|?05dk_EZj{1uBN&B>RlaJn8mLo%OK$IV+@KH4fQpJC!PA8} zALqyPP*Kr76fW3eT;Oa;WS|GqxNCSff^;$$S{=lBcy$PqINgyEaT)AM2{>Hp5UE~U z&mT4rC|NvgOdGCCXl-o`2nevsE-+an&BIgv@Oaa`PQIPxI9B(>wC!;uxwBK?vNe2#spqfc6~`^r zh4%J*yf2?R=32;ZNOYCR5S-F=&vzX|*QM`Nug!pI2hEnMWCYA!+by9H2LSV$)GbzjNN0f-3z&cL zk9hw4c|ZWFuUNBwOid_9rph=RpeWdb(*bbK0<`*TJLvB)w;j}kvgY163q`kkG_q7Z z#L#zPyF6+$KoaEK6=hc}JL8GIYuM{i>j+c1=PDQcX|L~XUB3nXfx(J9J|}rRrPC-x zP<1GHFB}1ndwOo4^ky^yqWY=Il>qp~#Kp@;M@K({!s5pAxH&Gcgwat_m8pmBpw{mS z`UGQd?uLd2)I!sX2rjy1V{-=l0VWLhfXt-kdK^bTw(9|yyK1OVIRH4^#U!0%z=Aid ztq%i^j6w(#Y|DMNN(L;=ePQbQx0;%vI`%Z(1Xn^5G*AJ-%fmdtFuMW*EQkJsh)8c| zz7w*YGns8cE2=NcSANvYxF7rw`Uz0qylt{V714O%EnpL^TT;(NnAY7oF>8UM$;qwx zYs3)=C4#g!*~_3$a_vMT)xG!gK8u4p0)fE?`PgYRLGVKQA^p|*j-!s+cm z$Aqhj%F}a+>De35t7dnu`&gAB=F6Oo6UN%iGUzn6BJaTVUZ6ugj-gw#hXV*YKv596 zAZ`&Qp@@E533axY6mW&1LW**YrTK6shWI5jNqDM0QJqdI&d&a2-cu2zWMFStRJp>O z0rjb(a#L>yOaYXeW5z5wBk$?*#tW!|=MC&vu0(pDN;rW#^mHWjDqeQv=HvjPJr3%f zwMdRw`rxsG1%UJ~LY3F@(BEoL6f6Llxn08TWgmXD@;$~}c}7S)!5hjBP3ID*ttuKD zwR@Z46ikq+gtB_#r3a^8+V|6sM_stAfG9W7v+(UFVKY9tARrteWIZg0x)VLuBV7rT zEN_@^4xQ{PeK5J)MEls5#j)pYf`z$^>@X9F++VW zT0ov3YuU!W@ilKpS(gKq8GEk6(|9jW6Q_FvB?te?2P1XRhw>dZ1s^iZv%emcf*zhX z6mAn~0FyceVAQt6o2Xgamc$O0V`0 z+scevHDjs=w{HZ^;FDZ#IHTKgU~3lYQ2=)VAK*B{HDZu{kd702q^OMw9|6Sc=fD|e zhiXE-i_{|}2I_9XwYT?tu{qL-JVfQwy-hqfAY?%+?~e%U+zzB_L=+IPASeq8RiQcl zRRr`Sc96D#3`RWw=$7m`9T5-!whjM8r5)ljjF~f$KNvnLR9Dg|G=e+a+FnFuKMw%F09mK7-?D?zg_S|fEwitQk>`OS zV{=?k_-xmU*m4z~iw8o4?`#wq&BlxsA3Qn4D^yj35C;lzZf?Z3gKq$-arYNE+Wo0g z(PF1_&xf_EP%^c*f)M>P{G-$o`q%LJZ&yc8IK;v50kQdXyTHj9`~^r<0M`P*OelG& zK*uC$pChmnugN}-+WHAsh}a7)evB5u7IVD_&)?8R#IGn~B}N)OG-fTeXtAZeb7>UU z!s&MFG{F&6ZFr)+;DKNjSsl`E6eiunNeBL9QC8gm-@`uZwCLfwW;0U1c2Eh&Ak#TPQIgvCIk z1SD%Yu+e!5o5+AmiXfp+!!x)u7l#tMY&G8}J`(mTf(mvtl;un z_!tndusmBsY!e&qAdy0#p9z&liVnY=rlXbBA?757DIp?+uP2!H9QzxMbvQCU5deq^ zQaUxxfMS}+*l(KVG>rA}oliENXOYI1KbNI?n`h&HF%SHaQM(Gr0vh`wBA^v{89@dJ z?@-c+$ZmwVmm6@5%gakGB_xLqcps=0j>mcoK1aw8nIp+_O#Ef#!4`QLcsMJvR*9G0 z@5a81rVE##TT zvH5@iFh6px+h=$SA=)x)hx5`*@$NMQf)2Y9K}s>*_B+3sq61Cb za#)qHqB(m2Ad%?2UHU3ct_hoEx4py z2LL1vdJzYz`rV`EFje*fKT^>nVNeb!en*NR1ONmL7-Bb!+a?}~Pw*G3F{W`h0IhYs zg2&69?c_!Rhy=T{9?*YqQ{cp_OB%`#7kwtPm^AKb_mhXQ6F++5_}3Iw^%|HFPQ?SZ z=KuwR}y(=cGP`B*fF+FL;y&ENw|Z0CDxj37$XZ-x$)X-HOB13$H!-+r!97 zE31Q$+Uem4>T{E!1yuH#E)!M7?6Y6`Z^ zb{2Zrs(>>;a^w2-mn>f3 zI4btWtuvVmi(B3+BIGs!QM$NAGZJ7OKbojMh>Z^e0!mo)lDM1FyRZD{bSHkvAVq&Q z|1>k>SmLH$^Y!aFL}rMHfV8R)$btZXXWV|z91EbPh>>^uZvUE13>OfoBL7Cr-%HQLwoROPRYa#$BL2}bu&SM+|p2}hX zj8o7-r#~u8kCSVh{UREN7BfMo<{2!f0?{Lc!Rk0%359`bDQ`XmRHmN7T~L4)Waa9o zK;MRgly>pJC%HZb zlx?G`*r*7gJ}hKm^IaZrH;kruu8=rLj1cPvybA#RmF|#ygvUymjS$1R#3xr8(AiI* z&|U2I=en`N*F(D#mD$Ly&?uPXLt;Q^6?e;l4;2{pPx`lJA-NwwFaX)`Gjs`1arMFq zst~bCR5Sd*A+cL-y1Kg9#u+=pJZi5(!Zxwq2KPB>1^E#~BO*73wO@WD{j=r{KgZ2o zH{#5h?VZN)ZL-V}0ke=yh_tXe3VezL)hU$Y{0-&bPQwu>Sk=F~ya;MtrR0(xA}`t# ziLyNESg%wQf3Ln#@T5~pgkf|b69J-vY^BfAegzsRA}qQw@${4f!~^^ki%I{nmix|d z!N3S3%`b2oP^FEMbBc-t;8vgd9Q0s~78<%VHj%XVu|e%tZeTq@AYTE#fk?B-u0kGo zZA2eJk_N|Ji@2N82jSMW^-dG*$M0-}KkY})@3nXkkO$Bc37^5&!1>N3X+PvKa=(75 z3Jr<7RsK3QUI$_ltbLCiXlti4;}~L0@Qo8S>Wu%W|VOf#Mfs*aRijX0uWz_tU-fYB|{Dpt3=Eia(mSk z^ZByR0@nXL1mYENBC2_yAd`}j;Q{Or7!cqzR9%iL8qkN?l8Xhoxj|LVe$0PbNxf|@ zN{P@ymm#^EkWE2eiG~ouv{~l!?_2=b=!ml%gyi?{?cWZh8Rlp7{j(~Bg@*yCND;PL zBsmi3Xmq02fOSE?9?E}s4zL&7l`20tHo{eKIms&`5Cg_S)EY1$~Ar=8DB@yVRB6JrJfa)S-Q*UfV;7Lk#_j2jO*m4=}ugrkHZ~;(g zTe=Y01Ct7)EXgk1G=ln-)d@zLRNWPAl*SX_c2J?Rv>Uyx#_xtJ-(xp@Z*leS$Uxfl+(w9+SYG=0-YRmK|-wp@pjPShlKA}u^Ya;-GDesP`W|l95YOALg@@lR45r0 zx1TRS00SufiVa)>;+FeGJ>G4F1H0VvgX&NnC<0o_fpj@^qX&pLLq3d369qOW3UPUj zICPCyYPZ3Eo@aTCZ~DU~NkBsZY?k2rP49`}7bAqh6oJ-)()<;SB=i%xqCMWCm`k@~ ziH8mf%7e9uh!}m(ZK9p1I>svgBY7#r?v_n7G!yik8`c6xOBWVG+$35Swg|JV7ZEeU zUMY=|rI1MA7LV!?*bl1F;=_VVX)0Ai4qM;^{TV(e)55 zj%df#6gn76NXZ@eY0L(&M^tvoGt*ke?iU!t!=ZALS2YYBeNws4;!B2D3)}k7pMnVk z0kTjsdgy0w;dQ_d2h!0P-G1=Zw3$8SnY*A^1#I+XTNedo^5e(D^Nyo?^+DSM`mr$G z0*k)jxFq+!V5uyW2X_$=;!UX9r40)XAR>XR+1MXlvbEAQC;|xsN-Lp8N3{q@5Bea9 zr$cBYGbY{sqFae(M>-+;s=z=%f8g@v%ShW&0W_&-7n{RAEq?-N9`I-oqErAZ-v&zx z!fa6{FMTOk7{5;hS*D1HZCAnZo(S~I0;KfK`kn<{ldq%DpY|5SqZav)z}TehU%VgU zy1l&U7b_KkG=<2%!i)ug3Vo2>wSFC@UVBtgk)c8>^ksPVvTq!uDS_uS)pLEV4o?$` zV`32;Po zA3-0C9GD390Lc__nv^%_7xso5ghotEO#B6X$$==qAUOPbw z?>k`K6PO!_2_6wg(YQHEH4BL&+7VGNsD_994`~5-VqoWDAF*SvOT~^XB&9+GB=C?> z2}96E%dt_I>eJr`w<%TGhjSTjDPg+6>QxnJ5&}+v3=b{|AQ<=SKPfFB6j3IMFomeo z3oDBdfP#eJ_lj8P(08_X2f}JW#MX5m#kX%{mj_GQp?g*W^g{^9fbo`gqp(n_2P`@) zHb2LB1b<;fKj`A!P$0#s|Ca&*jp6@>Z5sY_HrfAw+QZ`i!ojK0C|G6RiRx6KVR=9d z7L4lGziL(}-x0Ma+NJPp{g1`*chTyaj{uzhDM4i`xBf>7*Ac|?wwcGBQBfJyRbh*_ z{(W@nR#ZzzEc<{AFBDi!)R^;L=(#UnFl7U8$8T4}%_XD|Fcjyf1j_-|7;IeB`jP*& zj#dsVv)?UL@}&!jJ4K*JQS0#p?cvCq0A& z@s(*ng)+%rF~YK~;gp0>B|fjHYxO@C{Nr1*#$Q4W1npH+J%rhAlpT)Ympy(woAQ?Y z-&1iyAN_uhb#(|#jEc%92(Hwtlc4~4+{C#4#RH+q^jMhs$OUYkLY>bQDEDD4a)(2g zrteJH_Nrc94?uw`pYAxd(rn$%?KJkPa zW-0oCls?d)u$D#=(Q7M>ez=+p-O$)bAnvXJRs6XFd)0I3f{?ROKN9$Yx-tHjXxAU_ z;~Mio2%4KvkwE{{1a?bNTIlvi+y$&dURbR0i?x>LlrMc8E4esoLxCQ@*9gJaNVxi^ z9}T&%S|v0>8DTp=76Y;>%7sI$<+wi7%dj0|QFBXt-fmi4`iH>M_qwj#*KCUSkbHjD zru}L^u%MuG<;hY}PzoQGDOtQw1bS2lDEm=wqSBb@SYLJHE^{=E`6r78+Qws!&%s2g zsz3PwrQ~GEbN`hPQkaVl(c;J|K}`+DfHVn7O{jzN z@?Y}xW8c<^Bf?aPxzLAt#(?9A&_3%0jQ!j>^Vw}uRu^=+rvInJnws*)(+8(PfPxgO z0HK)2YN7go(WhtrGLQs_LFLo;Mw8{_7%o|9X*gkFI@GUdXacuT#)YVn>hv>5Jbs)+ zg{#1gDbdF>0|I^(3|z18iWZr(fe`oI2*iwfw=E$BmaQP3wneJxTS;z zXi!M^AazUW$n-#@aRnmdRsTxZ^K3J?=6#7M@_n&bKWxZwyUzL8iy~C&PD7hfRfW9( zqXR@xzZE9)DgeLYub?*Gr=?Ggm+DCa%!co>b2BEI2yL|h z9rgs+}) zDa$5`)_!706iDGKTbRK=ndWRZ(CbO*O+NfyT9&TmsA{^es_w z3Okkn{U##RQq|krTk8`U5wR3^5E>6~2}?TB?dP@;=Nq=R5}@x=(pl*h7QW%@UNdcVEMY=b6BtuZNSk7#p`plTR^d* zJFGyblXB}U#uvt0ZKh^lx7`XEJ6NgC_XR8njxLCLde>=V|u zwvT@8O)=Kf`ywK8ct>CePUDE8{xvSbr+lL{n%~PinK!2*(Z*blD>pN5Qz)=i_`p!UGyu666mc~G+&4*N81D4 zIzjKdGTipT5{xwDSo|FL5wxve;+o50P>h~L^J>ybl>4Lxwc4Mg6h6@2KA!3kdl3^e z;bv+BbUV9kg|t4X%>)D+3LP;qzvPtOhVER7&S7Y)f>**bAwBt6TFIoOG}f9YTANUF z59oK~nV@&;vJG7}^~;5Z!0IY!@TBNemhBg9)>@hP4f?xWLmuK_V-Ao257%dAWi^)A z+Ly{;Z9M%m&LFL{D(v6lW}HdI{cEZR=TzULH6Isw)qHaAB|>0#4j z=h(9!6~DH3dd?r3DRd*Wy&y}jq`>~ge6_67u)-p+W%Df8+Ru8;$@dZ(?-(DERrBQV zOjvhT_}IcGRy^F6ne+zA2QXwh{^bX?0YaSCH@P*en(L|yzLWVwLF=lY+k>tgw#MU# zHDSRjLe)=YCH?5UpkL^xX`;8cWZ+iU(+qRJG7FVOgf&5%B%-0|LA&4*G1R844wfm{q& z3*!;m0EVODUW3KTs(#SL!;-o-*g!4`v@#_pB|!xZ4G4BC2P_+J2y)-meqVm?d($yd z0ky@_9X04+z|L$eL*7oJ7k=G5Br(;(uF012>(6`w!fqH+7!W-rls5@Hk&&x@1rY$X zO=FdiE)%5Z*oaNhH}7xJ7ZGAPLY#j;Gy#+IqUz1%``E`oR{O~f5`x-^UdNrcb6&=( zRZNp83w`}Z&%)ifysBS;af5Ua?VN-}_b|DT1sRjckT886e!mLQ14(1x`CtQ{wCBLE zf}+&wk8LTSrGZtlC_f{CEL;O!Dmr}u=w3QrYqOly=buD_X};?q2ml~>6aYK){5xR= zT>d}2>1yfo_bV%7p+6exO$OhCdJ8xgm@uiV$!nlyLXu6u9wK8n=sb3ijez<^ZG!%D zP}Phlb=eXjG{Qaxs7noy10fFxsA@73te1PCxBa19y8RfC4I;YH z9!>--7&L@EUFd59tdMRpcnRu9*a>Hr3heh_%QKVycS?4c)I6VC&8=(3YOAh1+gfDuKO03kv*L2h0Z|DF#~+8{@nhbGr}pWmL^AhaxLc zZ7HZI3*96nSAlnjnyvz}AH>1)Z?i#M83=pGmU6;gKr9-xlT~9SVD~!cEpv+dX`^dtZ&N{R-H{Yef@T<^sndBWxuQG4`+7h<@GV+Rc#L`;k|01zn6F_RS<56x;8;kd5zGs^928a|)ApVnFk!yr z^osxlO~7^G<9Gl3dv~aNW&kt1+U_ zVFp`Yva|SDXn95?U?)){q_QfJIStefXdjSo!BPlSSEm&9JanuB zaK8(21S>XJ9D^QtGC31Aw4)LoWdDQ)v2R|cmlxzIh@xK9^8f(G?2;iylu){z04=vV z>5q}RD+ohb^kRV5M4!;5BCj58@KbmMv?v0yGnW}`KT`7vi^D_I2WO0y>be0Hg}8?$9|Dj*K4$G9aL{B6jEa zy_vloeXu-*d;0!uvx}hHN3cCEjzYWGCK&G`7qdE7)vhzv|3j`8@&Wx6LAn|Y1O#L* zd$fBQRThKYfHpS{dF|G&nZ|P}p$=Qm@FIx9(xA_)X*bfb)Z2X^w%B9N#kcu6r~HYp z4Wl+CqHRK8pNy8C!Kx_O5J~$GW5^kz&f`h}GcSdagG#X5-A!H@cl{R!U#-Gkfcm=h zC1mn)6kG8Ou>NuRkjeuDk{Deu@5-TYQNFSM_tdfHQtn^tv0hE%M#QjNq42ssc9fA| ze5Tj<^H`GQsRV@y>hS!}eC670nCP>pQsZpoCnmVX8$qkA?H1>}cB}RN=b*)gBr4C@ z2$(OABIjk2{o3{7ZRyrj2&CzMtkNuG3pThzjpM*w6e;qpCa*gtLIl3KO8QTXI?Jh& zgg$J?RP(`p)9>*R*8w7QNd0V0Fv87@oKh?_Piw2myBmQ7)L!&!g%v*MDjRG=%am_& zb#(Lte3fr@x%l(Zyz#I(3t0=V)uonwu-nSD*WVLA?j`_t01(-BpX;r%q5bw!-R_T9 zW&TV4W-oTOoIl2KPt<=*(9JFg-z7x&`L$76Xy;^tL}6Tma*tYU$7(1J;jxaqmJzfE z&+52)p+QnF(4g6d`^Hcy7ApawVzVRZBJ zsHngIqW`;8s1rO&I~a2xUNFpdSOF?nC*n1Key2i}r6jnn7s(aYxCFR&Rx8}SN0N)Z z={5I8)d==~b@LL3e%s57txnh48D_epHlbxXKViI(%1eH;P!?$W`a}Id8wZzKn`w7L z0&@H2EN$^#wd$?18>G*WYu6+}mciS$=_Z6H;l{akSzE&8boc?Za_vOhVHL~V4zMKH zaqe;Dc(&p?N+J3D1x%?h?`9tG>XuAc^iU4+N-mc;#v2Y&3g{<6F^9q##C3qN3P>Oe zMHiCf1fMmjxqKaBG)Rw1~U4 z$C5)wF=)keKgbUc-;kNH{f!=fHIH>H~WLtJfiFn(RD0_|5=k z9kLqp-6hOPzJHU0X^>xyAtGc7#sHMYbLYz%iKOjqHHx&(-wl4k-~;vUBQ&$sfxWuo hKV+Nvf1Pb*`cWSR@6d9_$e`y@JENhJdg|KU{|CY6-(CO! literal 0 HcmV?d00001 diff --git a/docs/challenges/automation/zne/3b/rel_err_3b_linear.png b/docs/challenges/automation/zne/3b/rel_err_3b_linear.png new file mode 100644 index 0000000000000000000000000000000000000000..c18cb65671043cacfdbdcb7c4635847592c4262f GIT binary patch literal 23570 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

s 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 K^nBl$EB_y!XuEd+ literal 0 HcmV?d00001 diff --git a/docs/challenges/automation/zne/3b/rel_err_3b_polynomial_degree_2.png b/docs/challenges/automation/zne/3b/rel_err_3b_polynomial_degree_2.png new file mode 100644 index 0000000000000000000000000000000000000000..34258813684b57cd6e4d4b85877016ac8570db17 GIT binary patch literal 25265 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 literal 0 HcmV?d00001 diff --git a/docs/challenges/automation/zne/automated_zne_challenge2.py b/docs/challenges/automation/zne/automated_zne_challenge2.py new file mode 100644 index 0000000..cf58a93 --- /dev/null +++ b/docs/challenges/automation/zne/automated_zne_challenge2.py @@ -0,0 +1,226 @@ +from collections import deque +import itertools +import json +import numpy as np +import os +import seaborn as sns +import matplotlib.pyplot as plt + +from qiskit.quantum_info import SparsePauliOp +from qiskit_ibm_runtime import Batch, EstimatorV2 as Estimator +from qiskit_ibm_runtime.fake_provider import FakeSherbrooke +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager +from qiskit_aer import AerSimulator +from qiskit_ibm_runtime import RuntimeEncoder, RuntimeDecoder +from datetime import datetime, timezone + +from circuit import ExampleCircuit + +def create_logical_circuit(num_qubits, depth, seed=0): + logical_circuit = ExampleCircuit(q, d // 2) # Halved depth + + # Compute-uncompute construct (doubles the depth) + inverse = logical_circuit.inverse() + logical_circuit.barrier() + logical_circuit.compose(inverse, inplace=True) + + # Parameter values + rng = np.random.default_rng(seed=0) + parameter_values = rng.uniform(-np.pi, np.pi, size=logical_circuit.num_parameters) + parameter_values[0] = 0.3 # Fix interaction strength (specific to MBL circuit) + logical_circuit.assign_parameters(parameter_values, inplace=True) + + return logical_circuit, parameter_values + +def create_wt2_logical_operator(num_qubits): + wt2 = deque(["I"] * (num_qubits - 2) + ["Z", "Z"]) + logical_observables = [] + + coeff = 1/num_qubits + for _ in range(num_qubits): + wt2_term = "".join(literal for literal in wt2) + logical_observables.append((wt2_term, coeff)) + wt2.rotate(-1) + + return SparsePauliOp.from_list(logical_observables) + +def heatmap_plotter( + rel_err, + widths, + depths, + filename, + title, + directory, + xlabel="2-qubit depth", + ylabel="Number of qubits", +): + plt.rcParams.update({"text.usetex": True, "font.family": "Helvetica"}) + nrows = len(widths) + ncols = len(depths) + + ax = sns.heatmap(rel_err, annot=True, cbar=False, vmin=0, vmax=100, cmap="binary", fmt=".0f") + # Drawing the frame + ax.axhline(y=0, color='k', linewidth=2) + + ax.axhline(y=nrows, color='k', linewidth=2) + + ax.axvline(x=0, color='k', linewidth = 2) + + ax.axvline(x=ncols, color='k', linewidth=2) + + xticks = np.array(list(range(ncols))) + 0.5 + ax.set_xticks(ticks=xticks) + ax.set_xticklabels(labels=depths) + + yticks = np.array(list(range(nrows))) + 0.5 + ax.set_yticks(ticks=yticks) + ax.set_yticklabels(labels=widths[::-1]) + + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + + # plt.show() + + plt.savefig( + f"{directory}/{filename}", + bbox_inches="tight", + dpi=200, + ) + + plt.close() + +if __name__ == "__main__": + num_qubits = [4, 8, 16, 32, 64] + depths = [4, 8, 16, 32, 64] + extrapolators = ["exponential", "polynomial_degree_2", "linear", ("exponential", "linear")] + # backend = FakeSherbrooke() + # backend = AerSimulator.from_backend(backend) + backend = AerSimulator(method="matrix_product_state") + + # create all circuits and observables + logical_circuits = [] + logical_observables = [] + circuit_parameters = [] + for q in num_qubits: + for d in depths: + logical_circuit, parameter_values = create_logical_circuit(num_qubits=q, depth=d, seed=0) + logical_circuits.append(logical_circuit) + circuit_parameters.append(parameter_values.tolist()) + + logical_observable = create_wt2_logical_operator(num_qubits=q) + logical_observables.append(logical_observable) + + # optimize circuit and observables + pm = generate_preset_pass_manager(optimization_level=3, backend=backend) + physical_circuits = pm.run(logical_circuits) + + physical_observables = [ + logical_observables[idx].apply_layout(layout=physical_circuits[idx].layout) + for idx in range(len(logical_observables)) + ] + + pubs = list(zip(physical_circuits, physical_observables)) + + timestamp = datetime.now(timezone.utc) + with Batch(backend=backend) as batch: + estimator = Estimator(mode=batch) + options = estimator.options + options.default_shots = 1000 + options.optimization_level = 0 + options.resilience_level = 0 + options.resilience.zne_mitigation = True # Activate ZNE error mitigation only + + jobs = {} + for extrapolator in extrapolators: + options.resilience.zne.extrapolator = extrapolator + job = estimator.run(pubs) + jobs[str(extrapolator)] = job + print(f" - {job.job_id()} ({extrapolator})") + + + results = {} + tmp = list(itertools.product(num_qubits, depths)) + expvals_all = {str(extrapolator): np.empty(len(tmp)) for extrapolator in extrapolators} + for idx, (qubit, depth) in enumerate(tmp): + label = f"pub_{idx}" + results[label] = {} + results[label]["num_qubits"] = qubit + results[label]["depth"] = depth + + # physical circuit is encoded using `RuntimeEncoder`. Use `RuntimeDecoder` to decode + encoded_physical_circuit = RuntimeEncoder().encode(physical_circuits[idx]) + results[label]["physical_circuit"] = encoded_physical_circuit + + obs = physical_observables[idx] + paulis = obs.paulis.to_labels() + coeffs = [str(coeff) for coeff in obs.coeffs] + results[label]["physical_observable"] = { + "paulis": paulis, + "coeffs": coeffs + } + + # layout + layout = physical_circuits[idx].layout + final_layout = None if layout is None else layout.final_index_layout(filter_ancillas=True) + results[label]["final_qubit_layout"] = final_layout + results[label]["circuit_parameters"] = circuit_parameters[idx] + + results[label]["expvals"] = {} + results[label]["job_ids"] = {} + + for extrapolator in extrapolators: + extrapolator = str(extrapolator) + job = jobs[extrapolator] + + primtive_results = job.result() + results[label]["job_ids"][extrapolator] = job.job_id() + + pub_result = primtive_results[idx] + evs = pub_result.data.evs.tolist() + expvals_all[extrapolator][idx] = evs + + results[label]["expvals"][extrapolator] = evs + + all_data = { + "num_qubits_list": num_qubits, + "depths": depths, + "extrapolators": extrapolators, + "batch_id": batch.session_id, + "job_ids": [job.job_id() for job in jobs.values()], + "backend_name": backend.name, + "timestamp": timestamp.isoformat(), + "results": results + } + + + name_signature = f"challenge_2_{timestamp.strftime('%Y_%m_%d_%H_%M_%S_%f')}" + name_signature = "2" + if not os.path.exists(name_signature): + os.mkdir(name_signature) + + with open(f"{name_signature}/data_{name_signature}.json", "w") as jf: + json.dump(all_data, jf, indent=2, sort_keys=False) + + # plot heatmaps + for extrapolator in extrapolators: + extrapolator_str = str(extrapolator) + + evs = np.flipud( + expvals_all[extrapolator_str].reshape((len(num_qubits), len(depths))) + ) + rel_err = 100 * (1 - evs) + + if isinstance(extrapolator, str): + extrapolator = [extrapolator] + + heatmap_plotter( + rel_err, + widths=num_qubits, + depths=depths, + filename=f"rel_err_{name_signature}_{'_'.join(extrapolator)}.png", + title=r'Error (\%): ' + r'$\overline{\langle{Z_{q}}\rangle}$' + f' {extrapolator}', + directory=name_signature, + xlabel="2-qubit depth", + ylabel="Number of qubits", + ) diff --git a/docs/challenges/automation/zne/automated_zne_challenge3a.py b/docs/challenges/automation/zne/automated_zne_challenge3a.py new file mode 100644 index 0000000..624855a --- /dev/null +++ b/docs/challenges/automation/zne/automated_zne_challenge3a.py @@ -0,0 +1,221 @@ +from collections import deque +import itertools +import json +import numpy as np +import os +import seaborn as sns +import matplotlib.pyplot as plt + +from qiskit.quantum_info import SparsePauliOp +from qiskit_ibm_runtime import Batch, EstimatorV2 as Estimator +from qiskit_ibm_runtime.fake_provider import FakeSherbrooke +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager +from qiskit_aer import AerSimulator +from qiskit_ibm_runtime import RuntimeEncoder, RuntimeDecoder +from datetime import datetime, timezone + +from circuit import ExampleCircuit + +def create_logical_circuit(num_qubits, depth, seed=0): + logical_circuit = ExampleCircuit(q, d // 2) # Halved depth + + # Compute-uncompute construct (doubles the depth) + inverse = logical_circuit.inverse() + logical_circuit.barrier() + logical_circuit.compose(inverse, inplace=True) + + # Parameter values + rng = np.random.default_rng(seed=0) + parameter_values = rng.uniform(-np.pi, np.pi, size=logical_circuit.num_parameters) + parameter_values[0] = 0.3 # Fix interaction strength (specific to MBL circuit) + logical_circuit.assign_parameters(parameter_values, inplace=True) + + return logical_circuit, parameter_values + +def create_wt1_logical_operator(num_qubits): + paulis = ['I'*i + 'Z' + 'I'*(num_qubits-i-1) for i in range(num_qubits)] + coeffs = 1/len(paulis) + + return SparsePauliOp(paulis, coeffs) + +def heatmap_plotter( + rel_err, + widths, + depths, + filename, + title, + directory, + xlabel="2-qubit depth", + ylabel="Number of qubits", +): + plt.rcParams.update({"text.usetex": True, "font.family": "Helvetica"}) + nrows = len(widths) + ncols = len(depths) + + ax = sns.heatmap(rel_err, annot=True, cbar=False, vmin=0, vmax=100, cmap="binary", fmt=".0f") + # Drawing the frame + ax.axhline(y=0, color='k', linewidth=2) + + ax.axhline(y=nrows, color='k', linewidth=2) + + ax.axvline(x=0, color='k', linewidth = 2) + + ax.axvline(x=ncols, color='k', linewidth=2) + + xticks = np.array(list(range(ncols))) + 0.5 + ax.set_xticks(ticks=xticks) + ax.set_xticklabels(labels=depths) + + yticks = np.array(list(range(nrows))) + 0.5 + ax.set_yticks(ticks=yticks) + ax.set_yticklabels(labels=widths[::-1]) + + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + + # plt.show() + + plt.savefig( + f"{directory}/{filename}", + bbox_inches="tight", + dpi=200, + ) + + plt.close() + +if __name__ == "__main__": + num_qubits = [4, 8, 16, 32, 64] + depths = [4, 8, 16, 32, 64] + extrapolators = ["exponential", "polynomial_degree_2", "linear", ("exponential", "linear")] + # backend = FakeSherbrooke() + # backend = AerSimulator.from_backend(backend) + backend = AerSimulator(method="matrix_product_state") + + # create all circuits and observables + logical_circuits = [] + logical_observables = [] + circuit_parameters = [] + for q in num_qubits: + for d in depths: + logical_circuit, parameter_values = create_logical_circuit(num_qubits=q, depth=d, seed=0) + logical_circuits.append(logical_circuit) + circuit_parameters.append(parameter_values.tolist()) + + logical_observable = create_wt1_logical_operator(num_qubits=q) + logical_observables.append(logical_observable) + + # optimize circuit and observables + pm = generate_preset_pass_manager(optimization_level=3, backend=backend) + physical_circuits = pm.run(logical_circuits) + + physical_observables = [ + logical_observables[idx].apply_layout(layout=physical_circuits[idx].layout) + for idx in range(len(logical_observables)) + ] + + pubs = list(zip(physical_circuits, physical_observables)) + + timestamp = datetime.now(timezone.utc) + with Batch(backend=backend) as batch: + estimator = Estimator(mode=batch) + options = estimator.options + options.default_shots = 1000 + options.optimization_level = 0 + options.resilience_level = 0 + options.resilience.zne_mitigation = True # Activates ZNE error mitigation only + options.resilience.measure_mitigation = True # Activates measurement error mitigation + + jobs = {} + for extrapolator in extrapolators: + options.resilience.zne.extrapolator = extrapolator + job = estimator.run(pubs) + jobs[str(extrapolator)] = job + print(f" - {job.job_id()} ({extrapolator})") + + + results = {} + tmp = list(itertools.product(num_qubits, depths)) + expvals_all = {str(extrapolator): np.empty(len(tmp)) for extrapolator in extrapolators} + for idx, (qubit, depth) in enumerate(tmp): + label = f"pub_{idx}" + results[label] = {} + results[label]["num_qubits"] = qubit + results[label]["depth"] = depth + + # physical circuit is encoded using `RuntimeEncoder`. Use `RuntimeDecoder` to decode + encoded_physical_circuit = RuntimeEncoder().encode(physical_circuits[idx]) + results[label]["physical_circuit"] = encoded_physical_circuit + + obs = physical_observables[idx] + paulis = obs.paulis.to_labels() + coeffs = [str(coeff) for coeff in obs.coeffs] + results[label]["physical_observable"] = { + "paulis": paulis, + "coeffs": coeffs + } + + # layout + layout = physical_circuits[idx].layout + final_layout = None if layout is None else layout.final_index_layout(filter_ancillas=True) + results[label]["final_qubit_layout"] = final_layout + results[label]["circuit_parameters"] = circuit_parameters[idx] + + results[label]["expvals"] = {} + results[label]["job_ids"] = {} + + for extrapolator in extrapolators: + extrapolator = str(extrapolator) + job = jobs[extrapolator] + + primtive_results = job.result() + results[label]["job_ids"][extrapolator] = job.job_id() + + pub_result = primtive_results[idx] + evs = pub_result.data.evs.tolist() + expvals_all[extrapolator][idx] = evs + + results[label]["expvals"][extrapolator] = evs + + all_data = { + "num_qubits_list": num_qubits, + "depths": depths, + "extrapolators": extrapolators, + "batch_id": batch.session_id, + "job_ids": [job.job_id() for job in jobs.values()], + "backend_name": backend.name, + "timestamp": timestamp.isoformat(), + "results": results + } + + + name_signature = f"challenge_3a_{timestamp.strftime('%Y_%m_%d_%H_%M_%S_%f')}" + name_signature = "3a" + if not os.path.exists(name_signature): + os.mkdir(name_signature) + + with open(f"{name_signature}/data_{name_signature}.json", "w") as jf: + json.dump(all_data, jf, indent=2, sort_keys=False) + + # plot heatmaps + for extrapolator in extrapolators: + extrapolator_str = str(extrapolator) + + evs = np.flipud( + expvals_all[extrapolator_str].reshape((len(num_qubits), len(depths))) + ) + rel_err = 100 * (1 - evs) + + if isinstance(extrapolator, str): + extrapolator = [extrapolator] + + heatmap_plotter( + rel_err, + widths=num_qubits, + depths=depths, + filename=f"rel_err_{name_signature}_{'_'.join(extrapolator)}.png", + title=r'Error (\%): ' + r'$\overline{\langle{Z_{q}}\rangle}$' + f' {extrapolator}', + directory=name_signature, + xlabel="2-qubit depth", + ylabel="Number of qubits", + ) diff --git a/docs/challenges/automation/zne/automated_zne_challenge3b.py b/docs/challenges/automation/zne/automated_zne_challenge3b.py new file mode 100644 index 0000000..96ebaa0 --- /dev/null +++ b/docs/challenges/automation/zne/automated_zne_challenge3b.py @@ -0,0 +1,233 @@ +from collections import deque +from datetime import datetime, timezone +from dataclasses import asdict +import itertools +import json +import numpy as np +import os +import seaborn as sns +import matplotlib.pyplot as plt + +from qiskit.quantum_info import SparsePauliOp +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager +from qiskit_aer import AerSimulator +from qiskit_ibm_runtime import Batch, EstimatorV2 as Estimator, QiskitRuntimeService, RuntimeEncoder +from qiskit_ibm_runtime.options.utils import remove_dict_unset_values +from qiskit_ibm_runtime.fake_provider import FakeSherbrooke + +from circuit import ExampleCircuit + +def create_logical_circuit(num_qubits, depth, seed=0): + logical_circuit = ExampleCircuit(num_qubits, depth // 2) # Halved depth + + # Compute-uncompute construct (doubles the depth) + inverse = logical_circuit.inverse() + logical_circuit.barrier() + logical_circuit.compose(inverse, inplace=True) + + # Parameter values + rng = np.random.default_rng(seed=seed) + parameter_values = rng.uniform(-np.pi, np.pi, size=logical_circuit.num_parameters) + parameter_values[0] = 0.3 # Fix interaction strength (specific to MBL circuit) + logical_circuit.assign_parameters(parameter_values, inplace=True) + + return logical_circuit, parameter_values + +def create_wt2_logical_operator(num_qubits): + wt2 = deque(["I"] * (num_qubits - 2) + ["Z", "Z"]) + logical_observables = [] + + coeff = 1/num_qubits + for _ in range(num_qubits): + wt2_term = "".join(literal for literal in wt2) + logical_observables.append((wt2_term, coeff)) + wt2.rotate(-1) + + return SparsePauliOp.from_list(logical_observables) + +def heatmap_plotter( + rel_err, + widths, + depths, + filename, + title, + directory, + xlabel="2-qubit depth", + ylabel="Number of qubits", +): + plt.rcParams.update({"text.usetex": True, "font.family": "Helvetica"}) + nrows = len(widths) + ncols = len(depths) + + ax = sns.heatmap(rel_err, annot=True, cbar=False, vmin=0, vmax=100, cmap="binary", fmt=".0f") + # Drawing the frame + ax.axhline(y=0, color='k', linewidth=2) + + ax.axhline(y=nrows, color='k', linewidth=2) + + ax.axvline(x=0, color='k', linewidth = 2) + + ax.axvline(x=ncols, color='k', linewidth=2) + + xticks = np.array(list(range(ncols))) + 0.5 + ax.set_xticks(ticks=xticks) + ax.set_xticklabels(labels=depths) + + yticks = np.array(list(range(nrows))) + 0.5 + ax.set_yticks(ticks=yticks) + ax.set_yticklabels(labels=widths[::-1]) + + ax.set_title(title) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + + plt.savefig( + f"{directory}/{filename}", + bbox_inches="tight", + dpi=200, + ) + + plt.close() + +if __name__ == "__main__": + num_qubits = [4, 8, 16] + depths = [4, 8, 16, 32, 64] + extrapolators = ["exponential", "polynomial_degree_2", "linear", ("exponential", "linear")] + + # service = QiskitRuntimeService() + # backend = service.least_busy(min_num_qubits=127) + # backend = FakeSherbrooke() + backend = AerSimulator(method="matrix_product_state") + + # create all circuits and observables + logical_circuits = [] + logical_observables = [] + circuit_parameters = [] + for q in num_qubits: + for d in depths: + logical_circuit, parameter_values = create_logical_circuit(num_qubits=q, depth=d, seed=0) + logical_circuits.append(logical_circuit) + circuit_parameters.append(parameter_values.tolist()) + + logical_observable = create_wt2_logical_operator(num_qubits=q) + logical_observables.append(logical_observable) + + # optimize circuit and observables + pm = generate_preset_pass_manager(optimization_level=3, backend=backend) + physical_circuits = pm.run(logical_circuits) + + physical_observables = [ + logical_observables[idx].apply_layout(layout=physical_circuits[idx].layout) + for idx in range(len(logical_observables)) + ] + + pubs = list(zip(physical_circuits, physical_observables)) + + timestamp = datetime.now(timezone.utc) + estimator_options = {} + with Batch(backend=backend) as batch: + estimator = Estimator(mode=batch) + options = estimator.options + options.default_shots = 1000 + options.optimization_level = 0 + options.resilience_level = 0 + options.resilience.zne_mitigation = True # Activates ZNE error mitigation only + options.resilience.measure_mitigation = True # Activates measurement error mitigation + + jobs = {} + for extrapolator in extrapolators: + options.resilience.zne.extrapolator = extrapolator + job = estimator.run(pubs) + jobs[str(extrapolator)] = job + options_dict = asdict(options) + remove_dict_unset_values(options_dict) + estimator_options[str(extrapolator)] = options_dict + print(f" - {job.job_id()} ({extrapolator})") + + + results = {} + tmp = list(itertools.product(num_qubits, depths)) + expvals_all = {str(extrapolator): np.empty(len(tmp)) for extrapolator in extrapolators} + for idx, (qubit, depth) in enumerate(tmp): + label = f"pub_{idx}" + results[label] = {} + results[label]["num_qubits"] = qubit + results[label]["depth"] = depth + + # physical circuit is encoded using `RuntimeEncoder`. Use `RuntimeDecoder` to decode + encoded_physical_circuit = RuntimeEncoder().encode(physical_circuits[idx]) + results[label]["physical_circuit"] = encoded_physical_circuit + + obs = physical_observables[idx] + paulis = obs.paulis.to_labels() + coeffs = [str(coeff) for coeff in obs.coeffs] + results[label]["physical_observable"] = { + "paulis": paulis, + "coeffs": coeffs + } + + # layout + layout = physical_circuits[idx].layout + final_layout = None if layout is None else layout.final_index_layout(filter_ancillas=True) + results[label]["final_qubit_layout"] = final_layout + results[label]["circuit_parameters"] = circuit_parameters[idx] + + results[label]["expvals"] = {} + results[label]["job_ids"] = {} + + for extrapolator in extrapolators: + extrapolator = str(extrapolator) + job = jobs[extrapolator] + + primtive_results = job.result() + results[label]["job_ids"][extrapolator] = job.job_id() + + pub_result = primtive_results[idx] + evs = pub_result.data.evs.tolist() + expvals_all[extrapolator][idx] = evs + + results[label]["expvals"][extrapolator] = evs + + all_data = { + "num_qubits_list": num_qubits, + "depths": depths, + "extrapolators": extrapolators, + "estimator_options": estimator_options, + "batch_id": batch.session_id, + "job_ids": [job.job_id() for job in jobs.values()], + "backend_name": backend.name, + "timestamp": timestamp.isoformat(), + "results": results + } + + + name_signature = f"challenge_3b_{timestamp.strftime('%Y_%m_%d_%H_%M_%S_%f')}" + name_signature = "3b" + if not os.path.exists(name_signature): + os.mkdir(name_signature) + + with open(f"{name_signature}/data_{name_signature}.json", "w") as jf: + json.dump(all_data, jf, indent=2, sort_keys=False) + + # plot heatmaps + for extrapolator in extrapolators: + extrapolator_str = str(extrapolator) + + evs = np.flipud( + expvals_all[extrapolator_str].reshape((len(num_qubits), len(depths))) + ) + rel_err = 100 * (1 - evs) + + if isinstance(extrapolator, str): + extrapolator = [extrapolator] + + heatmap_plotter( + rel_err, + widths=num_qubits, + depths=depths, + filename=f"rel_err_{name_signature}_{'_'.join(extrapolator)}.png", + title=r'Error (\%): ' + r'$\overline{\langle{Z_{q}}\rangle}$' + f' {extrapolator}', + directory=name_signature, + xlabel="2-qubit depth", + ylabel="Number of qubits", + )