{ "cells": [ { "cell_type": "markdown", "id": "083f9cb1-82a6-4147-8594-b32ff4dc9666", "metadata": {}, "source": [ "Fe4N2 - 3 - calculations on Quantinuum hardware \n", "===============================================" ] }, { "cell_type": "markdown", "id": "60c1176b-3c18-414b-a031-420dd2526699", "metadata": {}, "source": [ "This part marks the conclusion of the three-part series tutorial, and the user will learn how to conduct both emulator and hardware calculations using Quantinuum resources on a system more complex than [H2](InQ_htut_qsys_H2.ipynb). It is important to note that one should run the [first part](InQ_tut_fe4n2_1.ipynb) and [second part](InQ_tut_fe4n2_2.ipynb) before proceeding to this tutorial. Additional details regarding the chemical systems, methodologies, and outcomes presented in this tutorial series are available in the associated [research paper](https://doi.org/10.1039/D3CP05167F). \n", "\n", "Let us move beyond a simple single-point energy calculation that is neither optimized nor variationally solved. Instead, we build upon the results obtained in the second part of this tutorial series, where the Adaptive Variational Quantum Eigensolver (ADAPT-VQE) algorithm was used to compute the total energy of the Fe3N2 molecule. This tutorial is also an extension of the initial part of the series, which provides detailed insights into the classical workflow necessary for defining the system.\n", "\n", "To carry out these calculations, access to the Quantinuum Systems is essential, which can be obtained by submitting a [request form](https://www.quantinuum.com/contact/quantinuum-systems). Additionally, the user will require Hardware Quantum Credits (HQCs) to run jobs on Quantinuum Systems. Users with credentails and HQCs can access hardware and emulators through [qnexus](https://docs.quantinuum.com/nexus/trainings/notebooks/basics/getting_started.html).\n", "\n", "\n", "Here are the steps outlined:\n", "\n", "* Import the parameters characterizing the ground-state wavefunction.\n", "\n", "* Conduct calculations on the Quantinuum emulator utilizing the PMSV error mitigation method.\n", "\n", "* Execute calculations on the Quantinuum hardware using the PMSV error mitigation method." ] }, { "cell_type": "markdown", "id": "814ffcc8-65e2-4cc8-8714-290aac3c6431", "metadata": {}, "source": [ "To begin with, let us start by importing the qubit Hamiltonian, the fermionic state and space from the first part, along with the ground state parameters and the list of fermionic pool operators from the [second part](InQ_tut_fe4n2_2.ipynb) of this tutorial." ] }, { "cell_type": "code", "execution_count": null, "id": "c903f62b-6088-4747-ad06-ec1634f1b593", "metadata": {}, "outputs": [], "source": [ "import pickle\n", "\n", "with open('InQ_tut_fe4n2_qubit_hamiltonian.pickle', 'rb') as handle:\n", " qubit_hamiltonian = pickle.load(handle)\n", "\n", "with open('InQ_tut_fe4n2_state.pickle', 'rb') as handle:\n", " state = pickle.load(handle) \n", "\n", "with open('InQ_tut_fe4n2_space.pickle', 'rb') as handle:\n", " space = pickle.load(handle) \n", "\n", "with open('InQ_tut_fe4n2_gs_parameters.pickle', 'rb') as handle:\n", " gs_parameters = pickle.load(handle) \n", " \n", "with open('InQ_tut_fe4n2_exponents_with_symbols.pickle', 'rb') as handle:\n", " exponents_with_symbols = pickle.load(handle)\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')" ] }, { "cell_type": "markdown", "id": "96d66b6d-93ed-4fb5-b413-1ad51fa8a6f2", "metadata": {}, "source": [ "InQuanto employs an efficient ansatz circuit compilation approach, provided by the `FermionSpaceStateExpChemicallyAware` class. This method is designed to minimize the computational resources required.\n", "\n", "Parameters used:\n", "\n", "- `fermion_operator_exponents` – Contains exponents and symbols. Assuming input exponents are ordered as single exponents first, followed by double exponents.\n", "- `fermion_state` – Initial fermionic reference state." ] }, { "cell_type": "code", "execution_count": null, "id": "98608a33-1007-4a6f-a8ed-f9273b5be7e5", "metadata": {}, "outputs": [], "source": [ "from inquanto.ansatzes import FermionSpaceStateExpChemicallyAware\n", "\n", "ansatz=FermionSpaceStateExpChemicallyAware(fermion_operator_exponents=exponents_with_symbols, fermion_state=state)" ] }, { "cell_type": "markdown", "id": "e7dc5130-db75-40ad-bf5a-3bcab2ba21fe", "metadata": {}, "source": [ "The `state_circuit` attribute within InQuanto represents the symbolic state circuit, complete with a default compilation. In a Jupyter environment, one can visualize this symbolic state circuit by making use of the `render_circuit_jupyter` function provided by the pytket library." ] }, { "cell_type": "code", "execution_count": null, "id": "782eeefe-314d-45c9-a174-0164b9e21971", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pytket.circuit.display import render_circuit_jupyter\n", "\n", "render_circuit_jupyter(ansatz.state_circuit)" ] }, { "cell_type": "markdown", "id": "7f6a7b57-a941-4858-97c3-8ff1e8b8a750", "metadata": {}, "source": [ "To obtain an overview of the quantum resource costs associated with creating the Ansatz, one can utilize the `generate_report` and `circuit_resources` methods of the Ansatz object. The report typically includes information such as the count of Ansatz parameters, and the number of required qubits, while the resources method holds gate metrics such as 2-qubit gate counts. In this circuit there are 6 qubits, 7 parameters, and 59 2-qubit gates. These metrics provide an overview of the complexity and requirements of the quantum circuit. \n", "The circuit depth is the length of the longest path from the input (or from a preparation) to the output (or a measurement gate), moving forward in time along qubit wires.\n", "\n", "InQuanto offers the `generate_report()` and `circuit_resources()` methods for concise circuit analysis. However, for more in-depth diagnostics and analysis of the circuit, the user can examine the tket circuit object directly, which is usually accessed through `ansatz.state_circuit`. The [tket documentation](https://docs.quantinuum.com/tket/user-guide/examples/circuit_construction/circuit_analysis_example.html) provides comprehensive information and guidance on this topic." ] }, { "cell_type": "code", "execution_count": null, "id": "5b01d814-562a-412c-a0a1-544e07d34ec4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ANSATZ REPORT:\n", "{'n_parameters': 7, 'n_qubits': 6}\n", "\n", "\n", "2-qubit GATES: 59\n" ] } ], "source": [ "from pytket.circuit import OpType\n", "\n", "print('ANSATZ REPORT:')\n", "print(ansatz.generate_report())\n", "print(ansatz.get_circuit())\n", "print('\\n2-qubit GATES: {}'.format(ansatz.circuit_resources()['gates_2q']))" ] }, { "cell_type": "markdown", "id": "f4a45a45-e4db-4c1f-a72a-23325a662f01", "metadata": {}, "source": [ "Conducting emulator experiments prior to hardware experiments is a pivotal phase in the development and optimization of quantum algorithms and applications. Emulators offer a controlled setting with the possibility to refine algorithms, explore quantum error correction techniques, and gain valuable insights into the performance of quantum circuits, all without being restricted by the limitations of physical hardware.\n", " \n", "To instantiate a Quantinuum Systems emulator, use the `QuantinuumConfig` qnexus class. The `QuantinuumConfig` offers a range of emulators, such as H2-1E and H2-2E. These emulators are designed to emulate the specific devices and they run remotely on a server." ] }, { "cell_type": "code", "execution_count": null, "id": "8806527c-17ed-4ea9-b744-f0d57becee0e", "metadata": {}, "outputs": [], "source": [ "from qnexus.client import auth, projects, devices\n", "from qnexus import QuantinuumConfig\n", "\n", "# Login with your credentials\n", "# You only need to login once per session, then this can be commented out\n", "# auth.login()\n", "\n", "# qnexus requires the specification of a project for all submitted jobs\n", "project_ref = projects.get_or_create(name=\"InQuanto Documentation\", description=\"\", properties={})\n", "\n", "# Change the machine name if necessary.\n", "machine = \"H2-1E\"\n", "backend = QuantinuumConfig(device_name=machine)" ] }, { "cell_type": "markdown", "id": "54b15d3e-a4f9-4950-9b51-8ca2daee1c32", "metadata": {}, "source": [ "To reduce errors and inaccuracies caused by quantum noise and imperfections in the Quantinuum device, one can employ noise mitigation techniques. In this case, let us define the Qubit Operator symmetries within the system, which enables to utilize [PMSV](https://doi.org/10.1103/PhysRevResearch.4.033110) (Partition Measurement Symmetry Verification). PMSV is an efficient technique for symmetry-verified quantum calculations. It represents molecular symmetries using Pauli strings, including mirror planes (Z2) and electron-number conservation (U1). For systems with Abelian point group symmetry, qubit tapering methods can be applied. PMSV uses commutation between Pauli symmetries and Hamiltonian terms for symmetry verification. It groups them into sets of commuting Pauli strings. If each string in a set commutes with the symmetry operator, measurement circuits for that set can be verified for symmetry without additional quantum resources, discarding measurements violating system point group symmetries.\n", "\n", "Parameters used:\n", "\n", "`stabilizers` – List of state stabilzers as QubitOperators with only a single pauli strings in them.\n", "\n", "The InQuanto `symmetry_operators_z2_in_sector` function is employed to retrieve a list of symmetry operators applicable to the system under consideration. These symmetry operators are associated with the point group, spin parity, and particle number parity Z2 symmetries that uphold a specific symmetry sector. The users can find additional details in the linked [page](https://docs.quantinuum.com/inquanto/api/inquanto/spaces.html#inquanto.spaces.FermionSpace.symmetry_operators_z2_in_sector)." ] }, { "cell_type": "code", "execution_count": null, "id": "1323fbf1-0eb8-45dd-a212-2d98c0a1fc11", "metadata": {}, "outputs": [], "source": [ "from inquanto.protocols.averaging._mitigation import PMSV\n", "from inquanto.mappings import QubitMappingJordanWigner\n", "\n", "stabilizers = QubitMappingJordanWigner().operator_map(\n", " space.symmetry_operators_z2_in_sector(\n", " state\n", " )\n", ")\n", "\n", "mitms_pmsv = PMSV(stabilizers)" ] }, { "cell_type": "markdown", "id": "5c7c11f6-3901-43cc-9fa7-f1f2d1c4c888", "metadata": {}, "source": [ "Here, a technique known as \"batching\" is employed, wherein each experiment is iterated a certain number of times with a specific shot count as the target. For instance, if one aims for 10,000 shots, one conducts the experiment ten times, resulting in a total of 100,000 shots for that experiment. This limitation exists because each experiment can only accommodate a maximum of 10,000 shots and this implementation helps to avoid a single task from monopolizing the system's resources or a user accidentally using all their credits in a single instance.\n", "\n", "To compute the expectation value of a Hermitian operator through operator averaging on the system register, the `PauliAveraging` protocol is employed. This protocol effectively implements the procedure outlined in ['Hamiltonian Averaging'](https://arxiv.org/abs/1407.7863). To launch the circuits to the backend the `launch` function is used. This method processes all the circuits associated with the expectation value calculations and returns a list of `ResultHandle` objects representing the handles for the results. One can pickle these `ResultHandle` objects so that the results can be easily retrieved. The user can monitor the progress of the experiments on the [Quantinuum page](https://um.qapi.quantinuum.com/user) by using the same credentials used to execute the experiments." ] }, { "cell_type": "code", "execution_count": null, "id": "bc3f3e72-df8a-4313-b373-c507b9f0ecde", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/ciaran.ward/repos/inquanto-docs/.venv/lib/python3.12/site-packages/qnexus/client/utils.py:170: DeprecationWarning: The `circuits` argument is deprecated and will be removed in a future version. Please use `programs`.\n", " warnings.warn(\n" ] } ], "source": [ "from inquanto.protocols import PauliAveraging\n", "from pytket.partition import PauliPartitionStrat\n", "\n", "\n", "set_shots_10k = [10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000]\n", "repeats = 10\n", "\n", "#build and compile the circuits once\n", "protocol_template = PauliAveraging(\n", " backend,\n", " shots_per_circuit=10000,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", " project_ref=project_ref\n", ") \n", "protocol_template.build(\n", " gs_parameters, \n", " ansatz, \n", " qubit_hamiltonian, \n", " noise_mitigation=mitms_pmsv)\n", "\n", "protocol_template.compile_circuits()\n", "protocol_pickle=protocol_template.dumps()\n", "protocol_template.n_circuit\n", "\n", "# launch 10 repeats of these circuits \n", "for i in range(repeats):\n", " protocol= PauliAveraging.loads(protocol_pickle)\n", " handles = protocol.launch()\n", " with open( \"handles_\" + str(i) + \".pickle\", 'wb') as handle:\n", " pickle.dump(handles, handle, protocol=pickle.HIGHEST_PROTOCOL)" ] }, { "cell_type": "markdown", "id": "73972a27-a123-47f9-8290-c0d1ef96f8c6", "metadata": {}, "source": [ "After the experiments have finished, one can obtain the results by utilizing the `retrieve` function, which retrieves distributions from the backend for the specified source. The expectation value of a kernel for a specified quantum state is calculated by using the `evaluate_expectation_value` function. In addition, the `evaluate_expectation_uvalue` function can be used to calculate the expectation value of the Hermitian kernel while considering linear error propagation theory. The `std_dev` property returns the standard deviation which is used as the error associated with the calculation." ] }, { "cell_type": "code", "execution_count": null, "id": "c9dae4d6-258b-45ed-ac14-4748bc4ff79a", "metadata": {}, "outputs": [], "source": [ "repeats = 10\n", "emulator_energies_10k =[]\n", "emulator_10k = []\n", "\n", "for i in range(repeats):\n", " with open(\"handles_\" + str(i) + \".pickle\", 'rb') as handle:\n", " handles = pickle.load(handle)\n", " #only need 1 copy of protocol to eval sets of results\n", " protocol.retrieve(handles) \n", " energy_value = protocol.evaluate_expectation_value(ansatz, qubit_hamiltonian)\n", " emulator_energies_10k.append(energy_value)\n", " error = protocol.evaluate_expectation_uvalue(ansatz, qubit_hamiltonian)\n", " emulator_10k.append(error)\n", " " ] }, { "cell_type": "code", "execution_count": null, "id": "73596c5d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "uncertainties.core.AffineScalarFunc" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(emulator_10k[0])" ] }, { "cell_type": "code", "execution_count": null, "id": "8d907ca7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range (1,11))" ] }, { "cell_type": "code", "execution_count": null, "id": "8aa510c8", "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'list' object has no attribute 'float'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[35], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m emulator_10k \u001b[38;5;241m=\u001b[39m \u001b[43memulator_10k\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat\u001b[49m()\n\u001b[1;32m 3\u001b[0m emulator_10k_std\u001b[38;5;241m=\u001b[39m [] \n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m (\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m11\u001b[39m):\n", "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'float'" ] } ], "source": [ "emulator_10k = emulator_10k.float()\n", "\n", "emulator_10k_std= [] \n", "for i in range (1,11):\n", " print(emulator_10k[:i])\n", " # emulator_10k_std.append(np.std(emulator_10k[:i]))" ] }, { "cell_type": "markdown", "id": "3e141002-e45f-4c96-9dd3-15b0f20e65d2", "metadata": {}, "source": [ "Additionally, one can showcase circuit statistics after employing the `get_compiled_circuit` function to compile the sequence of circuits. In this case, both the circuit depth for each circuit measurement and the circuit depth associated with 2-qubit gates are visualized." ] }, { "cell_type": "code", "execution_count": null, "id": "ebc63a2b-8e54-47bc-9c96-b634f7a9a301", "metadata": {}, "outputs": [], "source": [ "for meas_circ in protocol.get_circuits():\n", " print(\"Circuit depth =\", meas_circ.depth())\n", " print(\"2qb gate depth =\", meas_circ.depth_by_type({OpType.ZZPhase}))" ] }, { "cell_type": "markdown", "id": "e93cf6e3-430e-421c-9a38-6d98994f3ff3", "metadata": {}, "source": [ "After completing the 10 repetitions, the mean value is computed. The mean value is used to determine the energy values for shot counts such as 20k, 30k, and so forth. Meanwhile, the standard deviation is used to calculate the error bars." ] }, { "cell_type": "code", "execution_count": null, "id": "20f6e0d3-6017-4130-884e-1d25e0b723b4", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "emulator_10k_mean = []\n", "emulator_10k_std= []\n", "for i in range (1,11):\n", " emulator_10k_mean.append(np.mean(emulator_energies_10k[:i]))\n", " emulator_10k_std.append(np.std(emulator_energies_10k[:i]))" ] }, { "cell_type": "markdown", "id": "c3f9a513-89c5-4c7a-aee5-02f5274a6c7e", "metadata": {}, "source": [ "This procedure can be reiterated for various sets of shots to analyze how the number of shots impacts the energy and error estimations." ] }, { "cell_type": "code", "execution_count": null, "id": "15b387eb-9afe-4030-9b60-f8ab3e207dc2", "metadata": {}, "outputs": [], "source": [ "#target:5k\n", "set_shots_5k = [5000, 10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000, 50000]\n", "\n", "emulator_5k_mean = [-598.5233976942287, -598.528748007567, -598.5254365672856, -598.5266267836435,-598.5252272612659, \n", " -598.5241590945266, -598.5255975795899, -598.525113940237,-598.5249076903503, -598.5239581110884]\n", "\n", "emulator_5k_std =[ 0,0.0016,0.0015,0.0014,0.0013,0.0012,0.0011, 0.0010,0.00095, 0.0009]\n", "\n", "\n", "\n", "#target:4k\n", "set_shots_4k = [4000, 8000, 12000, 16000, 20000, 24000, 28000, 32000, 36000, 40000]\n", "\n", "\n", "emulator_4k_mean = [-598.5261956279538, -598.5239748592571, -598.5250271719032, -598.5236355685819, -598.5232948710519, \n", " -598.5243534836842, -598.5244650328887, -598.5251092284366, -598.524141170795, -598.5235882519817]\n", "\n", "emulator_4k_std =[0,0.00163,0.00154,0.0015,0.0014,0.0013,0.0012,0.00115,0.0011, 0.0010]\n", " \n", "\n", "\n", "#target:2.5k\n", "set_shots_2_5k = [2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000, 22500, 25000]\n", "\n", "emulator_2_5k_mean = [-598.5386462829877, -598.528495041739, -598.5223780085176, -598.5221927569415, -598.5220793440851,\n", " -598.522950988168, -598.5245581694165, -598.5236303692766, -598.5243398619134, -598.5237327682132]\n", "\n", "emulator_2_5k_std =[0,0.0017,0.00165,0.0016,0.00155,0.0015,0.00145,0.0014,0.00135,0.0013]" ] }, { "cell_type": "markdown", "id": "51081333-e8b2-41a0-b956-1e6def9d3e48", "metadata": {}, "source": [ "Once collected all the results, one can proceed to visualize and analyze the data. By running the same set of instructions for different shot configurations, one can observe that the error bars notably decrease when a sufficiently large number of samples is used." ] }, { "cell_type": "code", "execution_count": null, "id": "e434ac54-9fec-4aa4-9fb2-2d9614b7e684", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "sns.set_style(\"whitegrid\")\n", "\n", "#plt.plot(set_shots_10k, emulator_10k_mean, label='emulator_10k',color='red')\n", "plt.plot(set_shots_5k, emulator_5k_mean, label='emulator_5k',color='black')\n", "plt.plot(set_shots_4k, emulator_4k_mean, label='emulator_4k',color='teal')\n", "plt.plot(set_shots_2_5k, emulator_2_5k_mean, label='emulator_2.5k',color='orange')\n", "\n", "plt.rcParams[\"figure.figsize\"] = (10,6)\n", "plt.xticks(fontsize=15 )\n", "plt.yticks(fontsize=15 )\n", "\n", "#y_error_10k = emulator_10k_std\n", "y_error_5k = emulator_5k_std\n", "y_error_4k = emulator_4k_std\n", "y_error_2_5k = emulator_2_5k_std\n", "\n", "#plt.errorbar(set_shots_10k,emulator_10k_mean,\n", "# yerr = y_error_10k, fmt ='s', color='red',\n", "# elinewidth=1,capsize=2)\n", "\n", "plt.errorbar(set_shots_5k, emulator_5k_mean,\n", " yerr = y_error_5k, fmt ='s', color='black',\n", " elinewidth=1,capsize=2)\n", "\n", "plt.errorbar(set_shots_4k, emulator_4k_mean,\n", " yerr = y_error_4k, fmt ='s', color='teal',\n", " elinewidth=1,capsize=2)\n", "\n", "plt.errorbar(set_shots_2_5k, emulator_2_5k_mean,\n", " yerr = y_error_2_5k, fmt ='s', color='orange',\n", " elinewidth=1,capsize=2)\n", "\n", "plt.xlabel('Number of shots',fontsize=15)\n", "plt.ylabel('$\\Delta E \\; [Ha]$',fontsize=15)\n", "plt.title(\"Convergence behavior of the expectation value by varying the number of shots when running computations with the Quantinuum H1-1E noisy emulator backend.\")\n", "plt.legend(fontsize=15)" ] }, { "cell_type": "markdown", "id": "92dbea74-9a12-49b1-8231-395bfa411c84", "metadata": {}, "source": [ "With InQuanto, it is extremely easy to go from hardware emulation to hardware experiment. This is because `qnexus` requires the same details for emulating the hardware as for sending the experiment to the physical quantum circuit, the only difference being the substitution of the name of the quantum device. For example, from 'H2-1E' to 'H2-1'. \n", "\n", "Here, only one series of experiments was performed on the hardware device. To limit the effects of noise in estimating expectation values, the PMSV method was used.\n", "\n", "In this tutorial, three hardware experiments for three different structures of Fe4N2 cluster were performed in order to calculate the activation and dissociation energies of nitrogen on iron cluster.\n", "More specifically, in this tutorial, the emulator calculations with 4000 shots were used. In addition, a hardware experiment was conducted simply by changing 'H2-1E' to 'H2-1', and these results served as the starting points in the figure below.\n", "Subsequently, one can re-run the calculations described in this tutorial, altering only the initial geometry in the first part. Namely, one can use the geometry where the N-N bond is stretched, representing the transition state and denoted as 'ts' in the figure. Finally, one can repeat the three tutorials once again, using a geometry where the N-N bond breaks, denoted as the 'end' in the figure. Notice that in these six experiments (two for each geometry), the single experiments with both the emulator and hardware were used instead of the batching method described above.\n", "The primary goal of this tutorial is to offer a deeper understanding of how quantum computers can contribute to the comprehension of dissociation processes.\n", "\n", "The electronic activation energy with respect to the kinetic constant of the process is calculated as $E_{Fe/N_2}^{tot}-E_{Fe/N_2^*}^{tot}$, while the activation energy is $E_{Fe/N_2}^{tot}-E_{Fe/2N}^{tot}$.\n", " \n", "The data points computed on the hardware are in excellent agreement with the emulation results." ] }, { "cell_type": "code", "execution_count": null, "id": "e583f8eb-3ee0-49f2-b526-9e17fe80e4d2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# these are example solved energies from hardware and emulator\n", "\n", "sns.set_style(\"whitegrid\")\n", "\n", "steps=[1,2,3]\n", "emulator=[0,0.04681999999991149,-0.021029999999996107 ]\n", "hardware=[0,0.06232999999997446,-0.018699999999967076]\n", "\n", "\n", "plt.hlines(y=0, xmin=0, xmax=12, ls='--', colors='black')\n", "\n", "plt.scatter(x=steps, y=hardware, s=200, c=\"black\", label=\"Hardware\") \n", "plt.plot(steps, hardware, c=\"black\")\n", "\n", "y_error_hard = [0.00196006200237305,0.00171393177265877,0.000768517902650537]\n", "plt.errorbar(steps, hardware,\n", " yerr = y_error_hard, fmt ='o', color='black',\n", " elinewidth=10,capsize=10)\n", "\n", "\n", "plt.scatter(x=steps, y=emulator, s=200, c=\"blue\", label=\"Emulator\") \n", "plt.plot(steps, emulator, c=\"blue\")\n", "\n", "y_error_em = [0.00222116960181585,0.000835916404261285,0.000489635318758811]\n", "\n", "plt.errorbar(steps, emulator,\n", " yerr = y_error_em, fmt ='o', color='blue',\n", " elinewidth=10,capsize=10)\n", "\n", "\n", "plt.ylabel('$Energy\\; [Ha]$', fontsize=15)\n", "plt.xlabel('$NEB \\; Images\\;$', fontsize=15)\n", "plt.xticks(fontsize=15 )\n", "plt.yticks(fontsize=15 )\n", "plt.xlim([0.5, 3.5])\n", "plt.ylim([-0.04, 0.08])\n", "x=[1,2,3]\n", "my_xticks = ['start','ts','end']\n", "plt.xticks(x, my_xticks)\n", "plt.legend(fontsize=15, loc='lower left')\n", "plt.title(\"Comparison of the activation and the dissociation energies by using ADAPT-VQE with Quantinuum H2-1 device and Quantinuum H2-1E noisy emulator backend.\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "20a92832", "metadata": {}, "outputs": [], "source": [] } ], "metadata": {}, "nbformat": 4, "nbformat_minor": 5 }