From b4979e1263384d249339cdd977d3373a581d1c95 Mon Sep 17 00:00:00 2001 From: Marco Pistoia Date: Sun, 23 Dec 2018 23:04:29 -0500 Subject: [PATCH] Refactored all the qiskit/aqua/chemistry featured tutorials to reflect the new naming convention, from Qiskit Aqua Chemistry to just Qiskit Chemistry. This change has affected both code and text. --- .../aqua/chemistry/declarative_approach.ipynb | 71 +++--- .../dissociation_profile_of_molecule.ipynb | 89 ++++--- qiskit/aqua/chemistry/index.ipynb | 8 +- ...oach.ipynb => programmatic_approach.ipynb} | 234 +++++++++--------- 4 files changed, 212 insertions(+), 190 deletions(-) rename qiskit/aqua/chemistry/{programatic_approach.ipynb => programmatic_approach.ipynb} (63%) diff --git a/qiskit/aqua/chemistry/declarative_approach.ipynb b/qiskit/aqua/chemistry/declarative_approach.ipynb index 7de42f192..0011b3998 100644 --- a/qiskit/aqua/chemistry/declarative_approach.ipynb +++ b/qiskit/aqua/chemistry/declarative_approach.ipynb @@ -11,9 +11,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# _*Qiskit Aqua: Chemistry, writing in declarative approach*_ \n", + "# _*Qiskit Chemistry, Declarative Approach*_ \n", "\n", - "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial.\n", + "The latest version of this notebook is available at https://github.com/Qiskit/qiskit-tutorials.\n", "\n", "***\n", "### Contributors\n", @@ -22,17 +22,24 @@ "- [1]IBMQ" ] }, + { + "cell_type": "raw", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Introduction\n", "\n", - "This notebook demonstrates how to use Qiskit Aqua Chemistry to compute the ground state energy of a Hydrogen (H2) molecule using VQE and UCCSD.\n", + "This notebook demonstrates how to use Qiskit Chemistry to compute the ground state energy of molecular Hydrogen (H$_2$) using the Variational Quantum Eigensolver (VQE) algorithm and the Unitary Coupled Cluster Singles and Doubles (UCCSD) variational form. This notebook uses the so called *declarative approach*: a Python dictionary automatically generated via the Qiskit Chemistry GUI wizard summarizes the entire experiment declaratively. That dictionary is simply then passed as a paramter to the `run` method of the `AquaChemistry` solver to get the result of the experiment, also in the form of a Python dictionary.\n", "\n", - "This notebook has been written to use the HDF5 chemistry driver. This driver uses molecular data that has been saved from a prior computation so that this notebook can be run with no additional driver installation requirements. See the HDF5 chemistry driver readme for more detail.\n", + "Users who are more interested in learning the Qiskit Aqua and Qiskit Chemistry APIs and/or in contributing new algorithmic components can look at the same experiment executed [programmatically](https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/aqua/chemistry/programmatic_approach.ipynb).\n", "\n", - "First we import AquaChemistry, which is the object that will carry out the computation for us" + "This notebook has been written to use the HDF5 chemistry driver. This driver uses molecular data that has been serialized from a prior computation. This allows this notebook to be executed with no additional driver installation requirements. See the Qiskit Chemistry driver documentation for more detail.\n", + "\n", + "First, we import `QiskitChemistry`, which is the object that will carry out the computation for us" ] }, { @@ -41,7 +48,7 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit_aqua_chemistry import AquaChemistry\n", + "from qiskit_chemistry import QiskitChemistry\n", "from qiskit import Aer" ] }, @@ -49,9 +56,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we create a Python dictionary to specify the problem we want to solve. There are defaults for many additional values that are not show here for simpicity. Indeed we take advantage of using sensisble defaults that the qischem stack provides to help us here. Please notice that the Qiskit Aqua Chemistry GUI allows for automatic extraction of the Python dictionary reflecting the current configuration. Once the Python dictionary has been extracted, it can be pasted into a Python program or a Jupyter Notebook and, if necessary, edited.\n", + "Next, we create a Python dictionary to specify the problem we want to solve. There are defaults for many additional values that are not shown here for simpicity. Indeed, we take advantage of using sensisble defaults that the Qiskit Chemistry stack provides. As mentioned above, the Qiskit Chemistry GUI wizard allows for automatic extraction of the Python dictionary, reflecting the current configuration. Once the Python dictionary has been extracted, it can be pasted into a Python program or a Jupyter Notebook and, if necessary, edited.\n", "\n", - "The first entry names a chemistry driver. This example uses HDF5 and the next line configures the driver for an hdf5 file that contains data from a prior computation for an H2 molecule with basis set sto-3g. The operator line would default but I have added it here to show it and to say that this is where the problem is converted into a quantum qubit form. We then have a VQE algorithm, using the COBYLA optimizer with a UCCSD variatonal form and initial state of HartreeFock. VQE is Variational Quantum Eigensolver and as its name suggests uses a variational method to find the mimimum eigenvalue of the problem, which in this case is the ground state energy of the molecule." + "The first entry names a chemistry driver. This example uses HDF5 and the next line configures the driver for an `hdf5` file that contains data from a prior computation for an H$_2$ molecule with basis set `sto-3g`. The operator line would be automatically set by default, but we have added it here to show it and to emphasize where the problem input is converted into a quantum qubit form. We then indicate to the `QiskitChemistry` solver that the VQE algorithm should be used in this experiment, using the COBYLA optimizer with a UCCSD variatonal form and initial state of HartreeFock. VQE uses the variational method to find the mimimum eigenvalue of a problem, which in this case is the ground state energy of the molecule." ] }, { @@ -61,7 +68,7 @@ "### [Optional] Setup token to run the experiment on a real device\n", "If you would like to run the experiement on a real device, you need to setup your account first.\n", "\n", - "Note: If you do not store your token yet, use `IBMQ.save_accounts()` to store it first." + "Note: If you have not stored your token yet, use `IBMQ.save_accounts()` to store it first." ] }, { @@ -70,8 +77,8 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit import IBMQ\n", - "IBMQ.load_accounts()\n", + "# from qiskit import IBMQ\n", + "# IBMQ.load_accounts()\n", "# backend = IBMQ.get_backend('ibmq_16_melbourne')" ] }, @@ -81,6 +88,7 @@ "metadata": {}, "outputs": [], "source": [ + "from qiskit import Aer\n", "backend = Aer.get_backend('statevector_simulator')" ] }, @@ -94,7 +102,7 @@ "source": [ "# Input dictionary to configure Qiskit AQUA Chemistry for the chemistry problem.\n", "\n", - "aqua_chemistry_dict = {\n", + "qiskit_chemistry_dict = {\n", " 'driver': {'name': 'HDF5'},\n", " 'HDF5': {'hdf5_input': 'H2/0.7_sto-3g.hdf5'},\n", " 'operator': {'name': 'hamiltonian'},\n", @@ -109,7 +117,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can now create a AquaChemistry object and call run on it passing in the problem dictionary to get a result. This may take a short time and it will use a local quantum simulator to carry out the quantum computation that the VQE algorithm uses." + "We can now create an `QiskitChemistry` object and call `run` on it passing in the problem dictionary to get a result. This may take a short time and it will use a local quantum simulator to carry out the quantum computation that the VQE algorithm uses." ] }, { @@ -118,15 +126,15 @@ "metadata": {}, "outputs": [], "source": [ - "solver = AquaChemistry()\n", - "result = solver.run(aqua_chemistry_dict, backend=backend)" + "solver = QiskitChemistry()\n", + "result = solver.run(qiskit_chemistry_dict, backend=backend)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The run method returns a result dictionary. Some notable fields include 'energy' which is the computed ground state energy. We can print it." + "The `run` method returns a result dictionary. Some notable fields include `energy`, which is the computed ground state energy. We can print it." ] }, { @@ -138,7 +146,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Ground state energy: -1.1361894321408132\n" + "Ground state energy: -1.1361894423809882\n" ] } ], @@ -150,7 +158,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "There is also a 'printable' field containing a complete ready to print readable result" + "There is also a `printable` field containing a complete ready to print readable result." ] }, { @@ -164,23 +172,23 @@ "text": [ "=== GROUND STATE ENERGY ===\n", " \n", - "* Electronic ground state energy (Hartree): -1.892156876312\n", - " - computed part: -1.892156876312\n", + "* Electronic ground state energy (Hartree): -1.892156886552\n", + " - computed part: -1.892156886552\n", " - frozen energy part: 0.0\n", " - particle hole part: 0.0\n", "~ Nuclear repulsion energy (Hartree): 0.755967444171\n", - "> Total ground state energy (Hartree): -1.136189432141\n", + "> Total ground state energy (Hartree): -1.136189442381\n", " Measured:: Num particles: 2.000, S: 0.000, M: 0.00000\n", " \n", "=== DIPOLE MOMENT ===\n", " \n", - "* Electronic dipole moment (a.u.): [0.0 0.0 0.00029555]\n", - " - computed part: [0.0 0.0 0.00029555]\n", + "* Electronic dipole moment (a.u.): [0.0 0.0 -0.00006376]\n", + " - computed part: [0.0 0.0 -0.00006376]\n", " - frozen energy part: [0.0 0.0 0.0]\n", " - particle hole part: [0.0 0.0 0.0]\n", "~ Nuclear dipole moment (a.u.): [0.0 0.0 0.0]\n", - "> Dipole moment (a.u.): [0.0 0.0 -0.00029555] Total: 0.00029555\n", - " (debye): [0.0 0.0 -0.00075122] Total: 0.00075122\n" + "> Dipole moment (a.u.): [0.0 0.0 0.00006376] Total: 0.00006376\n", + " (debye): [0.0 0.0 0.00016206] Total: 0.00016206\n" ] } ], @@ -195,13 +203,20 @@ "source": [ "This was a very simple example showing how to get started. There are more elaborate notebooks here as well documentation describing the various components and their configurations to help you to experiment with quantum computing and its application to solving chemistry problems." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Quantum py37", + "display_name": "Python 3", "language": "python", - "name": "quantum-dev-37" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -213,7 +228,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.6.4" } }, "nbformat": 4, diff --git a/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb b/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb index f60a1e9b6..231637f09 100644 --- a/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb +++ b/qiskit/aqua/chemistry/dissociation_profile_of_molecule.ipynb @@ -11,9 +11,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# _*Qiskit Aqua Chemistry: Experimenting with molecular ground state energy with variational quantum eigensolver*_ \n", + "# _*Qiskit Chemistry: Compiuting a Molecule's Dissociation Profile Using the Variational Quantum Eigensolver (VQE) Algorithm*_ \n", "\n", - "The latest version of this notebook is available on https://github.com/qiskit/qiskit-tutorial.\n", + "The latest version of this notebook is available on https://github.com/qiskit/qiskit-tutorials.\n", "\n", "***\n", "### Contributors\n", @@ -116,14 +116,14 @@ "%matplotlib inline\n", "import numpy as np\n", "from qiskit import Aer\n", - "from qiskit_aqua_chemistry import AquaChemistry\n", + "from qiskit_chemistry import QiskitChemistry\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", - "# setup aqua_chemistry logging\n", + "# setup qiskit_chemistry logging\n", "import logging\n", - "from qiskit_aqua_chemistry import set_aqua_chemistry_logging\n", - "set_aqua_chemistry_logging(logging.INFO) # choose INFO, DEBUG to see the log" + "from qiskit_chemistry import set_qiskit_chemistry_logging\n", + "set_qiskit_chemistry_logging(logging.ERROR) # choose among DEBUG, INFO, WARNING, ERROR, CRITICAL and NOTSET" ] }, { @@ -142,8 +142,8 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit import IBMQ\n", - "IBMQ.load_accounts()" + "# from qiskit import IBMQ\n", + "# IBMQ.load_accounts()" ] }, { @@ -152,9 +152,9 @@ "source": [ "## Optimization of H$_2$ at bond length\n", "\n", - "In this first part of the notebook we show the optimization of the H$_2$ Hamiltonian in the STO-3G basis at the bond length of 0.735 Angstrom. After mapping it to a four-qubit system with a parity transformation, two spin-parity symmetries are modded out, leading to a two-qubit Hamiltonian. The energy of the mapped Hamiltonian obtained is then minimized using the variational ansatz described in the introduction, and a stochastic perturbation simultaneous approximation (SPSA) gradient descent method. We stored the precomputed one- and two-body integrals and other molecular information in the hdf5 file.\n", + "In this first part of the notebook, we show the optimization of the H$_2$ Hamiltonian in the `STO-3G` basis at the bond length of 0.735 Angstrom. After mapping it to a four-qubit system with a parity transformation, two spin-parity symmetries are modded out, leading to a two-qubit Hamiltonian. The energy of the mapped Hamiltonian obtained is then minimized using the variational ansatz described in the introduction, and a stochastic perturbation simultaneous approximation (SPSA) gradient descent method. We stored the precomputed one- and two-body integrals and other molecular information in the `hdf5` file.\n", "\n", - "Here we use the declarative approach to run our experiement but it is doable via programatice approach, please see this [tutorial](programatic_approach.ipynb)." + "Here we use the [*declarative approach*](https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/aqua/chemistry/declarative_approach.ipynb) to run our experiement, but the same is doable in a [fully programmatic way](https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/aqua/chemistry/programmatic_approach.ipynb), especially for those users who are interested in learning the Qiskit Aqua and Qiskit Chemistry APIs as well as contributing new algorithmic components." ] }, { @@ -167,33 +167,33 @@ "output_type": "stream", "text": [ "Ground state energy (classical): -1.137306035753\n", - "Ground state energy (quantum) : -1.137160612416\n", + "Ground state energy (quantum) : -1.137287121511\n", "====================================================\n", "=== GROUND STATE ENERGY ===\n", " \n", - "* Electronic ground state energy (Hartree): -1.857129603695\n", - " - computed part: -1.857129603695\n", + "* Electronic ground state energy (Hartree): -1.85725611279\n", + " - computed part: -1.85725611279\n", " - frozen energy part: 0.0\n", " - particle hole part: 0.0\n", "~ Nuclear repulsion energy (Hartree): 0.719968991279\n", - "> Total ground state energy (Hartree): -1.137160612416\n", + "> Total ground state energy (Hartree): -1.137287121511\n", " Measured:: Num particles: 2.000, S: 0.000, M: 0.00000\n", " \n", "=== DIPOLE MOMENT ===\n", " \n", - "* Electronic dipole moment (a.u.): [0.0 0.0 -0.01520674]\n", - " - computed part: [0.0 0.0 -0.01520674]\n", + "* Electronic dipole moment (a.u.): [0.0 0.0 -0.00514828]\n", + " - computed part: [0.0 0.0 -0.00514828]\n", " - frozen energy part: [0.0 0.0 0.0]\n", " - particle hole part: [0.0 0.0 0.0]\n", "~ Nuclear dipole moment (a.u.): [0.0 0.0 0.0]\n", - "> Dipole moment (a.u.): [0.0 0.0 -0.01520674] Total: 0.01520674\n", - " (debye): [0.0 0.0 -0.03865167] Total: 0.03865167\n" + "> Dipole moment (a.u.): [0.0 0.0 -0.00514828] Total: 0.00514828\n", + " (debye): [0.0 0.0 -0.01308562] Total: 0.01308562\n" ] } ], "source": [ "# First, we use classical eigendecomposition to get ground state energy (including nuclear repulsion energy) as reference.\n", - "aqua_chemistry_dict = {\n", + "qiskit_chemistry_dict = {\n", " 'driver': {'name': 'HDF5'},\n", " 'HDF5': {'hdf5_input': 'H2/H2_equilibrium_0.735_sto-3g.hdf5'},\n", " 'operator': {'name':'hamiltonian', \n", @@ -201,18 +201,18 @@ " 'two_qubit_reduction': True},\n", " 'algorithm': {'name': 'ExactEigensolver'}\n", "}\n", - "solver = AquaChemistry()\n", - "result = solver.run(aqua_chemistry_dict)\n", + "solver = QiskitChemistry()\n", + "result = solver.run(qiskit_chemistry_dict)\n", "print('Ground state energy (classical): {:.12f}'.format(result['energy']))\n", "\n", "# Second, we use variational quantum eigensolver (VQE)\n", - "aqua_chemistry_dict['algorithm']['name'] = 'VQE'\n", - "aqua_chemistry_dict['optimizer'] = {'name': 'SPSA', 'max_trials': 350}\n", - "aqua_chemistry_dict['variational_form'] = {'name': 'RYRZ', 'depth': 3, 'entanglement':'full'}\n", + "qiskit_chemistry_dict['algorithm']['name'] = 'VQE'\n", + "qiskit_chemistry_dict['optimizer'] = {'name': 'SPSA', 'max_trials': 350}\n", + "qiskit_chemistry_dict['variational_form'] = {'name': 'RYRZ', 'depth': 3, 'entanglement':'full'}\n", "backend = Aer.get_backend('statevector_simulator')\n", "\n", - "solver = AquaChemistry()\n", - "result = solver.run(aqua_chemistry_dict, backend=backend)\n", + "solver = QiskitChemistry()\n", + "result = solver.run(qiskit_chemistry_dict, backend=backend)\n", "print('Ground state energy (quantum) : {:.12f}'.format(result['energy']))\n", "print(\"====================================================\")\n", "# You can also print out other info in the field 'printable'\n", @@ -251,7 +251,7 @@ "# select H2 or LiH to experiment with\n", "molecule='H2'\n", "\n", - "aqua_chemistry_dict = {\n", + "qiskit_chemistry_dict = {\n", " 'driver': {'name': 'HDF5'},\n", " 'HDF5': {'hdf5_input': ''},\n", " 'operator': {'name':'hamiltonian', \n", @@ -270,26 +270,26 @@ "\n", "if molecule == 'LiH':\n", " mol_distances = np.arange(0.6, 5.1, 0.1)\n", - " aqua_chemistry_dict['operator']['freeze_core'] = True\n", - " aqua_chemistry_dict['operator']['orbital_reduction'] = [-3, -2]\n", - " aqua_chemistry_dict['optimizer']['max_trials'] = 2500\n", - " aqua_chemistry_dict['variational_form']['depth'] = 5\n", + " qiskit_chemistry_dict['operator']['freeze_core'] = True\n", + " qiskit_chemistry_dict['operator']['orbital_reduction'] = [-3, -2]\n", + " qiskit_chemistry_dict['optimizer']['max_trials'] = 2500\n", + " qiskit_chemistry_dict['variational_form']['depth'] = 5\n", "else:\n", " mol_distances = np.arange(0.2, 4.1, 0.1)\n", "\n", "energy = np.zeros((len(algos), len(mol_distances)))\n", "\n", "for j, algo in enumerate(algos):\n", - " aqua_chemistry_dict['algorithm']['name'] = algo\n", + " qiskit_chemistry_dict['algorithm']['name'] = algo\n", " if algo == 'ExactEigensolver':\n", - " aqua_chemistry_dict.pop('backend', None)\n", + " qiskit_chemistry_dict.pop('backend', None)\n", " elif algo == 'VQE':\n", - " aqua_chemistry_dict['backend'] = backend_cfg\n", + " qiskit_chemistry_dict['backend'] = backend_cfg\n", " print(\"Using {}\".format(algo))\n", " for i, dis in enumerate(mol_distances):\n", " print(\"Processing atomic distance: {:1.1f} Angstrom\".format(dis), end='\\r')\n", - " aqua_chemistry_dict['HDF5']['hdf5_input'] = \"{}/{:1.1f}_sto-3g.hdf5\".format(molecule, dis)\n", - " result = solver.run(aqua_chemistry_dict, backend=backend if algo == 'VQE' else None)\n", + " qiskit_chemistry_dict['HDF5']['hdf5_input'] = \"{}/{:1.1f}_sto-3g.hdf5\".format(molecule, dis)\n", + " result = solver.run(qiskit_chemistry_dict, backend=backend if algo == 'VQE' else None)\n", " energy[j][i] = result['energy']\n", " print(\"\\n\")" ] @@ -301,9 +301,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -318,14 +318,21 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Quantum py37", + "display_name": "Python 3", "language": "python", - "name": "quantum-dev-37" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -337,7 +344,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.6.4" } }, "nbformat": 4, diff --git a/qiskit/aqua/chemistry/index.ipynb b/qiskit/aqua/chemistry/index.ipynb index 40730ea7c..efff5974b 100644 --- a/qiskit/aqua/chemistry/index.ipynb +++ b/qiskit/aqua/chemistry/index.ipynb @@ -11,7 +11,7 @@ "## Contents\n", "\n", "* [Howto: declarative approach](declarative_approach.ipynb)\n", - "* [Howto: programatic approach](programatic_approach.ipynb)\n", + "* [Howto: programmatic approach](programmatic_approach.ipynb)\n", "* [Quantum Chemistry with VQE](dissociation_profile_of_molecule.ipynb) dissociation curve of H2 and LiH\n", "* More examples can be found in [commuity/aqua/chemistry](../../../community/aqua/chemistry)" ] @@ -28,9 +28,9 @@ ], "metadata": { "kernelspec": { - "display_name": "quantum-dev", + "display_name": "Python 3", "language": "python", - "name": "quantum-dev" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -42,7 +42,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.4" } }, "nbformat": 4, diff --git a/qiskit/aqua/chemistry/programatic_approach.ipynb b/qiskit/aqua/chemistry/programmatic_approach.ipynb similarity index 63% rename from qiskit/aqua/chemistry/programatic_approach.ipynb rename to qiskit/aqua/chemistry/programmatic_approach.ipynb index fe01be111..a0ed9e44f 100644 --- a/qiskit/aqua/chemistry/programatic_approach.ipynb +++ b/qiskit/aqua/chemistry/programmatic_approach.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# _*Qiskit Aqua: Chemistry, programatic approach*_ \n", + "# _*Qiskit Chemistry, Programmatic Approach*_ \n", "\n", "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial.\n", "\n", @@ -27,13 +27,13 @@ "metadata": {}, "source": [ "### Introduction\n", - "In the [declarative_approach](declarative_approach.ipynb) example, we show how to configure different parameters in an input dictionary for different experiments in Aqua Chemistry. Nonetheless, for the users who intersted in experimenting with their new algorithm or new components in the algorithm, which is outside of the bounds of the high-level APIs, the users may want to break down the computation into smaller steps.\n", + "In the [declarative_approach](declarative_approach.ipynb) example, we show how to configure different parameters in an input dictionary for different experiments in Qiskit Chemistry. However, many users might be intersted in experimenting with new algorithms or algorithm components, or in programming an experiment step by step using the Qiskit Chemistry APIs. This notebook illustrates how to use Qiskit Chemistry's programmatic APIs.\n", "\n", - "In this notebook, we decompose the steps to compute the ground state energy of a molecule into 4 steps:\n", - " 1. define a molecule and get integrals from a driver (PySCF)\n", - " 2. define how to map Fermionic Hamiltonian into qubit Hamiltonian\n", - " 3. initiate and config dynamically-loaded instances, such as algorithm, optimizer, variational_form, and initial_state\n", - " 4. run the algorithm and retrieve the results" + "In this notebook, we decompose the computation of the ground state energy of a molecule into 4 steps:\n", + " 1. Define a molecule and get integrals from a computational chemistry driver (PySCF in this case)\n", + " 2. Construct a Fermionic Hamiltonian and map it onto a qubit Hamiltonian\n", + " 3. Instantiated and initialize dynamically-loaded algorithmic components, such as the quantum algorithm VQE, the optimizer and variational form it will use, and the initial_state to initialize the variational form\n", + " 4. Run the algorithm on a quantum backend and retrieve the results" ] }, { @@ -53,10 +53,10 @@ "from qiskit_aqua.components.optimizers import COBYLA\n", "\n", "# lib from Qiskit Aqua Chemistry\n", - "from qiskit_aqua_chemistry import FermionicOperator\n", - "from qiskit_aqua_chemistry.drivers import ConfigurationManager\n", - "from qiskit_aqua_chemistry.aqua_extensions.components.variational_forms import UCCSD\n", - "from qiskit_aqua_chemistry.aqua_extensions.components.initial_states import HartreeFock" + "from qiskit_chemistry import FermionicOperator\n", + "from qiskit_chemistry.drivers import ConfigurationManager\n", + "from qiskit_chemistry.aqua_extensions.components.variational_forms import UCCSD\n", + "from qiskit_chemistry.aqua_extensions.components.initial_states import HartreeFock" ] }, { @@ -106,7 +106,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "HF energy: -8.854072040283645\n", + "HF energy: -8.85407204028365\n", "# of electrons: 4\n", "# of spin orbitals: 12\n" ] @@ -138,106 +138,106 @@ "name": "stdout", "output_type": "stream", "text": [ - "IIII\t(-0.20765933501970818+0j)\n", - "IIIZ\t(-0.09376337484626399+0j)\n", - "IIZX\t(-0.0031775814548705844+0j)\n", - "IIIX\t(0.0031775814548705844+0j)\n", - "IIXX\t(-0.0012513965999570598+0j)\n", - "IIYY\t(0.0012513965999570598+0j)\n", - "IIZZ\t(-0.21162509515109731+0j)\n", - "IIXZ\t(0.01920053386310309+0j)\n", - "IIXI\t(0.01920053386310309+0j)\n", - "IIZI\t(0.3581026994577042+0j)\n", - "IZII\t(0.09376337484626399+0j)\n", - "ZXII\t(0.0031775814548705918+0j)\n", - "IXII\t(0.0031775814548705918+0j)\n", - "XXII\t(-0.001251396599957065+0j)\n", - "YYII\t(0.001251396599957065+0j)\n", - "ZZII\t(-0.21162509515109737+0j)\n", - "XZII\t(-0.01920053386310308+0j)\n", - "XIII\t(0.01920053386310308+0j)\n", - "ZIII\t(-0.3581026994577042+0j)\n", - "IZIZ\t(-0.12182774215820587+0j)\n", - "IZZX\t(0.01214489722808203+0j)\n", - "IZIX\t(-0.01214489722808203+0j)\n", - "IZXX\t(0.03169874598733765+0j)\n", - "IZYY\t(-0.03169874598733765+0j)\n", - "IXIZ\t(0.012144897228082029+0j)\n", - "ZXIZ\t(0.012144897228082029+0j)\n", - "IXZX\t(-0.003265995499666326+0j)\n", - "ZXZX\t(-0.003265995499666326+0j)\n", - "IXIX\t(0.003265995499666326+0j)\n", - "ZXIX\t(0.003265995499666326+0j)\n", - "IXXX\t(-0.00865015686061975+0j)\n", - "ZXXX\t(-0.00865015686061975+0j)\n", - "IXYY\t(0.00865015686061975+0j)\n", - "ZXYY\t(0.00865015686061975+0j)\n", - "YYIZ\t(0.03169874598733764+0j)\n", - "XXIZ\t(-0.03169874598733764+0j)\n", - "YYZX\t(-0.008650156860619748+0j)\n", - "XXZX\t(0.008650156860619748+0j)\n", - "YYIX\t(0.008650156860619748+0j)\n", - "XXIX\t(-0.008650156860619748+0j)\n", - "YYXX\t(-0.03098161334462468+0j)\n", - "XXXX\t(0.03098161334462468+0j)\n", - "YYYY\t(0.03098161334462468+0j)\n", - "XXYY\t(-0.03098161334462468+0j)\n", - "ZZIZ\t(0.055902510785167156+0j)\n", - "ZZZX\t(0.001871042751421938+0j)\n", - "ZZIX\t(-0.001871042751421938+0j)\n", - "ZZXX\t(0.0031040041160655197+0j)\n", - "ZZYY\t(-0.0031040041160655197+0j)\n", - "XIIZ\t(0.012841723180766738+0j)\n", - "XZIZ\t(-0.012841723180766738+0j)\n", - "XIZX\t(-0.0023521521732534313+0j)\n", - "XZZX\t(0.0023521521732534313+0j)\n", - "XIIX\t(0.0023521521732534313+0j)\n", - "XZIX\t(-0.0023521521732534313+0j)\n", - "XIXX\t(-0.00797590875057197+0j)\n", - "XZXX\t(0.00797590875057197+0j)\n", - "XIYY\t(0.00797590875057197+0j)\n", - "XZYY\t(-0.00797590875057197+0j)\n", - "ZIIZ\t(0.11346110712684758+0j)\n", - "ZIZX\t(-0.010838363828755228+0j)\n", - "ZIIX\t(0.010838363828755228+0j)\n", - "ZIXX\t(-0.033551353111232474+0j)\n", - "ZIYY\t(0.033551353111232474+0j)\n", - "IZZZ\t(-0.055902510785167156+0j)\n", - "IZXZ\t(-0.012841723180766738+0j)\n", - "IZXI\t(-0.012841723180766738+0j)\n", - "IXZZ\t(-0.001871042751421938+0j)\n", - "ZXZZ\t(-0.001871042751421938+0j)\n", - "IXXZ\t(0.002352152173253431+0j)\n", - "ZXXZ\t(0.002352152173253431+0j)\n", - "IXXI\t(0.002352152173253431+0j)\n", - "ZXXI\t(0.002352152173253431+0j)\n", - "YYZZ\t(-0.0031040041160655197+0j)\n", - "XXZZ\t(0.0031040041160655197+0j)\n", - "YYXZ\t(0.00797590875057197+0j)\n", - "XXXZ\t(-0.00797590875057197+0j)\n", - "YYXI\t(0.00797590875057197+0j)\n", - "XXXI\t(-0.00797590875057197+0j)\n", - "ZZZZ\t(0.08447056807294218+0j)\n", - "ZZXZ\t(-0.008994911953942267+0j)\n", - "ZZXI\t(-0.008994911953942267+0j)\n", - "XIZZ\t(-0.008994911953942267+0j)\n", - "XZZZ\t(0.008994911953942267+0j)\n", - "XIXZ\t(0.006612047066157872+0j)\n", - "XZXZ\t(-0.006612047066157872+0j)\n", - "XIXI\t(0.006612047066157872+0j)\n", - "XZXI\t(-0.006612047066157872+0j)\n", - "ZIZZ\t(0.060358912810788715+0j)\n", - "ZIXZ\t(0.011019231644722084+0j)\n", - "ZIXI\t(0.011019231644722084+0j)\n", - "IZZI\t(0.11346110712684758+0j)\n", - "IXZI\t(-0.010838363828755228+0j)\n", - "ZXZI\t(-0.010838363828755228+0j)\n", - "YYZI\t(-0.033551353111232474+0j)\n", - "XXZI\t(0.033551353111232474+0j)\n", - "ZZZI\t(-0.060358912810788715+0j)\n", - "XIZI\t(-0.011019231644722086+0j)\n", - "XZZI\t(0.011019231644722086+0j)\n", - "ZIZI\t(-0.11344680300366616+0j)\n", + "IIII\t(-0.2076593350197065+0j)\n", + "IIIZ\t(-0.09376337484626635+0j)\n", + "IIZX\t(-0.0031775814549057117+0j)\n", + "IIIX\t(0.0031775814549057117+0j)\n", + "IIXX\t(-0.0012513965999421568+0j)\n", + "IIYY\t(0.0012513965999421568+0j)\n", + "IIZZ\t(-0.21162509515109398+0j)\n", + "IIXZ\t(0.019200533863095684+0j)\n", + "IIXI\t(0.019200533863095684+0j)\n", + "IIZI\t(0.3581026994577069+0j)\n", + "IZII\t(0.09376337484626637+0j)\n", + "ZXII\t(0.0031775814549057126+0j)\n", + "IXII\t(0.0031775814549057126+0j)\n", + "XXII\t(-0.0012513965999421655+0j)\n", + "YYII\t(0.0012513965999421655+0j)\n", + "ZZII\t(-0.21162509515109404+0j)\n", + "XZII\t(-0.019200533863095684+0j)\n", + "XIII\t(0.019200533863095684+0j)\n", + "ZIII\t(-0.35810269945770695+0j)\n", + "IZIZ\t(-0.12182774215819626+0j)\n", + "IZZX\t(0.012144897228102084+0j)\n", + "IZIX\t(-0.012144897228102084+0j)\n", + "IZXX\t(0.03169874598733009+0j)\n", + "IZYY\t(-0.03169874598733009+0j)\n", + "IXIZ\t(0.012144897228102082+0j)\n", + "ZXIZ\t(0.012144897228102082+0j)\n", + "IXZX\t(-0.003265995499675574+0j)\n", + "ZXZX\t(-0.003265995499675574+0j)\n", + "IXIX\t(0.003265995499675574+0j)\n", + "ZXIX\t(0.003265995499675574+0j)\n", + "IXXX\t(-0.008650156860630915+0j)\n", + "ZXXX\t(-0.008650156860630915+0j)\n", + "IXYY\t(0.008650156860630915+0j)\n", + "ZXYY\t(0.008650156860630915+0j)\n", + "YYIZ\t(0.03169874598733009+0j)\n", + "XXIZ\t(-0.03169874598733009+0j)\n", + "YYZX\t(-0.008650156860630916+0j)\n", + "XXZX\t(0.008650156860630916+0j)\n", + "YYIX\t(0.008650156860630916+0j)\n", + "XXIX\t(-0.008650156860630916+0j)\n", + "YYXX\t(-0.03098161334461928+0j)\n", + "XXXX\t(0.03098161334461928+0j)\n", + "YYYY\t(0.03098161334461928+0j)\n", + "XXYY\t(-0.03098161334461928+0j)\n", + "ZZIZ\t(0.05590251078517651+0j)\n", + "ZZZX\t(0.0018710427514285974+0j)\n", + "ZZIX\t(-0.0018710427514285974+0j)\n", + "ZZXX\t(0.0031040041160567706+0j)\n", + "ZZYY\t(-0.0031040041160567706+0j)\n", + "XIIZ\t(0.012841723180777798+0j)\n", + "XZIZ\t(-0.012841723180777798+0j)\n", + "XIZX\t(-0.002352152173263534+0j)\n", + "XZZX\t(0.002352152173263534+0j)\n", + "XIIX\t(0.002352152173263534+0j)\n", + "XZIX\t(-0.002352152173263534+0j)\n", + "XIXX\t(-0.007975908750580529+0j)\n", + "XZXX\t(0.007975908750580529+0j)\n", + "XIYY\t(0.007975908750580529+0j)\n", + "XZYY\t(-0.007975908750580529+0j)\n", + "ZIIZ\t(0.11346110712684021+0j)\n", + "ZIZX\t(-0.010838363828772039+0j)\n", + "ZIIX\t(0.010838363828772039+0j)\n", + "ZIXX\t(-0.03355135311122575+0j)\n", + "ZIYY\t(0.03355135311122575+0j)\n", + "IZZZ\t(-0.05590251078517651+0j)\n", + "IZXZ\t(-0.0128417231807778+0j)\n", + "IZXI\t(-0.0128417231807778+0j)\n", + "IXZZ\t(-0.0018710427514285971+0j)\n", + "ZXZZ\t(-0.0018710427514285971+0j)\n", + "IXXZ\t(0.002352152173263534+0j)\n", + "ZXXZ\t(0.002352152173263534+0j)\n", + "IXXI\t(0.002352152173263534+0j)\n", + "ZXXI\t(0.002352152173263534+0j)\n", + "YYZZ\t(-0.0031040041160567706+0j)\n", + "XXZZ\t(0.0031040041160567706+0j)\n", + "YYXZ\t(0.00797590875058053+0j)\n", + "XXXZ\t(-0.00797590875058053+0j)\n", + "YYXI\t(0.00797590875058053+0j)\n", + "XXXI\t(-0.00797590875058053+0j)\n", + "ZZZZ\t(0.08447056807293814+0j)\n", + "ZZXZ\t(-0.008994911953942303+0j)\n", + "ZZXI\t(-0.008994911953942303+0j)\n", + "XIZZ\t(-0.008994911953942303+0j)\n", + "XZZZ\t(0.008994911953942303+0j)\n", + "XIXZ\t(0.006612047066164482+0j)\n", + "XZXZ\t(-0.006612047066164482+0j)\n", + "XIXI\t(0.006612047066164482+0j)\n", + "XZXI\t(-0.006612047066164482+0j)\n", + "ZIZZ\t(0.060358912810797395+0j)\n", + "ZIXZ\t(0.011019231644733077+0j)\n", + "ZIXI\t(0.011019231644733077+0j)\n", + "IZZI\t(0.11346110712684021+0j)\n", + "IXZI\t(-0.010838363828772039+0j)\n", + "ZXZI\t(-0.010838363828772039+0j)\n", + "YYZI\t(-0.03355135311122575+0j)\n", + "XXZI\t(0.03355135311122575+0j)\n", + "ZZZI\t(-0.060358912810797395+0j)\n", + "XIZI\t(-0.011019231644733077+0j)\n", + "XZZI\t(0.011019231644733077+0j)\n", + "ZIZI\t(-0.11344680300365938+0j)\n", "\n", "Representation: paulis, qubits: 4, size: 100\n" ] @@ -332,8 +332,8 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit import IBMQ\n", - "IBMQ.load_accounts()" + "# from qiskit import IBMQ\n", + "# IBMQ.load_accounts()" ] }, { @@ -415,9 +415,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Quantum py37", + "display_name": "Python 3", "language": "python", - "name": "quantum-dev-37" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -429,7 +429,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.6.4" } }, "nbformat": 4,