{ "cells": [ { "cell_type": "markdown", "id": "083f9cb1-82a6-4147-8594-b32ff4dc9666", "metadata": {}, "source": [ "Running on Quantinuum Backends \n", "===============================" ] }, { "attachments": {}, "cell_type": "markdown", "id": "60c1176b-3c18-414b-a031-420dd2526699", "metadata": {}, "source": [ "In this tutorial, we demonstrate how to perform a simple quantum chemical calculation on Quantinuum hardware.\n", "\n", "Since this tutorial focuses on practical quantum computation, we will perform a simple calculation: the single point (i.e. not optimized/not variationally solved) total energy evaluation of the H2 molecule in the Unitary Coupled Cluster (UCC) ansatz for a set value of the ansatz variational parameter.\n", "\n", "This tutorial will require that you have credentials for Quantinuum Systems, which can be obtained by contacting Quantinuum support. You will require credits (HQCs) to run on emulators and hardware. Users can access Quantinuum backends through [pytket-quantinuum](https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/) or via [Quantinuum Nexus](https://docs.quantinuum.com/nexus/trainings/notebooks/basics/getting_started.html)\n", "\n", "The steps below are such:\n", "\n", "- Define the system\n", "- Perform computation with emulated hardware noise (QuantinuumBackend emulator + machine noise profile)\n", "- Demonstrate error mitigation methods on emulated hardware (PMSV)" ] }, { "cell_type": "markdown", "id": "814ffcc8-65e2-4cc8-8714-290aac3c6431", "metadata": {}, "source": [ "### 1. Define the system " ] }, { "cell_type": "code", "execution_count": null, "id": "7e89ef34-63f2-4877-a477-8722c3a9fc8e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{d0: 0.4996755931358105}\n", "\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "2-qubit GATES: 4\n", "\n" ] } ], "source": [ "# Preload the Hamiltonian for H2\n", "# see the Aer tutorial for details\n", "from inquanto.express import load_h5\n", "\n", "h2 = load_h5(\"h2_sto3g.h5\", as_tuple=True)\n", "hamiltonian = h2.hamiltonian_operator\n", "\n", "from inquanto.spaces import FermionSpace\n", "from inquanto.states import FermionState\n", "from inquanto.symmetry import PointGroup\n", "from inquanto.ansatzes import FermionSpaceStateExpChemicallyAware\n", "\n", "# Define fermion space, state, and map the fermionic operator to qubits\n", "space = FermionSpace(\n", " 4, point_group=PointGroup(\"D2h\"), orb_irreps=[\"Ag\", \"Ag\", \"B1u\", \"B1u\"]\n", ")\n", "\n", "state = FermionState([1, 1, 0, 0])\n", "qubit_hamiltonian = hamiltonian.qubit_encode()\n", "\n", "exponents = space.construct_single_ucc_operators(state)\n", "## the above adds nothing due to the symmetry of the system\n", "exponents += space.construct_double_ucc_operators(state)\n", "# Construct an efficient ansatz\n", "ansatz = FermionSpaceStateExpChemicallyAware(exponents, state)\n", "\n", "p = ansatz.state_symbols.construct_from_array([0.4996755931358105])\n", "print(p)\n", "\n", "# Import an InQuanto Computable for measuring an expecation value. \n", "# The operator is the qubit Hamiltonian, and the wavefunction is the ansatz.\n", "from inquanto.computables import ExpectationValue\n", "\n", "print(hamiltonian)\n", "expectation0 = ExpectationValue(ansatz, hamiltonian.qubit_encode())\n", "\n", "# Analyze the ansatz circuit\n", "from pytket.circuit.display import render_circuit_jupyter\n", "from pytket import Circuit, OpType\n", "\n", "render_circuit_jupyter(ansatz.get_circuit(p)) # this is the uncompiled ansatz circuit\n", "\n", "print(\"2-qubit GATES: {}\".format(ansatz.circuit_resources()['gates_2q']))\n", "print(ansatz.state_circuit)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "145ad269-7da6-4645-af96-613a8170f98e", "metadata": {}, "source": [ "### 2. Machine emulation for quantum noise \n", "\n", "Running emulator experiments before hardware experiments is a crucial step in the development and optimization of quantum algorithms and applications. Emulators provide a controlled environment where one can fine-tune algorithms, explore error mitigation strategies, and gain valuable insights about the behavior of quantum circuits without some constraints of physical hardware.\n", "\n", "Below, we provide instructions for conducting experiments utilizing a Quantinuum emulator. To utilize hardware instead of the emulator one only needs to change their choice of device when instantiating the `QuantinuumBackend`. \n", "\n", " Note that we use the `pytket-quantinuum` extension to access a Quantinuum backend.\n", "\n", "`QuantinuumBackend` is a pytket backend that calls a Quantinuum device (\"H1-1\", \"H1-2\") or its emulator with the corresponding noise profile (\"H1-1E\", \"H2-1E\"). The emulators are run remotely on a server. Accessing the backend retrieves information from your Quantinuum account. More information can be found on the [pytket-quantinuum page.](https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/)\n", "\n", "For comparison in the figure below, we have also plotted the exact energy (-0.5876463677224993 Ha) for H$_2$ and the user should also compare these results to result from the first part of this tutorial." ] }, { "cell_type": "code", "execution_count": null, "id": "b059c2ee", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H1-1E status: online\n" ] } ], "source": [ "from pytket.extensions.quantinuum import QuantinuumBackend\n", "\n", "# Initialize the backend, make sure to login with your credentials. \n", "# Change the machine name and add the label and the group if necessary.\n", "machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "\n", "# The QuantinuumBackend has additional arguements for accessing resources and labelling circuits\n", "# label (Optional[str], optional) – Job labels used if Circuits have no name, defaults to “job”\n", "# group (Optional[str], optional) – string identifier of a collection of jobs, can be used for usage tracking.\n", "\n", "# Running the next line (device_state) will require logging into your \n", "# quantinuum account. This can also be called with backend.login()\n", "print(machine, \"status:\", QuantinuumBackend.device_state(device_name=machine))" ] }, { "cell_type": "code", "execution_count": null, "id": "11b53c55-e4ab-4198-bde2-b217f54c5505", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from inquanto.protocols import PauliAveraging\n", "from pytket.partition import PauliPartitionStrat\n", "\n", "# here we demonstrate building the \n", "protocol = PauliAveraging(\n", " backend,\n", " shots_per_circuit=10,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", ")\n", "protocol.build(p, ansatz, hamiltonian.qubit_encode())\n", "protocol.compile_circuits()\n", "\n", "# you can inspect compiled measurement circuits contained in the protocol that was run on the backend\n", "# note that the gateset of this circuit is different to the ansatz \n", "\n", "render_circuit_jupyter(protocol.get_circuits()[1])\n" ] }, { "cell_type": "code", "execution_count": null, "id": "f7391ae0", "metadata": {}, "outputs": [], "source": [ "# now we loop over different numbers of shots to examine convergence \n", "# the protocols are built, run, and the expectation values collected\n", "set_shots = [10, 50, 100, 500, 1000, 5000, 10000]\n", "noisy_H1_1E_energies = []\n", "\n", "for i in set_shots:\n", " protocol = PauliAveraging(\n", " backend,\n", " shots_per_circuit=i,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", " )\n", " protocol.build(p, ansatz, hamiltonian.qubit_encode())\n", " protocol.compile_circuits()\n", " protocol.run() # no seeding H series, returns results to the protocol\n", " noisy_H1_1E_expectation = protocol.evaluate_expectation_value(\n", " ansatz, hamiltonian.qubit_encode()\n", " )\n", " noisy_H1_1E_energies.append(noisy_H1_1E_expectation)" ] }, { "cell_type": "markdown", "id": "2b624552", "metadata": {}, "source": [ "The Quantinuum Portal can be used to inspect your submitted job progress and other details as illustrated below. \n", "\n", "| Status | JobID | Name | MACHINE | Group | Submit Date | Start Date | Result Date | Shots | | Cost |\n", "|-----------|----------------------------------|-----------------|---------|-----------|------------------|------------------|------------------|-------|------|------|\n", "| queued | 3049eb4cf05746ffb271c8bf11cd6e91 | GQ4WEZBUGM3DI,1 | H1-1E | UserGroup | 29/11/2023 11:42 | | | 10000 | | 251 |\n", "| queued | 474e5da741a34c5b9ad0b577db0141a0 | GQ4WEZBUGM3DI,0 | H1-1E | UserGroup | 29/11/2023 11:42 | | | 10000 | | 185 |\n", "| completed | 7dd6b36ea21a43c8bb8dd5067244a11f | GQ4WEZBUGM3DI,1 | H1-1E | UserGroup | 29/11/2023 11:40 | 29/11/2023 11:42 | 29/11/2023 11:42 | 5000 | 5000 | 128 |\n", "| completed | df15c1a8e2f442a694463c59538d466f | GQ4WEZBUGM3DI,0 | H1-1E | UserGroup | 29/11/2023 11:40 | 29/11/2023 11:42 | 29/11/2023 11:42 | 5000 | 5000 | 95 |\n" ] }, { "cell_type": "code", "execution_count": null, "id": "2794313a", "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", "# we plot the results of our sampling\n", "plt.rcParams[\"figure.figsize\"] = (12, 4)\n", "\n", "plt.hlines(\n", " y=-0.5876463677224993,\n", " xmin=10,\n", " xmax=50000,\n", " ls=\"--\",\n", " colors=\"black\",\n", " label=\"Exact Energy\",\n", ")\n", "plt.plot(set_shots, noisy_H1_1E_energies, label=\"H1-1E\")\n", "plt.xscale(\"log\")\n", "plt.ylim([-0.8, 0])\n", "plt.xlabel(\"Number of shots\")\n", "plt.ylabel(\"Energy (Ha)\")\n", "plt.title(\n", " \"Convergence behavior of the expectation value for \"\n", " + r\"$\\theta=$%.5f\" % list(p.values())[0]\n", ")\n", "plt.legend()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f12c4ba2-cb30-4c82-8c1e-74517dc544c5", "metadata": {}, "source": [ "### 3. Noise mitigation methods in Quantinuum emulation\n", "\n", "We can use noise mitigation techniques to reduce the impact of noise in our expectation value. In this case we will 'purify' results by discarding a shot if it has a certain error. There are many other mitigation methods. \n", "\n", "Specifically, we will define the symmetries of the Qubit Operators in the system to use PMSV (Partition Measurement Symmetry Verification). As a result, noise mitigation improves the accuracy of the energy obtained from the quantum hardware compared to the unmitigated results and the exact energy of H2.\n", "\n", "State Preparation and Measurement (SPAM) correction, which calibrates the calculation for system noise, can also be used." ] }, { "cell_type": "code", "execution_count": null, "id": "afc57872-f90e-477a-864a-1532602f2f55", "metadata": {}, "outputs": [], "source": [ "from inquanto.protocols.averaging._mitigation import PMSV\n", "from inquanto.mappings import QubitMappingJordanWigner\n", "\n", "backend = QuantinuumBackend(device_name=\"\", label=\"\", group=\"\")\n", "\n", "stabilizers = QubitMappingJordanWigner().operator_map(\n", " space.symmetry_operators_z2_in_sector(state)\n", ")\n", "\n", "mitms_pmsv = PMSV(stabilizers)\n", "\n", "miti_H1_1E_energies = []\n", "for i in set_shots:\n", " protocol = PauliAveraging(\n", " backend,\n", " shots_per_circuit=i,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", " )\n", " protocol.build(\n", " p, ansatz, hamiltonian.qubit_encode(), noise_mitigation=mitms_pmsv\n", " ).compile_circuits().run()\n", "\n", " miti_H1_1E_expectation = protocol.evaluate_expectation_value(\n", " ansatz, hamiltonian.qubit_encode()\n", " )\n", " miti_H1_1E_energies.append(miti_H1_1E_expectation)" ] }, { "cell_type": "code", "execution_count": null, "id": "8ff54e2e", "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": [ "#statevector \n", "plt.hlines(\n", " y=-0.5876463677224993,\n", " xmin=10,\n", " xmax=50000,\n", " ls=\"--\",\n", " colors=\"black\",\n", " label=\"Exact Energy\",\n", ")\n", "plt.plot(set_shots, noisy_H1_1E_energies, label=\"H1-1E\")\n", "plt.plot(set_shots, miti_H1_1E_energies, label=\"H1-1E mitigated\")\n", "plt.xscale(\"log\")\n", "plt.ylim([-0.8, 0])\n", "plt.xlabel(\"Number of shots\")\n", "plt.ylabel(\"Energy (Ha)\")\n", "plt.title(\n", " \"Convergence behavior of the expectation value for \"\n", " + r\"$\\theta=$%.5f\" % list(p.values())[0]\n", ")\n", "plt.legend()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c132e5c7-acf8-4a77-9ffd-1a247c256249", "metadata": {}, "source": [ "One may also explore the impact of SPAM on enhancing the convergence behavior of the expectation value. In the case of this simple system with a shallow circuit, the energy converges with slightly improved efficiency and/or heightened precision upon employing noise mitigation techniques.\n", "\n", "Transitioning to hardware experiments is straightforward. This is facilitated by the `pytket.extensions.quantinuum` module. The user simply changes the device name (e.g., from \"H1-1E\" to \"H1-1\"), and the circuit will be run on the physical quantum device provided sufficient credits and circuit syntax. " ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }