![](\"../img/li2_4.png\")
\n",
- " ![](\"../img/li2_4_opt.png\")
\n",
- " | \n",
- " Original molecular orbital | \n",
- " \n",
- " Optimized molecular orbital | \n",
- "
| \n",
- " \n",
- " | \n",
- " \n",
- " \n",
- " | \n",
- "
![](\"../img/rodeo_1000.png\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "RUwlEQ-AL8wz"
- },
- "source": [
- "## 4. Closing words \n",
- "\n",
- "We have shown a few of the many different algorithms that can be used to calculate excited states using Tangelo. Unlike ground states, the use of variational methods requires either penalizing against previously calculated states or the optimization of a collection of orthogonal states. Outside of variational methods, we have shown a few Hamiltonian simulation based algorithms to calculate excited states. \n",
- "\n",
- "But quantum resource requirements are an important aspect of quantum algorithm design: let's have a look at the resources required for each algorithm we tried on our use case. In particular, the following metrics:\n",
- "\n",
- "- `# measurements basis` is the number of distinct measurements for each function evaluation in the variational optimization process.\n",
- "- `# CNOT gates` is the number of CNOT gates in each circuit.\n",
- "- `# post measurements basis` is the number of measurements needed to successfully post-process the output of the algorithm. \n",
- "\n",
- "We note that `# CNOT gates` for each variational algorithm could be improved greatly if an algorithm such as ADAPT-VQE was used to create an ansatz. Similarly, `# CNOT gates` could be reduced for the time-evolution algorithms with more advanced approaches such as qubitization."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 26,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Algorithm # measurements # CNOT gates # post measurements \n",
- "vqe_ground_state 15 64 0 \n",
- "vqe_triplet_state 15 128 0 \n",
- "vqe_deflation_state_1 16 192 0 \n",
- "vqe_deflation_state_2 17 192 0 \n",
- "vqe_deflation_state_3 18 192 0 \n",
- "quantum_subspace_expansion 18 192 288 \n",
- "sa_vqe 60 128 0 \n",
- "mc_vqe 60 128 540 \n",
- "sa_vqe_deflation 18 192 0 \n",
- "sa_oo_vqe 30 128 0 \n",
- "mrsqk 0 72 16 \n",
- "rodeo 0 320 30 \n"
- ]
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mOclGIFNL8wf"
+ },
+ "source": [
+ "# Excited States in Tangelo"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8BtSmADsL8wj"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "One impactful application of quantum chemistry, in both academia and industry, is the study of the interaction of light with matter. Absorption (resp. emission) of a photon by a molecule can promote (resp. demote) an electron from a lower (resp. higher) electronic state to a higher (resp. lower) energy electronic state. The photon wavelength (i.e. energy) required for these transitions to occur is determined by the difference between the two respective electronic states. Therefore, it is imperative to be able to calculate accurate energies for both ground and excited states to study light/matter interations. These energy differences play a central role in many technologies such as solar panels, light-emitting diodes (LED), displays, and colorants."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZjlMQmjsL8wk"
+ },
+ "source": [
+ "To be more concrete, a colorant must emit light in a narrow region in the visible spectrum to be appropriate for the purpose, that is to say it must exhibit a specific wavelength. Another example is solar panels, where the absorption spectrum of a molecule is tuned via chemical functionalization to fit the solar emission spectrum to optimize the energy output efficiency. Here we show an example of a spectrum for the BODIPY molecule, a molecule widely used for fluorescent dyes. BODIPY absorbs light at a lower wavelength (higher energy) and emits light at a higher wavelength (lower energy). To compute this spectrum, one needs to calculate the ground and excited state energies and calculate their intensities. The absorption spectrum for the simplest BODIPY is shown below. Different absorption and emission wavelengths can be targeted by substituting the hydrogen atoms with different functional groups [J. Chem. Phys. 155, 244102 (2021)](https://aip.scitation.org/doi/10.1063/5.0076787).\n",
+ "\n",
+ "\n",
+ "\n",
+ "As there are a very large number of compounds to be considered, predicting absorption/emission UV-visible spectra would be a valuable asset to the scientific community.\n",
+ "\n",
+ "To achieve complete understanding of light interaction with a molecule, the quantum chemistry community has worked on several algorithms. In general, one must compute the relevant molecular electronic structures for the prediction of UV light absorption/emission. This notebook shows how Tangelo enables excited states calculations by implementing a few existing quantum algorithms. These are broadly grouped into variational optimization algorithms and algorithms that rely on Hamiltonian simulation. Along the way, we keep track of the quantum computational resources required by each of these approaches, and summarize this information at the end of the notebook. The use case here is Li $_2$ for expediency but many of these quantum algorithms can, in principle, be extended to much larger systems such as the BODIPY molecule above.\n",
+ "\n",
+ "It is worth noting that even with all the computed excited states, non-trivial effects can happen (solvation effect, geometry change, etc.) in which all modify the shape of a spectrum. In this notebook, we do not discuss how these effects are accounted for, but the calculations presented here are the necessary first steps towards computing excited states."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iujthgTEPHjH"
+ },
+ "source": [
+ "## Installation & Background\n",
+ "In order to successfully run this notebook, you need to install Tangelo. It is also important to be somewhat familiar with the variational quantum eigensolver (VQE). Information about VQE can be found in our [VQE with Tangelo](../variational_methods/vqe.ipynb) notebook. Information about each algorithm can be found by following the references linked when each method is introduced. The cell below installs Tangelo in your environment, if it has not been done already."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "QHfbVqHzxPwY",
+ "outputId": "dfb2c373-12a7-41f3-bd41-e3651e45d7f1"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+ " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m288.3/288.3 kB\u001b[0m \u001b[31m13.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m26.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m34.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25h Building wheel for tangelo-gc (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+ " Building wheel for pubchempy (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+ "Reading package lists... Done\n",
+ "Building dependency tree... Done\n",
+ "Reading state information... Done\n",
+ "git is already the newest version (1:2.34.1-1ubuntu1.11).\n",
+ "0 upgraded, 0 newly installed, 0 to remove and 49 not upgraded.\n",
+ "Cloning into 'Tangelo-Examples'...\n",
+ "remote: Enumerating objects: 2251, done.\u001b[K\n",
+ "remote: Counting objects: 100% (218/218), done.\u001b[K\n",
+ "remote: Compressing objects: 100% (144/144), done.\u001b[K\n",
+ "remote: Total 2251 (delta 98), reused 76 (delta 71), pack-reused 2033 (from 1)\u001b[K\n",
+ "Receiving objects: 100% (2251/2251), 10.09 MiB | 24.90 MiB/s, done.\n",
+ "Resolving deltas: 100% (1469/1469), done.\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " import tangelo\n",
+ "except ModuleNotFoundError:\n",
+ " !pip install git+https://github.com/goodchemistryco/Tangelo.git@develop --quiet\n",
+ "\n",
+ "# Download the data folder at https://github.com/goodchemistryco/Tangelo-Examples/tree/main/examples/chemistry/data\n",
+ "import os\n",
+ "if not os.path.isdir(\"data\"):\n",
+ " !sudo apt install git\n",
+ " !git clone https://github.com/sandbox-quantum/Tangelo-Examples.git\n",
+ " !mkdir data\n",
+ " !cp -a Tangelo-Examples/examples/chemistry/data/. ./data/"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "We'll also need to install pycsf, to support basic quantum chemistry features :"
+ ],
+ "metadata": {
+ "id": "KcBCl55KAhvE"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "7HwWqzwizb9I",
+ "outputId": "84b58e65-ca05-4206-873c-3fad2fa7f3f0"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Collecting pyscf==2.3.0\n",
+ " Downloading pyscf-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.1 kB)\n",
+ "Requirement already satisfied: numpy!=1.16,!=1.17,>=1.13 in /usr/local/lib/python3.10/dist-packages (from pyscf==2.3.0) (1.26.4)\n",
+ "Requirement already satisfied: scipy!=1.5.0,!=1.5.1 in /usr/local/lib/python3.10/dist-packages (from pyscf==2.3.0) (1.13.1)\n",
+ "Requirement already satisfied: h5py>=2.7 in /usr/local/lib/python3.10/dist-packages (from pyscf==2.3.0) (3.11.0)\n",
+ "Downloading pyscf-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (47.2 MB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m47.2/47.2 MB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hInstalling collected packages: pyscf\n",
+ "Successfully installed pyscf-2.3.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install --prefer-binary pyscf==2.3.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xPrfVi8IL8wl"
+ },
+ "source": [
+ "## Table of Contents\n",
+ "* [1. Obtaining excited state energies classically](#1)\n",
+ "* [2. Variational optimization algorithms](#2)\n",
+ " * [2.1 VQE for lowest singlet and triplet state ](#21)\n",
+ " * [2.2 VQE Deflation](#22)\n",
+ " * [2.3 Quantum Subspace Expansion](#23)\n",
+ " * [2.4 State-Averaged VQE](#24)\n",
+ " * [2.5 Multi-state contracted VQE (MC-VQE)](#25)\n",
+ " * [2.6 State-Averaged VQE with deflation](#26)\n",
+ " * [2.7 State-Averaged Orbital-Optimized VQE](#27)\n",
+ "* [3. Hamiltonian Simulation algorithms](#3)\n",
+ " * [3.1 Multi-Reference Selected Quantum Krylov](#31)\n",
+ " * [3.2 Rodeo Algorithm](#32)\n",
+ "* [4. Closing words](#4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "knX1VqLsL8wl"
+ },
+ "source": [
+ "The molecular system we use to illustrate a number of excited state algorithms in this notebook is Li $_2$ near its equilibrium geometry. The full calculation of the Li $_2$ energies would be non-trivial and very computationally expensive; we therefore restrict ourselves to an active space of 2 electrons in 2 orbitals which involve 4 qubits when mapped to a qubit Hamiltonian using the Jordan-Wigner mapping. However, there are still non-trivial effects that occur with this small problem, made particularly evident in section [2.7](#27). We define two molecule objects:\n",
+ "\n",
+ "- `mol_li2` defined as the ground state configuration with 2 electrons in the HOMO.\n",
+ "- `mol_li2_t` defined as the triplet configuration with an alpha electron in each of the HOMO and LUMO."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "sZnJKujyxPwZ",
+ "outputId": "a5356826-25ef-4013-9384-250f5819f091"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.10/dist-packages/pyscf/dft/libxc.py:772: UserWarning: Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, the same to the B3LYP functional in Gaussian and ORCA (issue 1480). To restore the VWN5 definition, you can put the setting \"B3LYP_WITH_VWN5 = True\" in pyscf_conf.py\n",
+ " warnings.warn('Since PySCF-2.3, B3LYP (and B3P86) are changed to the VWN-RPA variant, '\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tangelo import SecondQuantizedMolecule as SQMol\n",
+ "li2= \"\"\"Li 0. 0. 0.\n",
+ " Li 3.0 0. 0. \"\"\"\n",
+ "\n",
+ "# 2 electrons in 2 orbitals\n",
+ "fo = [0,1]+[i for i in range(4,28)]\n",
+ "\n",
+ "# Runs RHF calculation\n",
+ "mol_Li2 = SQMol(li2, q=0, spin=0, basis='6-31g(d,p)', frozen_orbitals=fo, symmetry=True)\n",
+ "\n",
+ "# Runs ROHF calculation\n",
+ "mol_Li2_t = SQMol(li2, q=0, spin=2, basis=\"6-31g(d,p)\", frozen_orbitals=fo, symmetry=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "D-72nuJ3L8wn"
+ },
+ "source": [
+ "Since we set `symmetry=True` in the initialization, the symmetry labels of all the\n",
+ "orbitals have been populated in `mol_li2.mo_symm_labels`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "p31n7vJfxPwa",
+ "outputId": "a781ea46-895b-4f7d-90f9-6e1e15629e5a"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " # Energy Symm Occ\n",
+ " 1 -2.4479 A1g 2\n",
+ " 2 -2.4478 A1u 2\n",
+ " 3 -0.1716 A1g 2\n",
+ " 4 0.0129 A1u 0\n",
+ "Number of active electrons: 2\n",
+ "Number of active orbtials: 2\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Symmetry labels and occupations for frozen core and active orbitals\n",
+ "print(\" # Energy Symm Occ\")\n",
+ "for i in range(4):\n",
+ " print(f\"{i+1:3d}{mol_Li2.mo_energies[i]: 9.4f} {mol_Li2.mo_symm_labels[i]} {int(mol_Li2.mo_occ[i])}\")\n",
+ "\n",
+ "# Active electrons, Active orbitals\n",
+ "print(f\"Number of active electrons: {mol_Li2.n_active_electrons}\")\n",
+ "print(f\"Number of active orbtials: {mol_Li2.n_active_mos}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "INDk1VI0L8wo"
+ },
+ "source": [
+ "We can examine the molecular orbitals by exporting them as cube files. These can then be read in by your favourite orbital viewer.\n",
+ "\n",
+ "```python\n",
+ "from pyscf.tools import cubegen\n",
+ "# Output cube files for active orbitals\n",
+ "for i in [2, 3]:\n",
+ " cubegen.orbital(mol_Li2.to_pyscf(basis = mol_Li2.basis), f'li2_{i+1}.cube', mol_Li2.mean_field.mo_coeff[:, i])\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wwUS06EwL8wp"
+ },
+ "source": [
+ "## 1. Obtaining excited state energies classically \n",
+ "\n",
+ "In order to compare the various quantum algorithms, it is useful to have the classically calculated values. Below we will calculate the two A1g and A2g states using PySCF CASCI implementation (https://pyscf.org/user/mcscf.html)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "-KscqbilxPwa",
+ "outputId": "e5b56a6f-afdf-4cc1-adc2-7b1340fb676e"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calculation for A1g symmetry\n",
+ "\n",
+ "WARN: Mulitple states found in CASCI solver. First state is used to compute the Fock matrix and natural orbitals in active space.\n",
+ "\n",
+ "CASCI state 0 E = -14.8696203628269 E(CI) = -0.575225299756584 S^2 = 0.0000000\n",
+ "CASCI state 1 E = -14.6801962666144 E(CI) = -0.385801203544137 S^2 = 0.0000000\n",
+ "\n",
+ " Calculation for A1u symmetry\n",
+ "\n",
+ "WARN: Mulitple states found in CASCI solver. First state is used to compute the Fock matrix and natural orbitals in active space.\n",
+ "\n",
+ "CASCI state 0 E = -14.8387664606074 E(CI) = -0.544371397537086 S^2 = 2.0000000\n",
+ "CASCI state 1 E = -14.7840380866340 E(CI) = -0.489643023563765 S^2 = 0.0000000\n"
+ ]
+ }
+ ],
+ "source": [
+ "from pyscf import mcscf\n",
+ "\n",
+ "myhf = mol_Li2.mean_field\n",
+ "ncore = {\"A1g\": 1, \"A1u\": 1}\n",
+ "ncas = {\"A1g\": 1, \"A1u\": 1}\n",
+ "\n",
+ "print(\"Calculation for A1g symmetry\")\n",
+ "mc = mcscf.CASCI(myhf, 2, (1, 1))\n",
+ "mo = mc.sort_mo_by_irrep(cas_irrep_nocc=ncas, cas_irrep_ncore=ncore)\n",
+ "mc.fcisolver.wfnsym = \"A1g\"\n",
+ "mc.fcisolver.nroots = 2\n",
+ "emc_A1g = mc.casci(mo)[0]\n",
+ "\n",
+ "print(\"\\n Calculation for A1u symmetry\")\n",
+ "mc = mcscf.CASCI(myhf, 2, (1, 1))\n",
+ "mc.fcisolver.wfnsym = \"A1u\"\n",
+ "mc.fcisolver.nroots = 2\n",
+ "emc_A1u = mc.casci(mo)[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mE9Dp_XZL8wq"
+ },
+ "source": [
+ "## 2. Variational algorithms\n",
+ "\n",
+ "We start by showing how different approaches based on VQE can be used to obtain excited states. For more information about VQE and the `VQESolver` class, feel free to have a look at our dedicated tutorials."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Y6t3SWGdL8wq"
+ },
+ "source": [
+ "### 2.1 VQE for lowest singlet and triplet states \n",
+ "\n",
+ "Both the lowest singlet (ground state) and lowest triplet (first excited state) can be computed using `VQESolver`. The `FCISolver` class can be used to produce a classically-computed reference value, to get a sense of the accuracy of VQE in this situation. Along the way, we capture the quantum computational resources required for each algorithm in the dictionary `algorithm_resources`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GzD9VBbzxPwa",
+ "outputId": "6ae173b3-8c27-4494-cbb4-5a78cbb570f4"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ " Ground Singlet state\n",
+ "VQE energy = -14.869620361804333\n",
+ "CASCI energy = -14.869620362826867\n",
+ "\n",
+ " Lowest Triplet state\n",
+ "VQE energy = -14.853462489027093\n",
+ "CASCI energy = -14.853462489027102\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tangelo.algorithms.variational import VQESolver, BuiltInAnsatze\n",
+ "from tangelo.algorithms.classical import FCISolver\n",
+ "\n",
+ "# Dictionary of resources for each algorithm\n",
+ "algorithm_resources = dict()\n",
+ "\n",
+ "# Ground state energy calculation with VQE, reference values with FCI\n",
+ "vqe_options = {\"molecule\": mol_Li2, \"ansatz\": BuiltInAnsatze.UCCSD}\n",
+ "vqe_solver = VQESolver(vqe_options)\n",
+ "vqe_solver.build()\n",
+ "vqe_energy = vqe_solver.simulate()\n",
+ "print(\"\\n Ground Singlet state\")\n",
+ "print(f\"VQE energy = {vqe_energy}\")\n",
+ "print(f\"CASCI energy = {FCISolver(mol_Li2).simulate()}\")\n",
+ "algorithm_resources[\"vqe_ground_state\"] = vqe_solver.get_resources()\n",
+ "\n",
+ "# First excited state energy calculation with VQE, reference values with FCI\n",
+ "vqe_options = {\"molecule\": mol_Li2_t, \"ansatz\": BuiltInAnsatze.UpCCGSD}\n",
+ "vqe_solver_t = VQESolver(vqe_options)\n",
+ "vqe_solver_t.build()\n",
+ "vqe_energy_t = vqe_solver_t.simulate()\n",
+ "print(\"\\n Lowest Triplet state\")\n",
+ "print(f\"VQE energy = {vqe_energy_t}\")\n",
+ "print(f\"CASCI energy = {FCISolver(mol_Li2_t).simulate()}\")\n",
+ "algorithm_resources[\"vqe_triplet_state\"] = vqe_solver_t.get_resources()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iXSSQBsvL8wr"
+ },
+ "source": [
+ "### 2.2 VQE Deflation \n",
+ "\n",
+ "Deflation can be used to gradually obtain higher and higher excited states, by applying an orthogonality penalty against all previous VQE calculations. This idea was introduced in [arXiv:2205.09203](https://arxiv.org/abs/2205.09203).\n",
+ "\n",
+ "This approach can be implented by using the deflation options built in the `VQESolver` class:\n",
+ "\n",
+ "- The keyword `\"deflation_circuits\"` allows the user to provide a list of circuits to use in the deflation process.\n",
+ "- Additionally, the keyword `\"deflation_coeff\"` allows a user to specify the weight in front of the penalty term. This coefficient must be larger than the difference in energy between the ground and the target excited state."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "background_save": true,
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "8XNANL08xPwb",
+ "outputId": "1add933d-26a9-4f6d-b942-8d43b50bbf91"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Excited state #1 \t VQE energy = -14.784036828632091\n",
+ "Excited state #2 \t VQE energy = -14.680196332828123\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Add initial VQE optimal circuit to the deflation circuits list\n",
+ "deflation_circuits = [vqe_solver.optimal_circuit.copy()]\n",
+ "\n",
+ "# Calculate first and second excited states by adding optimal circuits to deflation_circuits\n",
+ "for i in range(2):\n",
+ " vqe_options = {\"molecule\": mol_Li2, \"ansatz\": BuiltInAnsatze.UpCCGSD,\n",
+ " \"deflation_circuits\": deflation_circuits, \"deflation_coeff\": 0.4}\n",
+ " vqe_solver = VQESolver(vqe_options)\n",
+ " vqe_solver.build()\n",
+ " vqe_energy = vqe_solver.simulate()\n",
+ " print(f\"Excited state #{i+1} \\t VQE energy = {vqe_energy}\")\n",
+ " algorithm_resources[f\"vqe_deflation_state_{i+1}\"] = vqe_solver.get_resources()\n",
+ "\n",
+ " deflation_circuits.append(vqe_solver.optimal_circuit.copy())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gZVPYZHGL8wr"
+ },
+ "source": [
+ "The deflation above generated the singlet states. Sometimes it is useful to use a different reference state. In the next example of deflation, we use a reference state with 2 alpha electrons and 0 beta electrons to calculate the triplet state. The reference state is defined by alternating up then down ordering, which yields `{\"ref_state\": [1, 0, 1, 0]}` for 2 alpha electrons in 2 orbitals for this situation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "GUnTIo8HxPwb",
+ "outputId": "82c4f3bf-bfdb-40ba-f56f-a1ba74bb6ac0"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "VQE energy = -14.838766460607367\n"
+ ]
+ }
+ ],
+ "source": [
+ "vqe_options = {\"molecule\": mol_Li2, \"ansatz\": BuiltInAnsatze.UpCCGSD,\n",
+ " \"deflation_circuits\": deflation_circuits,\n",
+ " \"deflation_coeff\": 0.4, \"ref_state\": [1, 0, 1, 0]}\n",
+ "vqe_solver_triplet = VQESolver(vqe_options)\n",
+ "vqe_solver_triplet.build()\n",
+ "vqe_energy = vqe_solver_triplet.simulate()\n",
+ "print(f\"VQE energy = {vqe_energy}\")\n",
+ "algorithm_resources[f\"vqe_deflation_state_{3}\"] = vqe_solver_triplet.get_resources()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_odsQd-dL8ws"
+ },
+ "source": [
+ "This value is a great match for the triplet CASCI reference values we obtained earlier. We calculated all the excited states calculated using CASCI using deflation by running `VQESolver` 4 times.\n",
+ "\n",
+ "The `deflation_circuits` option is also available for the SA-VQE solver shown in another section of this notebook (`SA_VQESolver`), as well as ADAPT (`ADAPTSolver`)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uTRtGu2XL8ws"
+ },
+ "source": [
+ "### 2.3 Quantum Subspace Expansion \n",
+ "\n",
+ "Another way to obtain excited states is to define a pool of operators providing a good approximation to the excitations needed to represent the excited states from the ground state calculations produced by `VQESolver`. This idea was presented in [arXiv:1603.05681](https://arxiv.org/abs/1603.05681).\n",
+ "\n",
+ "For this example, we choose a pool of operators of the form $O_p=a_i^{\\dagger}a_j$.\n",
+ "\n",
+ "We then have to solve $FU = SUE$, where $F_{pq}=\\left<\\psi\\right|O_p^* H O_q\\left|\\psi\\right>$ and $S_{pq}=\\left<\\psi\\right|O_p^* O_q\\left|\\psi\\right>$.\n",
+ "\n",
+ "For simplicity here, we keep all wavefunction symmetry excitations. However, the matrix we need to diagonalize can be made smaller by only keeping excitations that respect the desired wavefunction symmetry of the excited state."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "oMEMRT1TxPwb"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from scipy.linalg import eigh\n",
+ "from openfermion.utils import hermitian_conjugated as hc\n",
+ "\n",
+ "from tangelo.toolboxes.operators import FermionOperator\n",
+ "from tangelo.toolboxes.qubit_mappings.mapping_transform import fermion_to_qubit_mapping as f2q_mapping\n",
+ "\n",
+ "# Generate all single excitations as qubit operators\n",
+ "op_list = list()\n",
+ "for i in range(2):\n",
+ " for j in range(i+1, 2):\n",
+ " op_list += [f2q_mapping(FermionOperator(((2*i, 1), (2*j, 0))), \"jw\")] #spin-up transition\n",
+ " op_list += [f2q_mapping(FermionOperator(((2*i+1, 1), (2*j+1, 0))), \"jw\")] #spin-down transition\n",
+ " op_list += [f2q_mapping(FermionOperator(((2*i+1, 1), (2*j, 0))), \"jw\")] #spin-up to spin-down\n",
+ " op_list += [f2q_mapping(FermionOperator(((2*i, 1), (2*j+1, 0))), \"jw\")] #spin-down to spin-up\n",
+ "\n",
+ "# Compute F and S matrices.\n",
+ "size_mat = len(op_list)\n",
+ "h = np.zeros((size_mat, size_mat))\n",
+ "s = np.zeros((size_mat, size_mat))\n",
+ "state_circuit = vqe_solver.optimal_circuit\n",
+ "for i, op1 in enumerate(op_list):\n",
+ " for j, op2 in enumerate(op_list):\n",
+ " h[i, j] = np.real(vqe_solver.backend.get_expectation_value(hc(op1)*vqe_solver.qubit_hamiltonian*op2, state_circuit))\n",
+ " s[i, j] = np.real(vqe_solver.backend.get_expectation_value(hc(op1)*op2, state_circuit))\n",
+ "\n",
+ "label = \"quantum_subspace_expansion\"\n",
+ "algorithm_resources[label] = vqe_solver.get_resources()\n",
+ "algorithm_resources[label][\"n_post_terms\"] = len(op_list)**2*algorithm_resources[label][\"qubit_hamiltonian_terms\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MrS38WBO2DBF"
+ },
+ "source": [
+ "After generating the matrices on the quantum computer. We need to perform the classical post-processing to obtain the energies by solving the $FU = SUE$ eigenvalue problem."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "DCQggLfFxPwb",
+ "outputId": "4512038b-4bc7-418a-d996-f9fd72f7addc"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Quantum Subspace Expansion energies: \n",
+ " [-14.83876646 -14.83876646 -14.83876646 -14.78403816]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Solve FU = SUE\n",
+ "e, v = eigh(h,s)\n",
+ "print(f\"Quantum Subspace Expansion energies: \\n {e}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YCqaM-2SL8ws"
+ },
+ "source": [
+ "We can see that we have obtained the correct energies for CASCI state A1g state 1, and A2 state 0 and 1. A1g state 1 was not recovered. We would therefore need to measure more excitations in $F$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SLJrouJXL8wt"
+ },
+ "source": [
+ "### 2.4 State-Averaged VQE \n",
+ "\n",
+ "Another method to obtain excited states is to use the State-Averaged VQE Solver (SA-VQE). SA-VQE minimizes the average energy of multiple orthogonal reference states using the same ansatz circuit. As the reference states are orthogonal, using the same circuit transformation (a unitary), results in final states that are also orthogonal. This idea can be found in [arXiv:2009.11417](https://arxiv.org/pdf/2009.11417.pdf).\n",
+ "\n",
+ "Here, we target singlet states only. This can be accomplished by adding a penalty term with `\"penalty_terms\": {\"S^2\": [2, 0]}`. This means that the target Hamiltonian to be minimized is $H = H_0 + 2 (\\hat{S}^2 - 0)^2$, where $H_0$ is the original molecular Hamiltonian."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "dBxaLp3sxPwb",
+ "outputId": "44b5e891-eb1d-4a06-90ef-65fb8961ce1a"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Singlet State 0 has energy -14.742180662780802\n",
+ "Singlet State 1 has energy -14.812125758504438\n",
+ "Singlet State 2 has energy -14.779540078255247\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tangelo.algorithms.variational import SA_VQESolver\n",
+ "\n",
+ "vqe_options = {\"molecule\": mol_Li2, \"ref_states\": [[1,1,0,0], [1,0,0,1], [0,0,1,1]],\n",
+ " \"weights\": [1, 1, 1], \"penalty_terms\": {\"S^2\": [2, 0]},\n",
+ " \"qubit_mapping\": \"jw\", \"ansatz\": BuiltInAnsatze.UpCCGSD,\n",
+ " }\n",
+ "vqe_solver = SA_VQESolver(vqe_options)\n",
+ "vqe_solver.build()\n",
+ "enernew = vqe_solver.simulate()\n",
+ "for i, energy in enumerate(vqe_solver.state_energies):\n",
+ " print(f\"Singlet State {i} has energy {energy}\")\n",
+ "\n",
+ "algorithm_resources[\"sa_vqe\"] = vqe_solver.get_resources()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kpLLy2N2L8wt"
+ },
+ "source": [
+ "The energies above are inaccurate, as the calculated states are restricted to linear combinations of the three lowest singlet states. We can use MC-VQE to generate the exact eigenvectors, as shown in the next section.\n",
+ "\n",
+ "However, the cell below shows the $\\hat{S}^2$ expectation value is nearly zero for all states, so they are all singlet as expected when using the penalty term."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "wKI5LzTPxPwb",
+ "outputId": "6369ac62-b2f6-4679-b35d-fa386246c0f8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "State 0 has S^2 = 3.5292665678809954e-08\n",
+ "State 1 has S^2 = 2.0223931609386625e-06\n",
+ "State 2 has S^2 = 7.838162452422637e-09\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tangelo.toolboxes.ansatz_generator.fermionic_operators import spin2_operator\n",
+ "\n",
+ "s2op = f2q_mapping(spin2_operator(2), \"jw\")\n",
+ "for i in range(3):\n",
+ " print(f\"State {i} has S^2 = {vqe_solver.backend.get_expectation_value(s2op, vqe_solver.reference_circuits[i]+vqe_solver.optimal_circuit)}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G6afws2QL8wt"
+ },
+ "source": [
+ "### 2.5 Multistate, contracted VQE (MC-VQE) \n",
+ "\n",
+ "To obtain the energies of the individual states, we can use multistate contracted VQE (MC-VQE), as introduced in [arXiv:1901.01234](https://arxiv.org/abs/1901.01234). This process defines a small matrix by measuring the Hamiltonian expectation values of $(\\left|\\theta_i\\right>+\\left|\\theta_j\\right>)/\\sqrt{2}$ and $(\\left|\\theta_i\\right>-\\left|\\theta_j\\right>)/\\sqrt{2}$ for all combinations of our final states ($\\left|\\theta_i\\right>$) resulting from the SA-VQE procedure.\n",
+ "\n",
+ "In general, the reference states are simple occupations so generating $(\\left|\\theta_i\\right>+\\left|\\theta_j\\right>)/\\sqrt{2}$ and $(\\left|\\theta_i\\right>-\\left|\\theta_j\\right>)/\\sqrt{2}$ by hand should be \"fairly straightforward\". In this notebook, we use Tangelo to obtain these statevectors and then generate the expectation values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "nKUl43KZxPwb"
+ },
+ "outputs": [],
+ "source": [
+ "# Generate individual statevectors\n",
+ "ref_svs = list()\n",
+ "for circuit in vqe_solver.reference_circuits:\n",
+ " _, sv = vqe_solver.backend.simulate(circuit, return_statevector=True)\n",
+ " ref_svs.append(sv)\n",
+ "\n",
+ "# Generate Equation (2) using equation (4) and (5) of arXiv:1901.01234\n",
+ "h_theta_theta = np.zeros((3,3))\n",
+ "for i, sv1 in enumerate(ref_svs):\n",
+ " for j, sv2 in enumerate(ref_svs):\n",
+ " if i != j:\n",
+ " sv_plus = (sv1 + sv2)/np.sqrt(2)\n",
+ " sv_minus = (sv1 - sv2)/np.sqrt(2)\n",
+ " exp_plus = vqe_solver.backend.get_expectation_value(vqe_solver.qubit_hamiltonian, vqe_solver.optimal_circuit, initial_statevector=sv_plus)\n",
+ " exp_minus = vqe_solver.backend.get_expectation_value(vqe_solver.qubit_hamiltonian, vqe_solver.optimal_circuit, initial_statevector=sv_minus)\n",
+ " h_theta_theta[i, j] = (exp_plus-exp_minus)/2\n",
+ " else:\n",
+ " h_theta_theta[i, j] = vqe_solver.state_energies[i]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "10myRMdfHJoJ"
+ },
+ "source": [
+ "Accurate energies can be recovered by solving the resulting eigenproblem classically:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "q1po_RIxxPwc",
+ "outputId": "09041799-e45d-4251-ab7d-b6c8e33d9c1c"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Singlet State 0 \t MC-VQE energy = -14.869616874285468\n",
+ "Singlet State 1 \t MC-VQE energy = -14.784034425090708\n",
+ "Singlet State 2 \t MC-VQE energy = -14.680195200164317\n"
+ ]
+ }
+ ],
+ "source": [
+ "e, _ = np.linalg.eigh(h_theta_theta)\n",
+ "for i, energy in enumerate(e):\n",
+ " print(f\"Singlet State {i} \\t MC-VQE energy = {energy}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JtJADlmZL8wu"
+ },
+ "source": [
+ "We can see that these singlet energies are all close to the exact answer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IrcmQn8cL8wu"
+ },
+ "source": [
+ "#### Using StateVector for MC-VQE\n",
+ "The code below can be used obtain the same MC-VQE result by using `StateVector` to automatically generate circuits for $(\\left|\\theta_i\\right>+\\left|\\theta_j\\right>)/\\sqrt{2}$ and $(\\left|\\theta_i\\right>-\\left|\\theta_j\\right>)/\\sqrt{2}$. However, the circuits created by StateVector are generally inefficient and one should try to create the circuits that generate these states by hand if running on a real quantum device."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Tqc7a0dmxPwc"
+ },
+ "outputs": [],
+ "source": [
+ "from tangelo.linq.helpers import StateVector\n",
+ "\n",
+ "# Generate individual statevectors\n",
+ "ref_svs = list()\n",
+ "for state in vqe_solver.ref_states:\n",
+ " sv = np.zeros(2**4)\n",
+ " # Generate bitstring representation of each ref_state and populate that position in the statevector\n",
+ " bitstring = \"\".join([str(i) for i in reversed(state)])\n",
+ " sv[int(bitstring, base=2)] = 1\n",
+ " ref_svs.append(sv)\n",
+ "\n",
+ "# Generate Equation (2) using equation (4) and (5) of arXiv:1901.01234\n",
+ "h_theta_theta = np.zeros((len(ref_svs), len(ref_svs)))\n",
+ "for i, sv1 in enumerate(ref_svs):\n",
+ " for j, sv2 in enumerate(ref_svs):\n",
+ " if i != j:\n",
+ " sv_plus = (sv1 + sv2)/np.sqrt(2)\n",
+ " sv_plus = StateVector(sv_plus)\n",
+ " ref_circ_plus = sv_plus.initializing_circuit()\n",
+ " exp_plus = vqe_solver.backend.get_expectation_value(vqe_solver.qubit_hamiltonian, ref_circ_plus + vqe_solver.optimal_circuit)\n",
+ "\n",
+ " sv_minus = (sv1 - sv2)/np.sqrt(2)\n",
+ " sv_minus = StateVector(sv_minus)\n",
+ " ref_circ_minus = sv_minus.initializing_circuit()\n",
+ " exp_minus = vqe_solver.backend.get_expectation_value(vqe_solver.qubit_hamiltonian, ref_circ_minus + vqe_solver.optimal_circuit)\n",
+ "\n",
+ " h_theta_theta[i, j] = (exp_plus-exp_minus)/2\n",
+ " else:\n",
+ " h_theta_theta[i, j] = vqe_solver.state_energies[i]\n",
+ "\n",
+ "algorithm_resources[\"mc_vqe\"] = vqe_solver.get_resources()\n",
+ "algorithm_resources[\"mc_vqe\"][\"n_post_terms\"] = len(ref_svs)**2*algorithm_resources[\"mc_vqe\"][\"qubit_hamiltonian_terms\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "S_TP1ww5xPwc",
+ "outputId": "4f3b4973-d48d-4124-c912-9ea0492c6185"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Singlet State 0 \t MC-VQE energy = -14.869616874285464\n",
+ "Singlet State 1 \t MC-VQE energy = -14.784034425090713\n",
+ "Singlet State 2 \t MC-VQE energy = -14.680195200164313\n"
+ ]
+ }
+ ],
+ "source": [
+ "e, _ = np.linalg.eigh(h_theta_theta)\n",
+ "for i, energy in enumerate(e):\n",
+ " print(f\"Singlet State {i} \\t MC-VQE energy = {energy}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "p6odrzVoL8wv"
+ },
+ "source": [
+ "### 2.6 State-Averaged VQE with deflation \n",
+ "We can obtain the final excited state by using deflation for the three singlet states above and removing the penalty term. We define a reference state with `\"ref_states\": [[1, 0, 1, 0]]` that better targets the remaining triplet state. We can revert back to the UCCSD ansatz for this state as we do not need as expressive an ansatz anymore."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "RnZ1_QYFxPwf",
+ "outputId": "e684c58c-2303-4c0d-d58c-e3322d4e79ec"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Triplet State 0 has energy -14.838766460607367\n"
+ ]
+ }
+ ],
+ "source": [
+ "vqe_options = {\"molecule\": mol_Li2, \"ref_states\": [[1, 0, 1, 0]],\n",
+ " \"weights\": [1], \"deflation_circuits\": [vqe_solver.reference_circuits[i]+vqe_solver.optimal_circuit for i in range(3)],\n",
+ " \"qubit_mapping\": \"jw\", \"ansatz\": BuiltInAnsatze.UCCSD,\n",
+ " }\n",
+ "vqe_solver_deflate = SA_VQESolver(vqe_options)\n",
+ "vqe_solver_deflate.build()\n",
+ "enernew = vqe_solver_deflate.simulate()\n",
+ "\n",
+ "for i, energy in enumerate(vqe_solver_deflate.state_energies):\n",
+ " print(f\"Triplet State {i} has energy {energy}\")\n",
+ "\n",
+ "algorithm_resources[f\"sa_vqe_deflation\"] = vqe_solver_deflate.get_resources()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JrU59nB3L8wv"
+ },
+ "source": [
+ "This is the correct triplet state energy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FNeQXqbIL8wv"
+ },
+ "source": [
+ "### 2.7 State-Averaged Orbital-Optimized VQE \n",
+ "\n",
+ "This performs the equivalent of a CASSCF calculation using a quantum computer. This approach runs multiple iterations comprised of the two following steps:\n",
+ "\n",
+ "- SA-VQE calculation\n",
+ "- orbital optimization\n",
+ "\n",
+ "These iterations are called by using the `iterate()` call. The `simulate()` method from `SA_OO_Solver` only performs a State-Averated VQE simulation. The reference for this method is [arXiv:2009.11417](https://arxiv.org/pdf/2009.11417.pdf)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "N7W6Iv99xPwf",
+ "outputId": "e7839591-ce72-42d0-9231-4b5febaaf0d6"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "State 0 has energy -14.875599348504345\n",
+ "State 1 has energy -14.851789148206684\n"
+ ]
+ }
+ ],
+ "source": [
+ "from tangelo.algorithms.variational import SA_OO_Solver\n",
+ "\n",
+ "mol_Li2_nosym = SQMol(li2, q=0, spin=0, basis='6-31g(d,p)',\n",
+ " frozen_orbitals=fo, symmetry=False)\n",
+ "vqe_options = {\"molecule\": mol_Li2_nosym, \"ref_states\": [[1,1,0,0], [1,0,1,0]],\n",
+ " \"weights\": [1, 1],\n",
+ " \"qubit_mapping\": \"jw\", \"ansatz\": BuiltInAnsatze.UpCCGSD, \"ansatz_options\": {\"k\": 2}\n",
+ " }\n",
+ "vqe_solver = SA_OO_Solver(vqe_options)\n",
+ "vqe_solver.build()\n",
+ "enernew = vqe_solver.iterate()\n",
+ "for i, energy in enumerate(vqe_solver.state_energies):\n",
+ " print(f\"State {i} has energy {energy}\")\n",
+ "\n",
+ "algorithm_resources[\"sa_oo_vqe\"] = vqe_solver.get_resources()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PD3cQc1GL8ww"
+ },
+ "source": [
+ "Comparing the `SA_OO_VQE` solution to CASSCF calculations from a library such as pyscf shows similar results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6uwKJ2vJxPwf",
+ "outputId": "b864fe1b-0804-4a2b-eefd-d350f41afb8f"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CASSCF energy = -14.8636942982907\n",
+ "CASCI E = -14.8636942982907 E(CI) = -0.569133524430852 S^2 = 1.0000000\n",
+ "CASCI state-averaged energy = -14.8636942982907\n",
+ "CASCI energy for each state\n",
+ " State 0 weight 0.5 E = -14.8756048777217 S^2 = 0.0000000\n",
+ " State 1 weight 0.5 E = -14.8517837188597 S^2 = 2.0000000\n"
+ ]
+ }
+ ],
+ "source": [
+ "mol_Li2_no_sym_copy = SQMol(li2, q=0, spin=0, basis='6-31g(d,p)',\n",
+ " frozen_orbitals=fo, symmetry=False)\n",
+ "mc = mcscf.CASSCF(mol_Li2_no_sym_copy.mean_field, 2, 2).state_average([0.5, 0.5])\n",
+ "energy = mc.kernel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "N7ZIjE-ML8ww"
+ },
+ "source": [
+ "`SA_OO_Solver` has optimized the orbitals in `mol_Li2_nosym` to minimize the average energy of the states above. We can then use the code below to output the optimized molecular orbitals as cube files and compare to the unoptimized orbitals from the top of the notebook.\n",
+ "\n",
+ "```python\n",
+ "from pyscf.tools import cubegen\n",
+ "# loop over active orbitals i.e. 2, 3\n",
+ "for i in [2, 3]:\n",
+ " cubegen.orbital(mol_Li2_nosym.to_pyscf(basis = mol_Li2_nosym.basis), f'li2_{i+1}_opt.cube', mol_Li2_nosym.mean_field.mo_coeff[:, i])\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_uXgf8A7L8ww"
+ },
+ "source": [
+ "Using [Avogadro](https://avogadro.cc/) to generate the two figures below with the .cube files outputted above, we see that the original fourth molecular orbital and the optimized fourth molecular orbital look very different:\n",
+ "\n",
+ "| \n",
+ " Original molecular orbital | \n",
+ " \n",
+ " Optimized molecular orbital | \n",
+ "
\n",
+ " ![](\"https://github.com/sandbox-quantum/Tangelo-Examples/blob/main/examples/img/li2_4.png?raw=1\") \n",
+ " | \n",
+ " \n",
+ " ![](\"https://github.com/sandbox-quantum/Tangelo-Examples/blob/main/examples/img/li2_4_opt.png?raw=1\") \n",
+ " | \n",
+ "
![](\"https://github.com/sandbox-quantum/Tangelo-Examples/blob/main/examples/img/rodeo_1000.png?raw=1\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RUwlEQ-AL8wz"
+ },
+ "source": [
+ "## 4. Closing words \n",
+ "\n",
+ "We have shown a few of the many different algorithms that can be used to calculate excited states using Tangelo. Unlike ground states, the use of variational methods requires either penalizing against previously calculated states or the optimization of a collection of orthogonal states. Outside of variational methods, we have shown a few Hamiltonian simulation based algorithms to calculate excited states.\n",
+ "\n",
+ "But quantum resource requirements are an important aspect of quantum algorithm design: let's have a look at the resources required for each algorithm we tried on our use case. In particular, the following metrics:\n",
+ "\n",
+ "- `# measurements basis` is the number of distinct measurements for each function evaluation in the variational optimization process.\n",
+ "- `# CNOT gates` is the number of CNOT gates in each circuit.\n",
+ "- `# post measurements basis` is the number of measurements needed to successfully post-process the output of the algorithm.\n",
+ "\n",
+ "We note that `# CNOT gates` for each variational algorithm could be improved greatly if an algorithm such as ADAPT-VQE was used to create an ansatz. Similarly, `# CNOT gates` could be reduced for the time-evolution algorithms with more advanced approaches such as qubitization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "JGtwnCGSxPwg",
+ "outputId": "c0cf851d-427c-4b5a-f34e-397770e8539b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Algorithm # measurements # CNOT gates # post measurements \n",
+ "vqe_ground_state 15 64 0 \n",
+ "vqe_triplet_state 15 128 0 \n",
+ "vqe_deflation_state_1 16 192 0 \n",
+ "vqe_deflation_state_2 17 192 0 \n",
+ "vqe_deflation_state_3 18 192 0 \n",
+ "quantum_subspace_expansion 18 192 288 \n",
+ "sa_vqe 60 128 0 \n",
+ "mc_vqe 60 128 540 \n",
+ "sa_vqe_deflation 18 192 0 \n",
+ "sa_oo_vqe 30 128 0 \n",
+ "mrsqk 0 72 16 \n",
+ "rodeo 0 320 30 \n"
+ ]
+ }
+ ],
+ "source": [
+ "format = \"{:<40} {:<20} {:<20} {:<20}\"\n",
+ "print(format.format(\"Algorithm\", \"# measurements\", \"# CNOT gates\", \"# post measurements\"))\n",
+ "for method, resources in algorithm_resources.items():\n",
+ " print(format.format(method, resources[\"qubit_hamiltonian_terms\"], resources[\"circuit_2qubit_gates\"], resources.get(\"n_post_terms\", 0)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6cT7h0NhmNEt"
+ },
+ "source": [
+ "These are the resource requirements that came out from calculations on our small Li$_2$ use case in minimal basis set, featuring two 2 electrons in 2 orbitals.\n",
+ "\n",
+ "But what of BODIPY ?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "5zmGtT3exPwg",
+ "outputId": "a0708059-636a-4b50-fc65-7e1d09c1957f"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Active electrons = 63\n",
+ "Active orbitals = 70\n"
+ ]
+ }
+ ],
+ "source": [
+ "bodipy = SQMol(\"data/bodipy.xyz\", q=0, spin=0, basis=\"sto-3g\")\n",
+ "print(f\"Active electrons = {bodipy.n_active_mos}\")\n",
+ "print(f\"Active orbitals = {bodipy.n_active_electrons}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "35WSxIsRL8w0"
+ },
+ "source": [
+ "Whereas we did calculations with 2 electrons in 2 orbitals, the full calculation of BODIPY in the minimal STO-3G basis would entail 63 electrons in 70 orbitals, with the core electrons frozen. The number of qubits needed to represent this would be 140 for the Jordan-Wigner mapping, compared to the 4 (+1 ansatz for the Hamiltonian simulation algorithms) qubits used in this notebook. [J. Chem. Theory. Comput. 2015, 11, 6](https://pubs.acs.org/doi/10.1021/ct500775r) showed reasonable results using CASSCF with 12 electrons in 11 orbitals, which would be a 22-qubit problem using the Jordan-Wigner mapping. Another issue is the number of CNOT gates, which would be much larger for the full 22-qubit problem than shown in the table for our use case.\n",
+ "\n",
+ "This system is orders or magnitude harder, and emphasize how it is crucial that we design and choose approaches that require as little quantum computational resources as possible to make such use cases tractable in the future.\n",
+ "\n",
+ "There is still much work to be done to efficiently calculate excited states using quantum computers, and allow us to tackle more industrially-relevant use cases.\n",
+ "\n",
+ "What will you do with Tangelo?"
+ ]
}
- ],
- "source": [
- "format = \"{:<40} {:<20} {:<20} {:<20}\"\n",
- "print(format.format(\"Algorithm\", \"# measurements\", \"# CNOT gates\", \"# post measurements\"))\n",
- "for method, resources in algorithm_resources.items():\n",
- " print(format.format(method, resources[\"qubit_hamiltonian_terms\"], resources[\"circuit_2qubit_gates\"], resources.get(\"n_post_terms\", 0)))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "6cT7h0NhmNEt"
- },
- "source": [
- "These are the resource requirements that came out from calculations on our small Li$_2$ use case in minimal basis set, featuring two 2 electrons in 2 orbitals.\n",
- "\n",
- "But what of BODIPY ?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 27,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Active electrons = 63\n",
- "Active orbitals = 70\n"
- ]
+ ],
+ "metadata": {
+ "colab": {
+ "provenance": []
+ },
+ "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.10.0"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "95050af2697fca56ed7491a4fb0b04c1282c0de0a7e0a7cacd318a8297b0b1d8"
+ }
}
- ],
- "source": [
- "bodipy = SQMol(\"data/bodipy.xyz\", q=0, spin=0, basis=\"sto-3g\")\n",
- "print(f\"Active electrons = {bodipy.n_active_mos}\")\n",
- "print(f\"Active orbitals = {bodipy.n_active_electrons}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "35WSxIsRL8w0"
- },
- "source": [
- "Whereas we did calculations with 2 electrons in 2 orbitals, the full calculation of BODIPY in the minimal STO-3G basis would entail 63 electrons in 70 orbitals, with the core electrons frozen. The number of qubits needed to represent this would be 140 for the Jordan-Wigner mapping, compared to the 4 (+1 ansatz for the Hamiltonian simulation algorithms) qubits used in this notebook. [J. Chem. Theory. Comput. 2015, 11, 6](https://pubs.acs.org/doi/10.1021/ct500775r) showed reasonable results using CASSCF with 12 electrons in 11 orbitals, which would be a 22-qubit problem using the Jordan-Wigner mapping. Another issue is the number of CNOT gates, which would be much larger for the full 22-qubit problem than shown in the table for our use case. \n",
- "\n",
- "This system is orders or magnitude harder, and emphasize how it is crucial that we design and choose approaches that require as little quantum computational resources as possible to make such use cases tractable in the future.\n",
- "\n",
- "There is still much work to be done to efficiently calculate excited states using quantum computers, and allow us to tackle more industrially-relevant use cases.\n",
- "\n",
- "What will you do with Tangelo? "
- ]
- }
- ],
- "metadata": {
- "colab": {
- "collapsed_sections": [],
- "name": "excited_states.ipynb",
- "provenance": []
- },
- "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.10.0"
},
- "vscode": {
- "interpreter": {
- "hash": "95050af2697fca56ed7491a4fb0b04c1282c0de0a7e0a7cacd318a8297b0b1d8"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat": 4,
+ "nbformat_minor": 0
}