From cecb7647fa9a55fec944e0d0068942060c091fbf Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Wed, 23 Mar 2022 23:50:45 -0400 Subject: [PATCH 01/14] Add files via upload --- docs/tutorials/estimator_vqe.ipynb | 273 +++++++++++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 docs/tutorials/estimator_vqe.ipynb diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb new file mode 100644 index 000000000..c42628885 --- /dev/null +++ b/docs/tutorials/estimator_vqe.ipynb @@ -0,0 +1,273 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6aa68656", + "metadata": {}, + "source": [ + "# Variational Quantum Eigensolver with Estimator Primitive" + ] + }, + { + "cell_type": "markdown", + "id": "15a4588c", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "The Variational Quantum Eigensolver (VQE) is an optimization routine for finding the ground state energy (i.e. lowest eigenvalue) of a Hamiltonain and is a considered to be a viable candidate for NISQ hardware. In this tutorial, we will go over how to use IBM Quantum Runtime to submit your VQE's to the cloud. Specifically, we will be looking at calculating the Potential Energy Surface (PES) of the $H_2$ molecule using the estimator primitive. " + ] + }, + { + "cell_type": "markdown", + "id": "c5cb8630", + "metadata": {}, + "source": [ + "### Create Service\n", + "First we have to create our service instance and instantiate our estimator factory. In this example we will be working with a simulator for the sake of speed, but by simply changing this one line (for choice of backend) this could run on hardware as well. " + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "9c482297", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import IBMRuntimeService, IBMEstimator\n", + "\n", + "service = IBMRuntimeService()\n", + "estimator_factory = IBMEstimator(service=service, backend=\"ibmq_qasm_simulator\")" + ] + }, + { + "cell_type": "markdown", + "id": "bd67da7b", + "metadata": {}, + "source": [ + "### Molecular Hamiltonians\n", + "\n", + "Now we need to generate the Hamiltonians that we wish to find the ground state energy of. For this task we will be utilizing qiskit nature. First we have to specify how we are converting the fermionic operators of the electronic molecular hamiltonian to qubit operators. Here we will use the Parity Mapper, which maps annihilation to Pauli operators via $ \\hat{a} \\rightarrow \\frac{1}{2} \\left ( X_p Z_{p-1} + i Y_p \\right ) X_{p+1} ... X_{N} $" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "199981d2", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_nature.converters.second_quantization import QubitConverter\n", + "from qiskit_nature.mappers.second_quantization import ParityMapper\n", + "\n", + "qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd185bc", + "metadata": {}, + "source": [ + "For PES we generate the molecular hamiltonians at different bond lengths. At each bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "ce0f0955", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_nature.drivers import Molecule\n", + "from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver\n", + "from qiskit_nature.problems.second_quantization import ElectronicStructureProblem\n", + "from qiskit.algorithms import NumPyMinimumEigensolver\n", + "from qiskit.algorithms import MinimumEigensolverResult\n", + "from qiskit.opflow import TaperedPauliSumOp\n", + "\n", + "total_dist = 4\n", + "dist = 0.1\n", + "incr_early = 0.1\n", + "incr_late = 0.3\n", + "\n", + "real_energies = []\n", + "dists = []\n", + "ops = []\n", + "problems = []\n", + "while dist < total_dist:\n", + " molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])\n", + " driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \\\n", + " driver_type=ElectronicStructureDriverType.PYSCF)\n", + "\n", + " es_problem = ElectronicStructureProblem(driver)\n", + " second_q_ops = es_problem.second_q_ops() \n", + " hamiltonian = qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles)\n", + " sol = MinimumEigensolverResult()\n", + " sol.eigenvalue = numpy_solver.compute_minimum_eigenvalue(hamiltonian).eigenvalue\n", + " real_solution = es_problem.interpret(sol).total_energies[0]\n", + "\n", + " h = hamiltonian.primitive\n", + " h.coeffs = np.real(hamiltonian.coeffs)\n", + " real_energies.append(real_solution)\n", + " ops.append(TaperedPauliSumOp(h, hamiltonian.z2_symmetries))\n", + " dists.append(dist)\n", + " problems.append(es_problem)\n", + " \n", + " if dist > total_dist / 2:\n", + " dist += incr_late\n", + " else:\n", + " dist += incr_early" + ] + }, + { + "cell_type": "markdown", + "id": "2baf3383", + "metadata": {}, + "source": [ + "Now we can use these hamiltonians as the observable list in our estimator factory (thus avoiding the need to create many estimator instances). The VQE routine is formalized as $\\min_\\theta \\langle \\Psi | \\hat{H} | \\Psi \\rangle $, so we just need to minimize the expectation values of the hamiltonians. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8151031", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA\n", + "from qiskit.circuit.library import RealAmplitudes\n", + "import numpy as np\n", + "\n", + "circuit = RealAmplitudes(num_qubits=2, reps=2).decompose()\n", + "vqe_energies = []\n", + "\n", + "with estimator_factory(\n", + " circuits=[circuit],\n", + " observables=ops,\n", + ") as estimator:\n", + " for i in range(len(ops)):\n", + "\n", + " def evaluate_expectation(x):\n", + " x = list(x)\n", + " results = estimator(circuit_indices=[0], observable_indices=[i], parameter_values=[x]).values[0]\n", + " return np.real(results)\n", + "\n", + "\n", + " initial_point = np.random.uniform(-np.pi, np.pi, 6)\n", + " spsa = SPSA(100)\n", + " _, vqe_solution, _ = spsa.optimize(initial_point.size, evaluate_expectation, initial_point=initial_point) \n", + " \n", + " sol = MinimumEigensolverResult()\n", + " sol.eigenvalue = vqe_solution\n", + " vqe_sol = es_problem.interpret(sol).total_energies[0]\n", + " vqe_energies.append(vqe_sol)\n" + ] + }, + { + "cell_type": "markdown", + "id": "adc603cd", + "metadata": {}, + "source": [ + "Now that we solved the electronic hamiltonians, we have to add the nuclear energies." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "fc1023e8", + "metadata": {}, + "outputs": [], + "source": [ + "vqe_interpret = []\n", + "for i in range(len(vqe_energies)):\n", + " sol = MinimumEigensolverResult()\n", + " sol.eigenvalue = vqe_energies[i]\n", + " sol = problems[i].interpret(sol).total_energies[0]\n", + " vqe_interpret.append(sol)" + ] + }, + { + "cell_type": "markdown", + "id": "804075d3", + "metadata": {}, + "source": [ + "Finally, we can see our PES curve!" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "f0ddfd36", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(dists, real_energies, label='Real', color='red')\n", + "plt.scatter(dists, vqe_interpret, label='VQE', color='black')\n", + "plt.title(\"H2\")\n", + "plt.xlim(0, 4)\n", + "plt.xlabel('Angstroms')\n", + "plt.ylabel('Hartree')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "9b99ee51", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'qiskit-terra': '0.19.2', 'qiskit-aer': '0.10.3', 'qiskit-ignis': '0.7.0', 'qiskit-ibmq-provider': '0.18.3', 'qiskit-aqua': '0.9.5', 'qiskit': '0.34.2', 'qiskit-nature': '0.3.1', 'qiskit-finance': None, 'qiskit-optimization': '0.3.1', 'qiskit-machine-learning': '0.2.1'}" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import qiskit\n", + "qiskit.__qiskit_version__" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 59e701c3809ebe49930f3478a314554df63100e1 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 24 Mar 2022 09:59:43 -0400 Subject: [PATCH 02/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index c42628885..b30b72fd3 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -42,7 +42,7 @@ }, { "cell_type": "markdown", - "id": "bd67da7b", + "id": "5744d456", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -53,7 +53,7 @@ { "cell_type": "code", "execution_count": null, - "id": "199981d2", + "id": "ba0f09e8", "metadata": {}, "outputs": [], "source": [ @@ -65,7 +65,7 @@ }, { "cell_type": "markdown", - "id": "5cd185bc", + "id": "bf3b4be6", "metadata": {}, "source": [ "For PES we generate the molecular hamiltonians at different bond lengths. At each bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " @@ -84,6 +84,7 @@ "from qiskit.algorithms import NumPyMinimumEigensolver\n", "from qiskit.algorithms import MinimumEigensolverResult\n", "from qiskit.opflow import TaperedPauliSumOp\n", + "import numpy as np\n", "\n", "total_dist = 4\n", "dist = 0.1\n", @@ -103,7 +104,7 @@ " second_q_ops = es_problem.second_q_ops() \n", " hamiltonian = qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles)\n", " sol = MinimumEigensolverResult()\n", - " sol.eigenvalue = numpy_solver.compute_minimum_eigenvalue(hamiltonian).eigenvalue\n", + " sol.eigenvalue = NumPyMinimumEigensolver().compute_minimum_eigenvalue(hamiltonian).eigenvalue\n", " real_solution = es_problem.interpret(sol).total_energies[0]\n", "\n", " h = hamiltonian.primitive\n", @@ -136,7 +137,6 @@ "source": [ "from qiskit.algorithms.optimizers import SPSA\n", "from qiskit.circuit.library import RealAmplitudes\n", - "import numpy as np\n", "\n", "circuit = RealAmplitudes(num_qubits=2, reps=2).decompose()\n", "vqe_energies = []\n", @@ -188,7 +188,7 @@ }, { "cell_type": "markdown", - "id": "804075d3", + "id": "6c289933", "metadata": {}, "source": [ "Finally, we can see our PES curve!" From 89341040417d2f385e0e656f628dd588137614bc Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 24 Mar 2022 16:11:01 -0400 Subject: [PATCH 03/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 68 +++++++++++++++++++++++------- 1 file changed, 52 insertions(+), 16 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index b30b72fd3..0de847458 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -29,20 +29,23 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 11, "id": "9c482297", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import IBMRuntimeService, IBMEstimator\n", "\n", - "service = IBMRuntimeService()\n", + "#service = IBMRuntimeService()\n", + "service = IBMRuntimeService(auth=\"legacy\", token=\"a80ad6b1be1ad6e51fc0fa46a9635ba9361c9b9eae5f74c7390a8c496076037052737658289c42e706a48e10c4619d98b02e27ceaaf6f4f3fc28a1a72b9cf7bd\")\n", + "\n", + "\n", "estimator_factory = IBMEstimator(service=service, backend=\"ibmq_qasm_simulator\")" ] }, { "cell_type": "markdown", - "id": "5744d456", + "id": "48037a94", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -52,8 +55,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "ba0f09e8", + "execution_count": 12, + "id": "021c3fb2", "metadata": {}, "outputs": [], "source": [ @@ -65,7 +68,7 @@ }, { "cell_type": "markdown", - "id": "bf3b4be6", + "id": "300737ed", "metadata": {}, "source": [ "For PES we generate the molecular hamiltonians at different bond lengths. At each bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " @@ -73,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 13, "id": "ce0f0955", "metadata": {}, "outputs": [], @@ -130,12 +133,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "a8151031", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 / 26\n", + "1 / 26\n", + "2 / 26\n", + "3 / 26\n", + "4 / 26\n", + "5 / 26\n", + "6 / 26\n", + "7 / 26\n", + "8 / 26\n", + "9 / 26\n", + "10 / 26\n", + "11 / 26\n", + "12 / 26\n", + "13 / 26\n", + "14 / 26\n", + "15 / 26\n", + "16 / 26\n", + "17 / 26\n", + "18 / 26\n", + "19 / 26\n", + "20 / 26\n", + "21 / 26\n", + "22 / 26\n", + "23 / 26\n", + "24 / 26\n", + "25 / 26\n" + ] + } + ], "source": [ - "from qiskit.algorithms.optimizers import SPSA\n", + "from qiskit.algorithms.optimizers import SPSA, COBYLA\n", "from qiskit.circuit.library import RealAmplitudes\n", "\n", "circuit = RealAmplitudes(num_qubits=2, reps=2).decompose()\n", @@ -146,7 +182,7 @@ " observables=ops,\n", ") as estimator:\n", " for i in range(len(ops)):\n", - "\n", + " print(i, \"/\", len(ops))\n", " def evaluate_expectation(x):\n", " x = list(x)\n", " results = estimator(circuit_indices=[0], observable_indices=[i], parameter_values=[x]).values[0]\n", @@ -154,7 +190,7 @@ "\n", "\n", " initial_point = np.random.uniform(-np.pi, np.pi, 6)\n", - " spsa = SPSA(100)\n", + " spsa = COBYLA(10)\n", " _, vqe_solution, _ = spsa.optimize(initial_point.size, evaluate_expectation, initial_point=initial_point) \n", " \n", " sol = MinimumEigensolverResult()\n", @@ -173,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 17, "id": "fc1023e8", "metadata": {}, "outputs": [], @@ -188,7 +224,7 @@ }, { "cell_type": "markdown", - "id": "6c289933", + "id": "e93d7ba9", "metadata": {}, "source": [ "Finally, we can see our PES curve!" @@ -196,13 +232,13 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 18, "id": "f0ddfd36", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 496b3918b90be15e0736f1f53885a871494aa6ba Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 24 Mar 2022 16:12:33 -0400 Subject: [PATCH 04/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index 0de847458..c75bfa6ab 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -36,16 +36,14 @@ "source": [ "from qiskit_ibm_runtime import IBMRuntimeService, IBMEstimator\n", "\n", - "#service = IBMRuntimeService()\n", - "service = IBMRuntimeService(auth=\"legacy\", token=\"a80ad6b1be1ad6e51fc0fa46a9635ba9361c9b9eae5f74c7390a8c496076037052737658289c42e706a48e10c4619d98b02e27ceaaf6f4f3fc28a1a72b9cf7bd\")\n", - "\n", + "service = IBMRuntimeService()\n", "\n", "estimator_factory = IBMEstimator(service=service, backend=\"ibmq_qasm_simulator\")" ] }, { "cell_type": "markdown", - "id": "48037a94", + "id": "d722d9ac", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -56,7 +54,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "021c3fb2", + "id": "015e5945", "metadata": {}, "outputs": [], "source": [ @@ -68,7 +66,7 @@ }, { "cell_type": "markdown", - "id": "300737ed", + "id": "a251b0b2", "metadata": {}, "source": [ "For PES we generate the molecular hamiltonians at different bond lengths. At each bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " @@ -224,7 +222,7 @@ }, { "cell_type": "markdown", - "id": "e93d7ba9", + "id": "09e5f016", "metadata": {}, "source": [ "Finally, we can see our PES curve!" From 276acc7ca8c112e15b3c3ffeffa485b972f85ac1 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 31 Mar 2022 14:05:04 -0400 Subject: [PATCH 05/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 170 +++++++++++++---------------- 1 file changed, 75 insertions(+), 95 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index c75bfa6ab..fb15f01bf 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "9c482297", "metadata": {}, "outputs": [], @@ -43,17 +43,37 @@ }, { "cell_type": "markdown", - "id": "d722d9ac", + "id": "8a6c471b", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", + "\n", + "We will be working with Qiskit Nature to generate and handle molecular hamiltonians. First though, we need to install these packages. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23c27160", + "metadata": {}, + "outputs": [], + "source": [ + "pip install qiskit-nature\n", + "pip install 'qiskit-nature[pyscf]'" + ] + }, + { + "cell_type": "markdown", + "id": "d722d9ac", + "metadata": {}, + "source": [ "\n", "Now we need to generate the Hamiltonians that we wish to find the ground state energy of. For this task we will be utilizing qiskit nature. First we have to specify how we are converting the fermionic operators of the electronic molecular hamiltonian to qubit operators. Here we will use the Parity Mapper, which maps annihilation to Pauli operators via $ \\hat{a} \\rightarrow \\frac{1}{2} \\left ( X_p Z_{p-1} + i Y_p \\right ) X_{p+1} ... X_{N} $" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "id": "015e5945", "metadata": {}, "outputs": [], @@ -74,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "ce0f0955", "metadata": {}, "outputs": [], @@ -87,38 +107,24 @@ "from qiskit.opflow import TaperedPauliSumOp\n", "import numpy as np\n", "\n", - "total_dist = 4\n", - "dist = 0.1\n", - "incr_early = 0.1\n", - "incr_late = 0.3\n", + "dist = 0.72\n", "\n", - "real_energies = []\n", - "dists = []\n", "ops = []\n", - "problems = []\n", - "while dist < total_dist:\n", - " molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])\n", - " driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \\\n", - " driver_type=ElectronicStructureDriverType.PYSCF)\n", "\n", - " es_problem = ElectronicStructureProblem(driver)\n", - " second_q_ops = es_problem.second_q_ops() \n", - " hamiltonian = qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles)\n", - " sol = MinimumEigensolverResult()\n", - " sol.eigenvalue = NumPyMinimumEigensolver().compute_minimum_eigenvalue(hamiltonian).eigenvalue\n", - " real_solution = es_problem.interpret(sol).total_energies[0]\n", + "molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])\n", + "driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \\\n", + " driver_type=ElectronicStructureDriverType.PYSCF)\n", "\n", - " h = hamiltonian.primitive\n", - " h.coeffs = np.real(hamiltonian.coeffs)\n", - " real_energies.append(real_solution)\n", - " ops.append(TaperedPauliSumOp(h, hamiltonian.z2_symmetries))\n", - " dists.append(dist)\n", - " problems.append(es_problem)\n", - " \n", - " if dist > total_dist / 2:\n", - " dist += incr_late\n", - " else:\n", - " dist += incr_early" + "es_problem = ElectronicStructureProblem(driver)\n", + "second_q_ops = es_problem.second_q_ops() \n", + "hamiltonian = qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles)\n", + "sol = MinimumEigensolverResult()\n", + "sol.eigenvalue = NumPyMinimumEigensolver().compute_minimum_eigenvalue(hamiltonian).eigenvalue\n", + "real_solution = es_problem.interpret(sol).total_energies[0]\n", + "\n", + "h = hamiltonian.primitive\n", + "h.coeffs = np.real(hamiltonian.coeffs)\n", + "ops.append(TaperedPauliSumOp(h, hamiltonian.z2_symmetries))" ] }, { @@ -131,70 +137,37 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "id": "a8151031", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 / 26\n", - "1 / 26\n", - "2 / 26\n", - "3 / 26\n", - "4 / 26\n", - "5 / 26\n", - "6 / 26\n", - "7 / 26\n", - "8 / 26\n", - "9 / 26\n", - "10 / 26\n", - "11 / 26\n", - "12 / 26\n", - "13 / 26\n", - "14 / 26\n", - "15 / 26\n", - "16 / 26\n", - "17 / 26\n", - "18 / 26\n", - "19 / 26\n", - "20 / 26\n", - "21 / 26\n", - "22 / 26\n", - "23 / 26\n", - "24 / 26\n", - "25 / 26\n" - ] - } - ], + "outputs": [], "source": [ - "from qiskit.algorithms.optimizers import SPSA, COBYLA\n", + "from qiskit.algorithms.optimizers import NELDER_MEAD\n", "from qiskit.circuit.library import RealAmplitudes\n", "\n", "circuit = RealAmplitudes(num_qubits=2, reps=2).decompose()\n", - "vqe_energies = []\n", + "convergence = []\n", "\n", "with estimator_factory(\n", " circuits=[circuit],\n", " observables=ops,\n", ") as estimator:\n", - " for i in range(len(ops)):\n", - " print(i, \"/\", len(ops))\n", - " def evaluate_expectation(x):\n", - " x = list(x)\n", - " results = estimator(circuit_indices=[0], observable_indices=[i], parameter_values=[x]).values[0]\n", - " return np.real(results)\n", + " def evaluate_expectation(x):\n", + " x = list(x)\n", + " results = estimator(circuit_indices=[0], observable_indices=[0], parameter_values=[x]).values[0]\n", + " return np.real(results)\n", + " \n", + " def callback(fx):\n", + " convergence.append(evaluate_expectation(fx))\n", "\n", + " np.random.seed(1)\n", + " initial_point = np.random.uniform(-np.pi, np.pi, len(circuit.parameters))\n", + " spsa = NELDER_MEAD(80, callback=callback)\n", + " _, vqe_solution, _ = spsa.optimize(initial_point.size, evaluate_expectation, initial_point=initial_point) \n", "\n", - " initial_point = np.random.uniform(-np.pi, np.pi, 6)\n", - " spsa = COBYLA(10)\n", - " _, vqe_solution, _ = spsa.optimize(initial_point.size, evaluate_expectation, initial_point=initial_point) \n", - " \n", - " sol = MinimumEigensolverResult()\n", - " sol.eigenvalue = vqe_solution\n", - " vqe_sol = es_problem.interpret(sol).total_energies[0]\n", - " vqe_energies.append(vqe_sol)\n" + " sol = MinimumEigensolverResult()\n", + " sol.eigenvalue = vqe_solution\n", + " vqe_sol = es_problem.interpret(sol).total_energies[0]\n" ] }, { @@ -207,16 +180,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "id": "fc1023e8", "metadata": {}, "outputs": [], "source": [ "vqe_interpret = []\n", - "for i in range(len(vqe_energies)):\n", + "for i in range(len(convergence)):\n", " sol = MinimumEigensolverResult()\n", - " sol.eigenvalue = vqe_energies[i]\n", - " sol = problems[i].interpret(sol).total_energies[0]\n", + " sol.eigenvalue = convergence[i]\n", + " sol = es_problem.interpret(sol).total_energies[0]\n", " vqe_interpret.append(sol)" ] }, @@ -230,13 +203,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "id": "f0ddfd36", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -250,11 +223,10 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "plt.plot(dists, real_energies, label='Real', color='red')\n", - "plt.scatter(dists, vqe_interpret, label='VQE', color='black')\n", + "plt.axhline(real_solution, label='Real', color='red')\n", + "plt.plot(vqe_interpret, label='VQE', color='black')\n", "plt.title(\"H2\")\n", - "plt.xlim(0, 4)\n", - "plt.xlabel('Angstroms')\n", + "plt.xlabel('Iteration')\n", "plt.ylabel('Hartree')\n", "plt.legend()\n", "plt.show()" @@ -262,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 7, "id": "9b99ee51", "metadata": {}, "outputs": [ @@ -272,7 +244,7 @@ "{'qiskit-terra': '0.19.2', 'qiskit-aer': '0.10.3', 'qiskit-ignis': '0.7.0', 'qiskit-ibmq-provider': '0.18.3', 'qiskit-aqua': '0.9.5', 'qiskit': '0.34.2', 'qiskit-nature': '0.3.1', 'qiskit-finance': None, 'qiskit-optimization': '0.3.1', 'qiskit-machine-learning': '0.2.1'}" ] }, - "execution_count": 96, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -281,6 +253,14 @@ "import qiskit\n", "qiskit.__qiskit_version__" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76c591f6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 75299cee0423135add1c61c752397c6cf5adbdc9 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 31 Mar 2022 14:07:26 -0400 Subject: [PATCH 06/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index fb15f01bf..be87df304 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -15,7 +15,7 @@ "source": [ "## Overview\n", "\n", - "The Variational Quantum Eigensolver (VQE) is an optimization routine for finding the ground state energy (i.e. lowest eigenvalue) of a Hamiltonain and is a considered to be a viable candidate for NISQ hardware. In this tutorial, we will go over how to use IBM Quantum Runtime to submit your VQE's to the cloud. Specifically, we will be looking at calculating the Potential Energy Surface (PES) of the $H_2$ molecule using the estimator primitive. " + "The Variational Quantum Eigensolver (VQE) is an optimization routine for finding the ground state energy (i.e. lowest eigenvalue) of a Hamiltonain and is a considered to be a viable candidate for NISQ hardware. In this tutorial, we will go over how to use IBM Quantum Runtime to submit your VQE's to the cloud. Specifically, we will be looking at calculating the ground state energy of the $H_2$ molecule using the estimator primitive. " ] }, { @@ -43,7 +43,7 @@ }, { "cell_type": "markdown", - "id": "8a6c471b", + "id": "a5bce8ea", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -54,7 +54,7 @@ { "cell_type": "code", "execution_count": null, - "id": "23c27160", + "id": "0dfcba73", "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ "id": "a251b0b2", "metadata": {}, "source": [ - "For PES we generate the molecular hamiltonians at different bond lengths. At each bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " + "At our specified bond length we will create an electronic structure problem and generate the second quantized (i.e. fermionic) operators. We then compute the true ground state energy to compare against. " ] }, { @@ -132,7 +132,7 @@ "id": "2baf3383", "metadata": {}, "source": [ - "Now we can use these hamiltonians as the observable list in our estimator factory (thus avoiding the need to create many estimator instances). The VQE routine is formalized as $\\min_\\theta \\langle \\Psi | \\hat{H} | \\Psi \\rangle $, so we just need to minimize the expectation values of the hamiltonians. " + "Now we can use this hamiltonian as the observable in our estimator factory. The VQE routine is formalized as $\\min_\\theta \\langle \\Psi | \\hat{H} | \\Psi \\rangle $, so we just need to minimize the expectation values of the hamiltonian. " ] }, { @@ -175,7 +175,7 @@ "id": "adc603cd", "metadata": {}, "source": [ - "Now that we solved the electronic hamiltonians, we have to add the nuclear energies." + "Now that we solved the electronic hamiltonian, we have to add the nuclear energies." ] }, { @@ -198,7 +198,7 @@ "id": "09e5f016", "metadata": {}, "source": [ - "Finally, we can see our PES curve!" + "Finally, we can see our convergence plot!" ] }, { @@ -257,7 +257,7 @@ { "cell_type": "code", "execution_count": null, - "id": "76c591f6", + "id": "66df643f", "metadata": {}, "outputs": [], "source": [] From 5c3b39070f7a41f9009eb368414966d7e1c63f15 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 7 Apr 2022 11:31:47 -0400 Subject: [PATCH 07/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index be87df304..585077ed0 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -24,7 +24,7 @@ "metadata": {}, "source": [ "### Create Service\n", - "First we have to create our service instance and instantiate our estimator factory. In this example we will be working with a simulator for the sake of speed, but by simply changing this one line (for choice of backend) this could run on hardware as well. " + "First we have to create our service instance and specify our backend. In this example we will be working with a simulator for the sake of speed, but by simply changing this one line (for choice of backend) this could run on hardware as well. " ] }, { @@ -34,16 +34,16 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit_ibm_runtime import IBMRuntimeService, IBMEstimator\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", "\n", - "service = IBMRuntimeService()\n", + "service = QiskitRuntimeService()\n", "\n", - "estimator_factory = IBMEstimator(service=service, backend=\"ibmq_qasm_simulator\")" + "options = {\"backend\" : \"ibmq_qasm_simulator\"}" ] }, { "cell_type": "markdown", - "id": "a5bce8ea", + "id": "a93d2e7d", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -54,7 +54,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0dfcba73", + "id": "eb864fc1", "metadata": {}, "outputs": [], "source": [ @@ -148,9 +148,11 @@ "circuit = RealAmplitudes(num_qubits=2, reps=2).decompose()\n", "convergence = []\n", "\n", - "with estimator_factory(\n", + "with Estimator(\n", " circuits=[circuit],\n", " observables=ops,\n", + " options=options,\n", + " service=service\n", ") as estimator:\n", " def evaluate_expectation(x):\n", " x = list(x)\n", @@ -257,7 +259,7 @@ { "cell_type": "code", "execution_count": null, - "id": "66df643f", + "id": "ec35cfde", "metadata": {}, "outputs": [], "source": [] From e0bee6709714a90ccc3d0245ac11ab758f7f6e62 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 7 Apr 2022 14:00:16 -0400 Subject: [PATCH 08/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index 585077ed0..e45d78274 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -15,7 +15,7 @@ "source": [ "## Overview\n", "\n", - "The Variational Quantum Eigensolver (VQE) is an optimization routine for finding the ground state energy (i.e. lowest eigenvalue) of a Hamiltonain and is a considered to be a viable candidate for NISQ hardware. In this tutorial, we will go over how to use IBM Quantum Runtime to submit your VQE's to the cloud. Specifically, we will be looking at calculating the ground state energy of the $H_2$ molecule using the estimator primitive. " + "The Variational Quantum Eigensolver (VQE) is an optimization routine for finding the ground state energy (i.e. lowest eigenvalue) of a Hamiltonian and is a considered to be a viable candidate for NISQ hardware. In this tutorial, we will go over how to use Qiskit Runtime to submit variational jobs using the estimator. Specifically, we will be looking at calculating the ground state energy of the $H_2$ molecule using the estimator primitive. " ] }, { @@ -43,7 +43,7 @@ }, { "cell_type": "markdown", - "id": "a93d2e7d", + "id": "b1ab8088", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -54,7 +54,7 @@ { "cell_type": "code", "execution_count": null, - "id": "eb864fc1", + "id": "14b0724b", "metadata": {}, "outputs": [], "source": [ @@ -259,7 +259,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ec35cfde", + "id": "9bc84286", "metadata": {}, "outputs": [], "source": [] From d0e328fce52ffddebf34ecad299dc1baf52c5c25 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Thu, 7 Apr 2022 14:03:12 -0400 Subject: [PATCH 09/14] Update estimator_vqe.ipynb --- docs/tutorials/estimator_vqe.ipynb | 34 ++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/estimator_vqe.ipynb index e45d78274..8e30832dc 100644 --- a/docs/tutorials/estimator_vqe.ipynb +++ b/docs/tutorials/estimator_vqe.ipynb @@ -43,7 +43,7 @@ }, { "cell_type": "markdown", - "id": "b1ab8088", + "id": "e78c4ba0", "metadata": {}, "source": [ "### Molecular Hamiltonians\n", @@ -54,7 +54,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14b0724b", + "id": "a635d559", "metadata": {}, "outputs": [], "source": [ @@ -236,30 +236,46 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "id": "9b99ee51", "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.2
qiskit-aer0.10.3
qiskit-ignis0.7.0
qiskit-ibmq-provider0.18.3
qiskit-aqua0.9.5
qiskit0.34.2
qiskit-nature0.3.1
qiskit-optimization0.3.1
qiskit-machine-learning0.2.1
System information
Python version3.9.6
Python compilerClang 10.0.0
Python builddefault, Aug 18 2021 12:38:10
OSDarwin
CPUs8
Memory (Gb)32.0
Thu Apr 07 14:02:39 2022 EDT
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" + ], "text/plain": [ - "{'qiskit-terra': '0.19.2', 'qiskit-aer': '0.10.3', 'qiskit-ignis': '0.7.0', 'qiskit-ibmq-provider': '0.18.3', 'qiskit-aqua': '0.9.5', 'qiskit': '0.34.2', 'qiskit-nature': '0.3.1', 'qiskit-finance': None, 'qiskit-optimization': '0.3.1', 'qiskit-machine-learning': '0.2.1'}" + "" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "import qiskit\n", - "qiskit.__qiskit_version__" + "from qiskit.tools.jupyter import *\n", + "\n", + "%qiskit_version_table\n", + "%qiskit_copyright" ] }, { "cell_type": "code", "execution_count": null, - "id": "9bc84286", + "id": "9cdd5df3", "metadata": {}, "outputs": [], "source": [] From 1c097fc6e0db03ecd1f59bb274200cb6d43cb454 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Fri, 8 Apr 2022 14:05:58 -0400 Subject: [PATCH 10/14] Rename estimator_vqe.ipynb to vqe_with_estimator.ipynb --- docs/tutorials/{estimator_vqe.ipynb => vqe_with_estimator.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/tutorials/{estimator_vqe.ipynb => vqe_with_estimator.ipynb} (100%) diff --git a/docs/tutorials/estimator_vqe.ipynb b/docs/tutorials/vqe_with_estimator.ipynb similarity index 100% rename from docs/tutorials/estimator_vqe.ipynb rename to docs/tutorials/vqe_with_estimator.ipynb From 8bc98d69dcd11b3a4cdc4440a26a9455e895e4fe Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Fri, 8 Apr 2022 14:06:15 -0400 Subject: [PATCH 11/14] Update tutorials.rst --- docs/tutorials.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/tutorials.rst b/docs/tutorials.rst index cb8926300..4fcb603d6 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -26,6 +26,16 @@ In-depth +Primitives +========== + +.. nbgallery:: + :glob: + + tutorials/vqe_with_estimator* + + + Qiskit Runtime Programs ======================= From ddc473ca477743bd0e8f456d3021eecd9d885367 Mon Sep 17 00:00:00 2001 From: Owen Lockwood <42878312+lockwo@users.noreply.github.com> Date: Fri, 8 Apr 2022 14:08:23 -0400 Subject: [PATCH 12/14] Update vqe_with_estimator.ipynb --- docs/tutorials/vqe_with_estimator.ipynb | 28 ++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/vqe_with_estimator.ipynb b/docs/tutorials/vqe_with_estimator.ipynb index 8e30832dc..ccf87ec0f 100644 --- a/docs/tutorials/vqe_with_estimator.ipynb +++ b/docs/tutorials/vqe_with_estimator.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "9c482297", "metadata": {}, "outputs": [], @@ -236,14 +236,36 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, + "id": "4c613583", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.4.0'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import qiskit_ibm_runtime\n", + "qiskit_ibm_runtime.version.get_version_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "id": "9b99ee51", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.2
qiskit-aer0.10.3
qiskit-ignis0.7.0
qiskit-ibmq-provider0.18.3
qiskit-aqua0.9.5
qiskit0.34.2
qiskit-nature0.3.1
qiskit-optimization0.3.1
qiskit-machine-learning0.2.1
System information
Python version3.9.6
Python compilerClang 10.0.0
Python builddefault, Aug 18 2021 12:38:10
OSDarwin
CPUs8
Memory (Gb)32.0
Thu Apr 07 14:02:39 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.2
qiskit-aer0.10.3
qiskit-ignis0.7.0
qiskit-ibmq-provider0.18.3
qiskit-aqua0.9.5
qiskit0.34.2
qiskit-nature0.3.1
qiskit-optimization0.3.1
qiskit-machine-learning0.2.1
System information
Python version3.9.6
Python compilerClang 10.0.0
Python builddefault, Aug 18 2021 12:38:10
OSDarwin
CPUs8
Memory (Gb)32.0
Fri Apr 08 14:06:51 2022 EDT
" ], "text/plain": [ "" From f4f62447c34eb7121f62403963b9df1824731bc6 Mon Sep 17 00:00:00 2001 From: Rathish Cholarajan Date: Fri, 8 Apr 2022 15:38:22 -0400 Subject: [PATCH 13/14] Update docs/tutorials/vqe_with_estimator.ipynb --- docs/tutorials/vqe_with_estimator.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/vqe_with_estimator.ipynb b/docs/tutorials/vqe_with_estimator.ipynb index ccf87ec0f..78acd13d6 100644 --- a/docs/tutorials/vqe_with_estimator.ipynb +++ b/docs/tutorials/vqe_with_estimator.ipynb @@ -68,7 +68,7 @@ "metadata": {}, "source": [ "\n", - "Now we need to generate the Hamiltonians that we wish to find the ground state energy of. For this task we will be utilizing qiskit nature. First we have to specify how we are converting the fermionic operators of the electronic molecular hamiltonian to qubit operators. Here we will use the Parity Mapper, which maps annihilation to Pauli operators via $ \\hat{a} \\rightarrow \\frac{1}{2} \\left ( X_p Z_{p-1} + i Y_p \\right ) X_{p+1} ... X_{N} $" + "Now we need to generate the Hamiltonians that we wish to find the ground state energy of. For this task we will be utilizing qiskit nature. First we have to specify how we are converting the fermionic operators of the electronic molecular hamiltonian to qubit operators. Here we will use the Parity Mapper, which maps annihilation to Pauli operators via $\\hat{a} \\rightarrow \\frac{1}{2} \\left ( X_p Z_{p-1} + i Y_p \\right ) X_{p+1} ... X_{N}$" ] }, { From 20d08c42f8efff274180eb67d5e925af07e35896 Mon Sep 17 00:00:00 2001 From: Rathish Cholarajan Date: Fri, 8 Apr 2022 15:45:39 -0400 Subject: [PATCH 14/14] Update docs/tutorials/vqe_with_estimator.ipynb --- docs/tutorials/vqe_with_estimator.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/vqe_with_estimator.ipynb b/docs/tutorials/vqe_with_estimator.ipynb index 78acd13d6..faabd2fc6 100644 --- a/docs/tutorials/vqe_with_estimator.ipynb +++ b/docs/tutorials/vqe_with_estimator.ipynb @@ -132,7 +132,7 @@ "id": "2baf3383", "metadata": {}, "source": [ - "Now we can use this hamiltonian as the observable in our estimator factory. The VQE routine is formalized as $\\min_\\theta \\langle \\Psi | \\hat{H} | \\Psi \\rangle $, so we just need to minimize the expectation values of the hamiltonian. " + "Now we can use this hamiltonian as the observable in our estimator factory. The VQE routine is formalized as $\\min_\\theta \\langle \\Psi | \\hat{H} | \\Psi \\rangle$, so we just need to minimize the expectation values of the hamiltonian. " ] }, {