├── .gitignore ├── LICENSE ├── README.md ├── Session1 Notebook └── Hamiltonian Simulation.ipynb ├── Session2 Notebook └── 1DPoisson+VQE.ipynb └── slides.pdf /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | *.py[cod] 3 | *$py.class 4 | # Byte-compiled / optimized / DLL files 5 | .idea 6 | .DS_Store 7 | .vscode/ 8 | __pycache__/ 9 | *.py[cod] 10 | *$py.class 11 | 12 | 13 | # C extensions 14 | *.so 15 | 16 | # Distribution / packaging 17 | .Python 18 | build/ 19 | develop-eggs/ 20 | dist/ 21 | downloads/ 22 | eggs/ 23 | .eggs/ 24 | lib/ 25 | lib64/ 26 | parts/ 27 | sdist/ 28 | var/ 29 | wheels/ 30 | share/python-wheels/ 31 | *.egg-info/ 32 | .installed.cfg 33 | *.egg 34 | MANIFEST 35 | 36 | # PyInstaller 37 | # Usually these files are written by a python script from a template 38 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 39 | *.manifest 40 | *.spec 41 | 42 | # Installer logs 43 | pip-log.txt 44 | pip-delete-this-directory.txt 45 | 46 | # Unit test / coverage reports 47 | htmlcov/ 48 | .tox/ 49 | .nox/ 50 | .coverage 51 | .coverage.* 52 | .cache 53 | nosetests.xml 54 | coverage.xml 55 | *.cover 56 | *.py,cover 57 | .hypothesis/ 58 | .pytest_cache/ 59 | cover/ 60 | 61 | # Translations 62 | *.mo 63 | *.pot 64 | 65 | # Django stuff: 66 | *.log 67 | local_settings.py 68 | db.sqlite3 69 | db.sqlite3-journal 70 | 71 | # Flask stuff: 72 | instance/ 73 | .webassets-cache 74 | 75 | # Scrapy stuff: 76 | .scrapy 77 | 78 | # Sphinx documentation 79 | docs/_build/ 80 | 81 | # PyBuilder 82 | .pybuilder/ 83 | target/ 84 | 85 | # Jupyter Notebook 86 | .ipynb_checkpoints 87 | 88 | # IPython 89 | profile_default/ 90 | ipython_config.py 91 | 92 | # pyenv 93 | # For a library or package, you might want to ignore these files since the code is 94 | # intended to run in multiple environments; otherwise, check them in: 95 | # .python-version 96 | 97 | # pipenv 98 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 99 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 100 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 101 | # install all needed dependencies. 102 | #Pipfile.lock 103 | 104 | # poetry 105 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 106 | # This is especially recommended for binary packages to ensure reproducibility, and is more 107 | # commonly ignored for libraries. 108 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 109 | #poetry.lock 110 | 111 | # pdm 112 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 113 | #pdm.lock 114 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 115 | # in version control. 116 | # https://pdm.fming.dev/#use-with-ide 117 | .pdm.toml 118 | 119 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 120 | __pypackages__/ 121 | 122 | # Celery stuff 123 | celerybeat-schedule 124 | celerybeat.pid 125 | 126 | # SageMath parsed files 127 | *.sage.py 128 | 129 | # Environments 130 | .env 131 | .venv 132 | env/ 133 | venv/ 134 | ENV/ 135 | env.bak/ 136 | venv.bak/ 137 | 138 | # Spyder project settings 139 | .spyderproject 140 | .spyproject 141 | 142 | # Rope project settings 143 | .ropeproject 144 | 145 | # mkdocs documentation 146 | /site 147 | 148 | # mypy 149 | .mypy_cache/ 150 | .dmypy.json 151 | dmypy.json 152 | 153 | # Pyre type checker 154 | .pyre/ 155 | 156 | # pytype static type analyzer 157 | .pytype/ 158 | 159 | # Cython debug symbols 160 | cython_debug/ 161 | 162 | # PyCharm 163 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 164 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 165 | # and can be added to the global gitignore or merged into this file. For a more nuclear 166 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 167 | #.idea/ 168 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 Computational Physics @ GT CSE 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # TUT27 — Solving Partial Differential Equations (PDEs) with Quantum Computers 2 | 3 | [Zhixin Song, Georgia Institute of Technology, USA](https://www.linkedin.com/in/kaminotesf524/) \ 4 | [Spencer Bryngelson, Georgia Institute of Technology, USA](https://cse.gatech.edu/people/spencer-bryngelson) 5 | 6 | 7 | 8 | **Date:** Fri, Sep 22, 2023 \ 9 | **Time:** Between 10:00-14:30 Pacific Time (PDT) — UTC-7 \ 10 | **Duration:** 3 hours (2 x 1.5 hours) 11 | 12 | 13 | 14 | 15 | Many important systems in nature are described by the space-time evolution of physical quantities using partial differential equations (PDEs), which can range from the microscale, such as the Schrödinger equation in quantum systems, to the macroscale, such as the Navier–Stokes equations of fluid dynamics. Thus, efficient PDE solvers are critical to understanding and solving many science and engineering problems. Quantum algorithms have been proposed to solve PDEs and verified on small-scale simulators. For long-term PDE solvers, the Harrow-Hassidim-Lloyd (HHL) algorithm could bring an exponential speedup over classical methods. For the near-term quantum hardware, variational quantum algorithms such as the Variational Quantum Linear Solver (VQLS) are applied to solve PDEs. In this tutorial, we will introduce users to QPDE-Benchmark, a new programming toolkit, powered by a set of quantum PDE solvers, that enable a user to more seamlessly test and improve quantum solvers for various PDEs. More specifically, we will show users how to solve the Schrödinger, Wave, and Poisson equation on near-term quantum computers using Hamiltonian simulation, VQLS and Variational Quantum Eigensolver (VQE). 16 | 17 | 18 | 19 | **Note:** Session 1 notebook is based on IBM Open Science Prize 2021. Please check this [repo](https://github.com/qiskit-community/open-science-prize-2021) for more details and advanced technique to enhance fidelity of Hamiltonian simulation on IBMQ's hardware. 20 | 21 | -------------------------------------------------------------------------------- /Session1 Notebook/Hamiltonian Simulation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "852ab4ac-e501-4694-bf67-90cd4122140e", 6 | "metadata": {}, 7 | "source": [ 8 | "# 1 Introduction\n", 9 | "\n", 10 | "### 1-1 Quantum Simulation\n", 11 | "One of the leading uses for quantum computers will be to simulate quantum systems such as molecules or engineered materials. Actually executing a quantum simulation on a current quantum computer, however, can be difficult and error prone. Your objective for this tutorial is to significantly improve the state-of-the-art for quantum simulation (details in Section 2).\n", 12 | "\n", 13 | "The quantum system you will simulate is a quantum spin-1/2 model, where each qubit represents a quantum [spin-1/2](https://en.wikipedia.org/wiki/Spin-1/2) particle in a 1D chain. Quantum spin models have some amazing properties and uses. Computationally speaking, [certain optimization problems can be mapped](https://arxiv.org/pdf/1712.05771.pdf) to spin models and hence minimized on a quantum computer. Physically speaking, spin models show a variety of quantum behavior such as large entangled states, quantum phases of matter, quantum many-body affects, and many other open questions in physics research.\n", 14 | "\n", 15 | "There are many different spin models, but we will focus on the [$XXX$ Heisenberg spin model](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model#XXX_model). Though it is not as well known as the [transverse-field Ising model](https://en.wikipedia.org/wiki/Transverse-field_Ising_model), the $XXX$ Heisenberg model is of practical and theoretical interest. It can also be difficult to simulate, which is where you come in.\n", 16 | "\n", 17 | "The notebook is organized as follows:\n", 18 | "1) Section 1 (labeled 1-X) provides you with brief introductions to the $XXX$ Heisenberg model, time evolving a Hamiltonian, and decomposing a time evolution operator into gates for a quantum computer to execute.\n", 19 | "2) Section 2 (labeled 2-X) outlines the specific requirements and boundaries associated with completing the tutorial. Continuing from Section 1, the notebook shows an example solution." 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "id": "d1548b05-e691-40a5-8b35-c0eaa87a2a72", 26 | "metadata": { 27 | "ExecuteTime": { 28 | "end_time": "2023-09-22T18:52:11.154047Z", 29 | "start_time": "2023-09-22T18:52:10.083992Z" 30 | } 31 | }, 32 | "outputs": [], 33 | "source": [ 34 | "import numpy as np\n", 35 | "import matplotlib.pyplot as plt\n", 36 | "plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts\n", 37 | "\n", 38 | "# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)\n", 39 | "from qiskit.opflow import Zero, One, I, X, Y, Z\n", 40 | "\n", 41 | "# Suppress warnings\n", 42 | "import warnings\n", 43 | "warnings.filterwarnings('ignore')" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "id": "c764af20-017f-4209-9483-4f89f10cb562", 49 | "metadata": {}, 50 | "source": [ 51 | "### 1-2 The $XXX$ Heisenberg Spin Model\n", 52 | "\n", 53 | "To simulate a quantum system, we first need to define how the quantum particles that make up the system interact with each other. In quantum physics, this is done by defining a [Hamiltonian operator](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)). For this tutorial, you will work with the $XXX$ Heisenberg Hamiltonian $H_{\\text{Heis}}$ as defined below\n", 54 | "\n", 55 | "$$\n", 56 | "\\begin{equation}\n", 57 | "H_{\\text{Heis}} = \\sum_{\\langle ij \\rangle}^{N} J \\left(\\sigma_x^{(i)}\\sigma_x^{(j)} + \\sigma_y^{(i)}\\sigma_y^{(j)} + \\sigma_z^{(i)}\\sigma_z^{(j)}\\right).\n", 58 | "\\end{equation}\n", 59 | "$$\n", 60 | "\n", 61 | "$N$ is the number of spin-1/2 particles in model. The operators $\\sigma_x$, $\\sigma_y$, and $\\sigma_z$ are [Pauli operators](https://en.wikipedia.org/wiki/Pauli_matrices) where the $i$ and $j$ superscripts label which qubit they act on. For example, $\\sigma_x^{(1)}$ would be the $\\sigma_x$ operator acting on only qubit 1 (which is the 2nd qubit since indexing starts at 0). This version of the general Heisenberg spin model is called $XXX$ because the same $J$ value multiplies each pair of Pauli operators. The sum notation $\\langle ij \\rangle$ means the sum is over nearest neighbors (only qubits next to each other interact), and $J$ is the interaction strength, which we will set $J=1$.\n", 62 | "\n", 63 | "You will work with the explicit case of $N=3$ with the 3 spins arranged in a line. Written out fully, the Hamiltonian is\n", 64 | "$$\n", 65 | "H_{\\text{Heis3}} = \\sigma_x^{(0)}\\sigma_x^{(1)} + \\sigma_x^{(1)}\\sigma_x^{(2)} + \\sigma_y^{(0)}\\sigma_y^{(1)} + \\sigma_y^{(1)}\\sigma_y^{(2)} + \\sigma_z^{(0)}\\sigma_z^{(1)} + \\sigma_z^{(1)}\\sigma_z^{(2)}.\n", 66 | "$$\n", 67 | "Now that we have a Hamiltonian ($H_{\\text{Heis3}}$), we can use it to determine how the quantum system of 3 spin-1/2 particles changes in time.\n", 68 | "\n", 69 | "*See the supplementary material for further details on $H_{\\text{Heis}}$, $H_{\\text{Heis3}}$ and its matrix repsentation.*" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 2, 75 | "id": "e6d371fd-f5c4-446a-83f4-ac7593fdcee1", 76 | "metadata": { 77 | "ExecuteTime": { 78 | "end_time": "2023-09-22T18:52:13.395376Z", 79 | "start_time": "2023-09-22T18:52:13.389410Z" 80 | } 81 | }, 82 | "outputs": [], 83 | "source": [ 84 | "# Returns the matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line\n", 85 | "def H_heis3():\n", 86 | " # Interactions (I is the identity matrix; X, Y, and Z are Pauli matricies; ^ is a tensor product)\n", 87 | " XXs = (I^X^X) + (X^X^I)\n", 88 | " YYs = (I^Y^Y) + (Y^Y^I)\n", 89 | " ZZs = (I^Z^Z) + (Z^Z^I)\n", 90 | " \n", 91 | " # Sum interactions\n", 92 | " H = XXs + YYs + ZZs\n", 93 | " \n", 94 | " # Return Hamiltonian\n", 95 | " return H" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "id": "35323a1f-9aac-493a-87a8-116c3b7980ca", 101 | "metadata": {}, 102 | "source": [ 103 | "### 1-3 Time Evolution\n", 104 | "\n", 105 | "Knowing the Hamiltonian, we can determine how quantum states of that system evolve in time by solving the [Schrödinger equation](https://en.wikipedia.org/wiki/Schrödinger_equation)\n", 106 | "$$\n", 107 | "i\\hbar \\dfrac{d}{dt}|\\psi(t)\\rangle = H |\\psi(t)\\rangle\n", 108 | "$$\n", 109 | "\n", 110 | "For simplicity, let's set $\\hbar = 1$. We know that the Hamiltonian $H_{\\text{heis3}}$ does not change in time, so the solution to the Schrödinger equation is an exponential of the Hamiltonian operator\n", 111 | "$$\n", 112 | "\\begin{align}\n", 113 | "U_{\\text{Heis3}}(t) &= e^{-it H_\\text{Heis3}} = \\exp\\left(-it H_\\text{Heis3}\\right) \\\\\n", 114 | "U_{\\text{Heis3}}(t) &= \\exp\\left[-it \\sum_{\\langle ij \\rangle}^{N=3} \\left(\\sigma_x^{(i)}\\sigma_x^{(j)} + \\sigma_y^{(i)}\\sigma_y^{(j)} + \\sigma_z^{(i)}\\sigma_z^{(j)}\\right) \\right] \\\\\n", 115 | "U_{\\text{Heis3}}(t) &= \\exp\\left[-it \\left(\\sigma_x^{(0)}\\sigma_x^{(1)} + \\sigma_x^{(1)}\\sigma_x^{(2)} + \\sigma_y^{(0)}\\sigma_y^{(1)} + \\sigma_y^{(1)}\\sigma_y^{(2)} + \\sigma_z^{(0)}\\sigma_z^{(1)} + \\sigma_z^{(1)}\\sigma_z^{(2)}\\right) \\right]\n", 116 | "\\end{align}\n", 117 | "$$.\n", 118 | "\n", 119 | "Now that we have the time evolution operator $U_{\\text{Heis3}}(t)$, we can simulate changes in a state of the system ($|\\psi(t)\\rangle$) over time $|\\psi(t)\\rangle = U_{\\text{Heis3}}(t)|\\psi(t=0)\\rangle$. \n", 120 | "\n", 121 | "*See the supplementary material for more information on exponentiating an operator or matrix.*" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 3, 127 | "id": "ccdedbc8-f335-468c-9db5-b594aa2e50bd", 128 | "metadata": { 129 | "ExecuteTime": { 130 | "end_time": "2023-09-22T18:52:15.079433Z", 131 | "start_time": "2023-09-22T18:52:15.073440Z" 132 | } 133 | }, 134 | "outputs": [], 135 | "source": [ 136 | "# Returns the matrix representation of U_heis3(t) for a given time t assuming an XXX Heisenberg Hamiltonian for 3 spins-1/2 particles in a line\n", 137 | "def U_heis3(t):\n", 138 | " # Compute XXX Hamiltonian for 3 spins in a line\n", 139 | " H = H_heis3()\n", 140 | " \n", 141 | " # Return the exponential of -i multipled by time t multipled by the 3 spin XXX Heisenberg Hamilonian \n", 142 | " return (t * H).exp_i()" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "id": "1668a459-1c19-4769-9263-ff0d8de330af", 148 | "metadata": {}, 149 | "source": [ 150 | "### 1-4 Classical Simulation of $H_{\\text{Heis3}}$\n", 151 | "\n", 152 | "Now that we have the operator $U_{\\text{Heis3}}(t)$ which describes how any state of the quantum system changes in time, we can simulate the $XXX$ Heisenberg spin model! Just for fun, let's simulate the system using a classical computer first.\n", 153 | "\n", 154 | "(Fun fact: Notice the size of $U_{\\text{Heis3}}(t)$ in matrix form. It's representated by an $8$x$8$ matrix. This is because there are $2^3=8$ states in the $N=3$ system. If the simulation were of $50$ particles ($N=50$), $U_{\\text{Heis}}(t)$ would be approximately $10^{15}$x$10^{15}$! Well beyond the capacity of today's computers.)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 4, 160 | "id": "0813fede-9945-4477-9304-9f9891ce50a7", 161 | "metadata": { 162 | "ExecuteTime": { 163 | "end_time": "2023-09-22T18:52:16.870929Z", 164 | "start_time": "2023-09-22T18:52:16.479159Z" 165 | } 166 | }, 167 | "outputs": [ 168 | { 169 | "data": { 170 | "image/png": "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", 171 | "text/plain": [ 172 | "
" 173 | ] 174 | }, 175 | "metadata": {}, 176 | "output_type": "display_data" 177 | } 178 | ], 179 | "source": [ 180 | "# Define array of time points\n", 181 | "ts = np.linspace(0, np.pi, 100)\n", 182 | "\n", 183 | "# Define initial state |110>\n", 184 | "initial_state = One^One^Zero\n", 185 | "\n", 186 | "# Compute probability of remaining in |110> state over the array of time points\n", 187 | " # ~initial_state gives the bra of the initial state (<110|)\n", 188 | " # @ is short hand for matrix multiplication\n", 189 | " # U_heis3(t) is the unitary time evolution at time t\n", 190 | " # t needs to be wrapped with float(t) to avoid a bug\n", 191 | " # (...).eval() returns the inner product <110|U_heis3(t)|110>\n", 192 | " # np.abs(...)**2 is the modulus squared of the innner product which is the expectation value, or probability, of remaining in |110>\n", 193 | "probs_110 = [np.abs((~initial_state @ U_heis3(float(t)) @ initial_state).eval())**2 for t in ts]\n", 194 | "\n", 195 | "# Plot evolution of |110>\n", 196 | "plt.plot(ts, probs_110)\n", 197 | "plt.xlabel('time')\n", 198 | "plt.ylabel(r'probability of state $|110\\rangle$')\n", 199 | "plt.title(r'Evolution of state $|110\\rangle$ under $H_{Heis3}$')\n", 200 | "plt.grid()\n", 201 | "plt.show()" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "id": "04db5341-8ba0-433b-b671-d929aba1fbe0", 207 | "metadata": {}, 208 | "source": [ 209 | "### 1-5 Decomposition of $U_{\\text{Heis3}}(t)$ Into Quantum Gates\n", 210 | "\n", 211 | "To execute $U_{\\text{Heis3}}(t)$ on a [circuit model](https://qiskit.org/documentation/apidoc/circuit.html) quantum computer, we must decompose $U_{\\text{Heis3}}(t)$ into a product of single and two-qubit gates that are native to that quantum computer. There are a [variety of techniques](https://en.wikipedia.org/wiki/Hamiltonian_simulation) to do this. For this tutorial, you will only use [Trotterization](https://en.wikipedia.org/wiki/Hamiltonian_simulation#Product_Formulas) (which is sometimes refered to as Suzuki-Trotterization decomposition, Trotter formulas, product formulas, and other names).\n", 212 | "\n", 213 | "Below, we show an example Trotterization as outlined in \\[1-2\\].\n", 214 | "\n", 215 | "Since the [Pauli operators do not commute](https://en.wikipedia.org/wiki/Pauli_matrices#Commutation_relations) with each other, the exponential $U_{\\text{Heis3}}(t)$ cannot be split into a product of simpler exponentials. However, we can approximate $U_{\\text{Heis3}}(t)$ as a product of simpler exponentials through Trotterization. Consider a subsystem of 2 spin-1/2 particles within the larger 3 spin system. The Hamiltonian on spins $i$ and $j$ ($i,j \\in \\{0,1,2\\}$) would be $H^{(i,j)}_{\\text{Heis2}} = \\sigma_x^{(i)}\\sigma_x^{(j)} + \\sigma_y^{(i)}\\sigma_y^{(j)} + \\sigma_z^{(i)}\\sigma_z^{(j)}$. Rewritting $U_{\\text{Heis3}}(t)$ in terms of the two possible subsystems within the total $N=3$ system you will simulate,\n", 216 | "\n", 217 | "$$\n", 218 | "U_{\\text{Heis3}}(t) = \\exp\\left[-i t \\left(H^{(0,1)}_{\\text{Heis2}} + H^{(1,2)}_{\\text{Heis2}} \\right)\\right].\n", 219 | "$$\n", 220 | "\n", 221 | "$H^{(0,1)}_{\\text{Heis2}}$ and $H^{(1,2)}_{\\text{Heis2}}$ do not commute, so $U_{\\text{Heis3}}(t) \\neq \\exp\\left(-i t H^{(0,1)}_{\\text{Heis2}}\\right) \\exp\\left(-i t H^{(1,2)}_{\\text{Heis2}} \\right)$. But, this product decomposition can be approximated with Trotterization which says $U_{\\text{Heis3}}(t)$ is approximately a short evolution of $H^{(0,1)}_{\\text{Heis2}}$ (time = $t/n$) and followed by a short evolution of $H^{(1,2)}_{\\text{Heis2}}$ (time = $t/n$) repeated $n$ times\n", 222 | "\n", 223 | "$$\n", 224 | "\\begin{align}\n", 225 | "U_{\\text{Heis3}}(t) &= \\exp\\left[-i t \\left(H^{(0,1)}_{\\text{Heis2}} + H^{(1,2)}_{\\text{Heis2}} \\right)\\right] \\\\\n", 226 | "U_{\\text{Heis3}}(t) &\\approx \\left[\\exp\\left(\\dfrac{-it}{n}H^{(0,1)}_{\\text{Heis2}}\\right) \\exp\\left(\\dfrac{-it}{n}H^{(1,2)}_{\\text{Heis2}} \\right)\\right]^n.\n", 227 | "\\end{align}\n", 228 | "$$\n", 229 | "\n", 230 | "$n$ is the number of Trotter steps, and as $n$ increases, the approximation becomes more accurate. (Note that how a untiary is split up into subsystems for Trotterization is not necessarily unique.) The decomposition goes further. Within each 2 spin subsystems, the Pauli operator pairs ($\\sigma_x^{(i)}\\sigma_x^{(j)}$, $\\sigma_y^{(i)}\\sigma_y^{(j)}$, and $\\sigma_z^{(i)}\\sigma_z^{(j)}$) commute. This means we can decompose the exponential of a subsystem Hamiltonian ($H^{(i,j)}_{\\text{Heis2}}$) into a product of even simpler exponentials getting us closer to a gate implementation of $U_{\\text{Heis3}}(t)$\n", 231 | "\n", 232 | "$$\n", 233 | "\\begin{align}\n", 234 | "U_{\\text{Heis3}}(t) &\\approx \\left[\\exp\\left(\\dfrac{-it}{n}H^{(0,1)}_{\\text{Heis2}}\\right) \\exp\\left(\\dfrac{-it}{n}H^{(1,2)}_{\\text{Heis2}} \\right)\\right]^n \\\\\n", 235 | "U_{\\text{Heis3}}(t) &\\approx \\left[\\exp\\left(\\dfrac{-it}{n}\\left(\\sigma_x^{(0)}\\sigma_x^{(1)} + \\sigma_y^{(0)}\\sigma_y^{(1)} + \\sigma_z^{(0)}\\sigma_z^{(1)}\\right)\\right) \\exp\\left(\\dfrac{-it}{n}\\left(\\sigma_x^{(1)}\\sigma_x^{(2)} + \\sigma_y^{(1)}\\sigma_y^{(2)} + \\sigma_z^{(1)}\\sigma_z^{(2)}\\right)\\right)\\right]^{n} \\\\\n", 236 | "U_{\\text{Heis3}}(t) &\\approx \\left[\\exp\\left(\\dfrac{-it}{n}\\sigma_x^{(0)}\\sigma_x^{(1)}\\right) \\exp\\left(\\dfrac{-it}{n}\\sigma_y^{(0)}\\sigma_y^{(1)}\\right) \\exp\\left(\\dfrac{-it}{n}\\sigma_z^{(0)}\\sigma_z^{(1)}\\right) \\exp\\left(\\dfrac{-it}{n}\\sigma_x^{(1)}\\sigma_x^{(2)}\\right) \\exp\\left(\\dfrac{-it}{n}\\sigma_y^{(1)}\\sigma_y^{(2)}\\right) \\exp\\left(\\dfrac{-it}{n}\\sigma_z^{(1)}\\sigma_z^{(2)}\\right)\\right]^{n}\n", 237 | "\\end{align}\n", 238 | "$$\n", 239 | "\n", 240 | "For simplicity, and to use more common notation, let's rename the products with $XX(2t) = \\exp\\left(-it \\sigma_x\\sigma_x\\right)$, $YY(2t) = \\exp\\left(-it \\sigma_y\\sigma_y\\right)$, and $ZZ(2t) = \\exp\\left(-it \\sigma_z\\sigma_z\\right)$ and rewrite the Trotterized $U_{\\text{Heis3}}(t)$\n", 241 | "$$\n", 242 | "U_{\\text{Heis3}}(t) \\approx \\left[XX\\left(\\frac{2t}{n}\\right)^{(0,1)} YY\\left(\\frac{2t}{n}\\right)^{(0,1)} ZZ\\left(\\frac{2t}{n}\\right)^{(0,1)} XX\\left(\\frac{2t}{n}\\right)^{(1,2)} YY\\left(\\frac{2t}{n}\\right)^{(1,2)} ZZ\\left(\\frac{2t}{n}\\right)^{(1,2)} \\right]^{n}\n", 243 | "$$\n", 244 | "And that's it! We have now approximately decomposed $U_{\\text{Heis3}}(t)$ into two-qubit gates $XX(t)$, $YY(t)$, and $ZZ(t)$. These gates are not native to superconducting qubits, but in Section 2, they will be further decomposed into native single and two-qubit gates with *further details found in the supplementary material.*\n", 245 | "\n", 246 | "\n", 247 | "\\[1\\] Y. Salathe, et al., *Digital Quantum Simulation of Spin Models with Circuit Quantum Electrodynamics*, [Phys. Rev. X **5**, 021027 (2015)](https://link.aps.org/doi/10.1103/PhysRevX.5.021027)\n", 248 | "\n", 249 | "\\[2\\] F. Tacchino, et al., *Quantum Computers as Universal Quantum Simulators: State-of-the-Art and Perspectives*, [Adv. Quantum Technol. *3* 3 (2020)](https://doi.org/10.1002/qute.201900052) \\[[free arxiv version](https://arxiv.org/abs/1907.03505)\\]\n" 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "id": "509e3761-6196-4b8f-aa5d-434bf1070eeb", 255 | "metadata": {}, 256 | "source": [ 257 | "# 2 Main\n", 258 | "### 2-1 Details\n", 259 | "\n", 260 | "You are to time evolve the state $|110\\rangle$ to time $t=\\pi$ under the $XXX$ Heisenberg model Hamiltonian $H_{\\text{heis3}}$ as defined in Section 1. This will be done on the ibmq_jakarta quantum computer. From left to right, the qubits in $|110\\rangle$ correspond to ibmq_jakarta's qubits 5, 3, and 1. The evolution must be done using Trotterization with at least 4 steps ($n\\geq4$). You will be judged on the clarity, originiality, and creativity of your solution, as well as the fidelity of the evolved state at time $t=\\pi$ using [state tomography](https://qiskit.org/documentation/tutorials/noise/8_tomography.html). State tomography is a way of determining the exact quantum state--even phase information--at the end of a quantum circuit by running the circuit multiple times and measuring in different bases. The closer your final quantum state to the expected state, the higher the fidelity. Ibmq_jakarta's qubits 0, 2, 4, and 6 will not be evaluated by the state tomography calculation, so you may use them as you wish. You do not need to follow the same decomposition given in the example above, but your solution must be a Trotterization of $U_{\\text{heis3}}(t)$ with at least 4 steps ($n\\geq4$). You may find it useful to implement techniques that reduce errors and improve qubit coherence." 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "id": "c794b8f1-6de7-497b-a000-0b37f9d094b3", 266 | "metadata": {}, 267 | "source": [ 268 | "### 2-2 Import Qiskit\n", 269 | "\n", 270 | "Feel free to import packages as needed. However, only free packages and those obtained through ```pip install``` or ```conda install``` are allowed." 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": 5, 276 | "id": "8b3e598e-1156-4263-abc6-890e554cf4fb", 277 | "metadata": { 278 | "ExecuteTime": { 279 | "end_time": "2023-09-22T18:52:20.975358Z", 280 | "start_time": "2023-09-22T18:52:20.892276Z" 281 | } 282 | }, 283 | "outputs": [], 284 | "source": [ 285 | "# Importing standard Qiskit modules\n", 286 | "from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile\n", 287 | "from qiskit.providers.aer import QasmSimulator\n", 288 | "from qiskit.tools.monitor import job_monitor\n", 289 | "from qiskit.circuit import Parameter\n", 290 | "\n", 291 | "# Import state tomography modules\n", 292 | "from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter\n", 293 | "from qiskit.quantum_info import state_fidelity\n", 294 | "\n", 295 | "# suppress warnings\n", 296 | "import warnings\n", 297 | "warnings.filterwarnings('ignore')" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "id": "900d2ab8-b568-4d28-87d8-473962fdc998", 303 | "metadata": {}, 304 | "source": [ 305 | "### 2-3 Quantum Devices\n", 306 | "Connect to IBM provider and connect to a real or simulated backend. Final submissions must be run on a real backend, but simulated devices are faster for debugging and testing." 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 6, 312 | "id": "7345d1e9-4803-4bd8-a578-0af5294cb22a", 313 | "metadata": { 314 | "ExecuteTime": { 315 | "end_time": "2023-09-22T18:52:27.837687Z", 316 | "start_time": "2023-09-22T18:52:22.667507Z" 317 | } 318 | }, 319 | "outputs": [ 320 | { 321 | "name": "stderr", 322 | "output_type": "stream", 323 | "text": [ 324 | "configrc.store_credentials:WARNING:2023-09-22 11:52:22,674: Credentials already present. Set overwrite=True to overwrite.\n" 325 | ] 326 | } 327 | ], 328 | "source": [ 329 | "# load IBMQ Account data\n", 330 | "\n", 331 | "IBMQ.save_account() # replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n", 332 | "provider = IBMQ.load_account()" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": 7, 338 | "id": "78e0af5d-6da9-4a08-912a-5a172535e03b", 339 | "metadata": { 340 | "ExecuteTime": { 341 | "end_time": "2023-09-22T18:52:30.315251Z", 342 | "start_time": "2023-09-22T18:52:29.949432Z" 343 | } 344 | }, 345 | "outputs": [], 346 | "source": [ 347 | "# Get backend for experiment\n", 348 | "# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n", 349 | "jakarta = provider.get_backend('ibmq_jakarta')\n", 350 | "properties = jakarta.properties()\n", 351 | "\n", 352 | "# Simulated backend based on ibmq_jakarta's device noise profile\n", 353 | "# sim_noisy_jakarta = QasmSimulator.from_backend(provider.get_backend('ibmq_jakarta'))\n", 354 | "\n", 355 | "sim_noisy_jakarta = QasmSimulator()\n", 356 | "\n", 357 | "# Noiseless simulated backend\n", 358 | "sim = QasmSimulator()" 359 | ] 360 | }, 361 | { 362 | "cell_type": "markdown", 363 | "id": "d4e8a24c-5846-4de9-95ea-3033653c4037", 364 | "metadata": {}, 365 | "source": [ 366 | "### 2-4 Decomposition of $U_{\\text{Heis3}}(t)$ into Quantum Gates (Example)\n", 367 | "\n", 368 | "The following circuit code is written based on the example given in Section 1. This is where you write your solution." 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "id": "207beaa7-58e9-40c1-a35c-f359ddb7aa8b", 374 | "metadata": {}, 375 | "source": [ 376 | "YOUR TROTTERIZATION GOES HERE -- START (beginning of example)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 8, 382 | "id": "9156980e-d3a7-4494-8ad4-7ec15ca92e7f", 383 | "metadata": { 384 | "ExecuteTime": { 385 | "end_time": "2023-09-22T18:52:33.638767Z", 386 | "start_time": "2023-09-22T18:52:33.634189Z" 387 | } 388 | }, 389 | "outputs": [], 390 | "source": [ 391 | "# Parameterize variable t to be evaluated at t=pi later\n", 392 | "t = Parameter('t')" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": 9, 398 | "id": "ec328a9f-809c-49d6-8400-fa09579c1d8c", 399 | "metadata": { 400 | "ExecuteTime": { 401 | "end_time": "2023-09-22T18:52:34.028440Z", 402 | "start_time": "2023-09-22T18:52:34.017313Z" 403 | } 404 | }, 405 | "outputs": [], 406 | "source": [ 407 | "# Build a subcircuit for XX(t) two-qubit gate\n", 408 | "XX_qr = QuantumRegister(2)\n", 409 | "XX_qc = QuantumCircuit(XX_qr, name='XX')\n", 410 | "\n", 411 | "XX_qc.ry(np.pi/2,[0,1])\n", 412 | "XX_qc.cnot(0,1)\n", 413 | "XX_qc.rz(2 * t, 1)\n", 414 | "XX_qc.cnot(0,1)\n", 415 | "XX_qc.ry(-np.pi/2,[0,1])\n", 416 | "\n", 417 | "# Convert custom quantum circuit into a gate\n", 418 | "XX = XX_qc.to_instruction()" 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": 10, 424 | "id": "6a5c351c", 425 | "metadata": { 426 | "ExecuteTime": { 427 | "end_time": "2023-09-22T18:52:34.898779Z", 428 | "start_time": "2023-09-22T18:52:34.632988Z" 429 | } 430 | }, 431 | "outputs": [ 432 | { 433 | "name": "stderr", 434 | "output_type": "stream", 435 | "text": [ 436 | "/Users/jacksong/opt/anaconda3/envs/QCFD_env/lib/python3.8/site-packages/qiskit/circuit/tools/pi_check.py:55: SymPyDeprecationWarning: \n", 437 | "\n", 438 | "The expr_free_symbols property is deprecated. Use free_symbols to get\n", 439 | "the free symbols of an expression.\n", 440 | "\n", 441 | "See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-expr-free-symbols\n", 442 | "for details.\n", 443 | "\n", 444 | "This has been deprecated since SymPy version 1.9. It\n", 445 | "will be removed in a future version of SymPy.\n", 446 | "\n", 447 | " syms = expr.expr_free_symbols\n", 448 | "/Users/jacksong/opt/anaconda3/envs/QCFD_env/lib/python3.8/site-packages/sympy/core/expr.py:2463: SymPyDeprecationWarning: \n", 449 | "\n", 450 | "The expr_free_symbols property is deprecated. Use free_symbols to get\n", 451 | "the free symbols of an expression.\n", 452 | "\n", 453 | "See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-expr-free-symbols\n", 454 | "for details.\n", 455 | "\n", 456 | "This has been deprecated since SymPy version 1.9. It\n", 457 | "will be removed in a future version of SymPy.\n", 458 | "\n", 459 | " return {j for i in self.args for j in i.expr_free_symbols}\n" 460 | ] 461 | }, 462 | { 463 | "data": { 464 | "text/html": [ 465 | "
      ┌─────────┐                     ┌──────────┐\n",
 466 |        "q0_0: ┤ Ry(π/2) ├──■───────────────■──┤ Ry(-π/2) ├\n",
 467 |        "      ├─────────┤┌─┴─┐┌─────────┐┌─┴─┐├──────────┤\n",
 468 |        "q0_1: ┤ Ry(π/2) ├┤ X ├┤ Rz(2*t) ├┤ X ├┤ Ry(-π/2) ├\n",
 469 |        "      └─────────┘└───┘└─────────┘└───┘└──────────┘
" 470 | ], 471 | "text/plain": [ 472 | " ┌─────────┐ ┌──────────┐\n", 473 | "q0_0: ┤ Ry(π/2) ├──■───────────────■──┤ Ry(-π/2) ├\n", 474 | " ├─────────┤┌─┴─┐┌─────────┐┌─┴─┐├──────────┤\n", 475 | "q0_1: ┤ Ry(π/2) ├┤ X ├┤ Rz(2*t) ├┤ X ├┤ Ry(-π/2) ├\n", 476 | " └─────────┘└───┘└─────────┘└───┘└──────────┘" 477 | ] 478 | }, 479 | "execution_count": 10, 480 | "metadata": {}, 481 | "output_type": "execute_result" 482 | } 483 | ], 484 | "source": [ 485 | "XX_qc.draw()" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": 11, 491 | "id": "52977709-1b68-4ebf-98de-dc5c88265acb", 492 | "metadata": { 493 | "ExecuteTime": { 494 | "end_time": "2023-09-22T18:52:35.077695Z", 495 | "start_time": "2023-09-22T18:52:35.073628Z" 496 | } 497 | }, 498 | "outputs": [], 499 | "source": [ 500 | "# Build a subcircuit for YY(t) two-qubit gate\n", 501 | "YY_qr = QuantumRegister(2)\n", 502 | "YY_qc = QuantumCircuit(YY_qr, name='YY')\n", 503 | "\n", 504 | "YY_qc.rx(np.pi/2,[0,1])\n", 505 | "YY_qc.cnot(0,1)\n", 506 | "YY_qc.rz(2 * t, 1)\n", 507 | "YY_qc.cnot(0,1)\n", 508 | "YY_qc.rx(-np.pi/2,[0,1])\n", 509 | "\n", 510 | "# Convert custom quantum circuit into a gate\n", 511 | "YY = YY_qc.to_instruction()" 512 | ] 513 | }, 514 | { 515 | "cell_type": "code", 516 | "execution_count": 12, 517 | "id": "b4b35bf9", 518 | "metadata": { 519 | "ExecuteTime": { 520 | "end_time": "2023-09-22T18:52:35.702856Z", 521 | "start_time": "2023-09-22T18:52:35.689411Z" 522 | } 523 | }, 524 | "outputs": [ 525 | { 526 | "data": { 527 | "text/html": [ 528 | "
      ┌─────────┐                     ┌──────────┐\n",
 529 |        "q1_0: ┤ Rx(π/2) ├──■───────────────■──┤ Rx(-π/2) ├\n",
 530 |        "      ├─────────┤┌─┴─┐┌─────────┐┌─┴─┐├──────────┤\n",
 531 |        "q1_1: ┤ Rx(π/2) ├┤ X ├┤ Rz(2*t) ├┤ X ├┤ Rx(-π/2) ├\n",
 532 |        "      └─────────┘└───┘└─────────┘└───┘└──────────┘
" 533 | ], 534 | "text/plain": [ 535 | " ┌─────────┐ ┌──────────┐\n", 536 | "q1_0: ┤ Rx(π/2) ├──■───────────────■──┤ Rx(-π/2) ├\n", 537 | " ├─────────┤┌─┴─┐┌─────────┐┌─┴─┐├──────────┤\n", 538 | "q1_1: ┤ Rx(π/2) ├┤ X ├┤ Rz(2*t) ├┤ X ├┤ Rx(-π/2) ├\n", 539 | " └─────────┘└───┘└─────────┘└───┘└──────────┘" 540 | ] 541 | }, 542 | "execution_count": 12, 543 | "metadata": {}, 544 | "output_type": "execute_result" 545 | } 546 | ], 547 | "source": [ 548 | "YY_qc.draw()" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 13, 554 | "id": "4fd739df-0dc4-48ef-823e-230fb0c8fd64", 555 | "metadata": { 556 | "ExecuteTime": { 557 | "end_time": "2023-09-22T18:52:36.249726Z", 558 | "start_time": "2023-09-22T18:52:36.238616Z" 559 | } 560 | }, 561 | "outputs": [], 562 | "source": [ 563 | "# Build a subcircuit for ZZ(t) two-qubit gate\n", 564 | "ZZ_qr = QuantumRegister(2)\n", 565 | "ZZ_qc = QuantumCircuit(ZZ_qr, name='ZZ')\n", 566 | "\n", 567 | "ZZ_qc.cnot(0,1)\n", 568 | "ZZ_qc.rz(2 * t, 1)\n", 569 | "ZZ_qc.cnot(0,1)\n", 570 | "\n", 571 | "# Convert custom quantum circuit into a gate\n", 572 | "ZZ = ZZ_qc.to_instruction()" 573 | ] 574 | }, 575 | { 576 | "cell_type": "code", 577 | "execution_count": 14, 578 | "id": "03c87dca", 579 | "metadata": { 580 | "ExecuteTime": { 581 | "end_time": "2023-09-22T18:52:36.795427Z", 582 | "start_time": "2023-09-22T18:52:36.783918Z" 583 | } 584 | }, 585 | "outputs": [ 586 | { 587 | "data": { 588 | "text/html": [ 589 | "
                           \n",
 590 |        "q2_0: ──■───────────────■──\n",
 591 |        "      ┌─┴─┐┌─────────┐┌─┴─┐\n",
 592 |        "q2_1: ┤ X ├┤ Rz(2*t) ├┤ X ├\n",
 593 |        "      └───┘└─────────┘└───┘
" 594 | ], 595 | "text/plain": [ 596 | " \n", 597 | "q2_0: ──■───────────────■──\n", 598 | " ┌─┴─┐┌─────────┐┌─┴─┐\n", 599 | "q2_1: ┤ X ├┤ Rz(2*t) ├┤ X ├\n", 600 | " └───┘└─────────┘└───┘" 601 | ] 602 | }, 603 | "execution_count": 14, 604 | "metadata": {}, 605 | "output_type": "execute_result" 606 | } 607 | ], 608 | "source": [ 609 | "ZZ_qc.draw()" 610 | ] 611 | }, 612 | { 613 | "cell_type": "markdown", 614 | "id": "4335d6d3-4a8e-4140-aad0-97b9b189905a", 615 | "metadata": {}, 616 | "source": [ 617 | "Combine subcircuits into single gate representing one ($n=1$) trotter step." 618 | ] 619 | }, 620 | { 621 | "cell_type": "code", 622 | "execution_count": 15, 623 | "id": "8ef03f79-2c47-49da-93d5-0c0ae3ea5872", 624 | "metadata": { 625 | "ExecuteTime": { 626 | "end_time": "2023-09-22T18:52:37.832105Z", 627 | "start_time": "2023-09-22T18:52:37.813379Z" 628 | } 629 | }, 630 | "outputs": [], 631 | "source": [ 632 | "# Combine subcircuits into a single multiqubit gate representing a single trotter step\n", 633 | "num_qubits = 3\n", 634 | "\n", 635 | "Trot_qr = QuantumRegister(num_qubits)\n", 636 | "Trot_qc = QuantumCircuit(Trot_qr, name='Trot')\n", 637 | "\n", 638 | "for i in range(0, num_qubits - 1):\n", 639 | " Trot_qc.append(ZZ, [Trot_qr[i], Trot_qr[i+1]])\n", 640 | " Trot_qc.append(YY, [Trot_qr[i], Trot_qr[i+1]])\n", 641 | " Trot_qc.append(XX, [Trot_qr[i], Trot_qr[i+1]])\n", 642 | "\n", 643 | "# Convert custom quantum circuit into a gate\n", 644 | "Trot_gate = Trot_qc.to_instruction()" 645 | ] 646 | }, 647 | { 648 | "cell_type": "markdown", 649 | "id": "0641237c-048e-41e7-b47c-88a364683fb7", 650 | "metadata": {}, 651 | "source": [ 652 | "YOUR TROTTERIZATION GOES HERE -- FINISH (end of example)" 653 | ] 654 | }, 655 | { 656 | "cell_type": "markdown", 657 | "id": "b9fb21ba-a2ea-4595-ba76-a4cef87ea666", 658 | "metadata": {}, 659 | "source": [ 660 | "### 2-5 Trotterized Time Evolution\n", 661 | "\n", 662 | "Time evolve the state $|110\\rangle$ from $\\theta=0$ to $\\theta=\\pi$ under $H_{\\text{heis3}}$. Although jakarta has 7 qubits, only the qubits 1, 3, and 5 will be used for the state $|110\\rangle$. From left to right, the qubits in $|110\\rangle$ corresponds to the qubits 5, 3, and 1 on jakarta. State tomography will evaluate how well the quantum simulation matches to the expected state at $\\theta= \\pi$. (Note qubits 0, 2, 4, and 6 are not part of the state tomography calculation.)\n", 663 | "\n", 664 | "You choose how many trotter steps (```trotter_steps```) to take in the simulation, but it must be at least 4. The code below is written to be generic enough for you may add to it if necessary for your solution." 665 | ] 666 | }, 667 | { 668 | "cell_type": "code", 669 | "execution_count": 16, 670 | "id": "c6135540-dcea-4313-8ce8-0eb8e3ee23e7", 671 | "metadata": { 672 | "ExecuteTime": { 673 | "end_time": "2023-09-22T18:52:39.171251Z", 674 | "start_time": "2023-09-22T18:52:39.112794Z" 675 | } 676 | }, 677 | "outputs": [ 678 | { 679 | "data": { 680 | "text/html": [ 681 | "
                                                                    ░          \n",
 682 |        "q4_0: ──────────────────────────────────────────────────────────────░──────────\n",
 683 |        "           ┌────────────┐┌────────────┐┌────────────┐┌────────────┐ ░ ┌─┐      \n",
 684 |        "q4_1: ─────┤0           ├┤0           ├┤0           ├┤0           ├─░─┤M├──────\n",
 685 |        "           │            ││            ││            ││            │ ░ └╥┘      \n",
 686 |        "q4_2: ─────┤            ├┤            ├┤            ├┤            ├─░──╫───────\n",
 687 |        "      ┌───┐│            ││            ││            ││            │ ░  ║ ┌─┐   \n",
 688 |        "q4_3: ┤ X ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├─░──╫─┤M├───\n",
 689 |        "      └───┘│            ││            ││            ││            │ ░  ║ └╥┘   \n",
 690 |        "q4_4: ─────┤            ├┤            ├┤            ├┤            ├─░──╫──╫────\n",
 691 |        "      ┌───┐│            ││            ││            ││            │ ░  ║  ║ ┌─┐\n",
 692 |        "q4_5: ┤ X ├┤2           ├┤2           ├┤2           ├┤2           ├─░──╫──╫─┤M├\n",
 693 |        "      └───┘└────────────┘└────────────┘└────────────┘└────────────┘ ░  ║  ║ └╥┘\n",
 694 |        "q4_6: ──────────────────────────────────────────────────────────────░──╫──╫──╫─\n",
 695 |        "                                                                    ░  ║  ║  ║ \n",
 696 |        "c0: 3/═════════════════════════════════════════════════════════════════╩══╩══╩═\n",
 697 |        "                                                                       0  1  2
" 698 | ], 699 | "text/plain": [ 700 | " ░ \n", 701 | "q4_0: ──────────────────────────────────────────────────────────────░──────────\n", 702 | " ┌────────────┐┌────────────┐┌────────────┐┌────────────┐ ░ ┌─┐ \n", 703 | "q4_1: ─────┤0 ├┤0 ├┤0 ├┤0 ├─░─┤M├──────\n", 704 | " │ ││ ││ ││ │ ░ └╥┘ \n", 705 | "q4_2: ─────┤ ├┤ ├┤ ├┤ ├─░──╫───────\n", 706 | " ┌───┐│ ││ ││ ││ │ ░ ║ ┌─┐ \n", 707 | "q4_3: ┤ X ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├─░──╫─┤M├───\n", 708 | " └───┘│ ││ ││ ││ │ ░ ║ └╥┘ \n", 709 | "q4_4: ─────┤ ├┤ ├┤ ├┤ ├─░──╫──╫────\n", 710 | " ┌───┐│ ││ ││ ││ │ ░ ║ ║ ┌─┐\n", 711 | "q4_5: ┤ X ├┤2 ├┤2 ├┤2 ├┤2 ├─░──╫──╫─┤M├\n", 712 | " └───┘└────────────┘└────────────┘└────────────┘└────────────┘ ░ ║ ║ └╥┘\n", 713 | "q4_6: ──────────────────────────────────────────────────────────────░──╫──╫──╫─\n", 714 | " ░ ║ ║ ║ \n", 715 | "c0: 3/═════════════════════════════════════════════════════════════════╩══╩══╩═\n", 716 | " 0 1 2 " 717 | ] 718 | }, 719 | "execution_count": 16, 720 | "metadata": {}, 721 | "output_type": "execute_result" 722 | } 723 | ], 724 | "source": [ 725 | "# The final time of the state evolution\n", 726 | "target_time = np.pi\n", 727 | "\n", 728 | "# Number of trotter steps\n", 729 | "trotter_steps = 4 ### CAN BE >= 4\n", 730 | "\n", 731 | "# Initialize quantum circuit for 3 qubits\n", 732 | "qr = QuantumRegister(7)\n", 733 | "qc = QuantumCircuit(qr)\n", 734 | "\n", 735 | "# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)\n", 736 | "qc.x([3,5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)\n", 737 | "\n", 738 | "# Simulate time evolution under H_heis3 Hamiltonian\n", 739 | "for _ in range(trotter_steps):\n", 740 | " qc.append(Trot_gate, [qr[1], qr[3], qr[5]])\n", 741 | "\n", 742 | "# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time\n", 743 | "qc = qc.bind_parameters({t: target_time/trotter_steps})\n", 744 | "\n", 745 | "# Generate state tomography circuits to evaluate fidelity of simulation\n", 746 | "st_qcs = state_tomography_circuits(qc, [qr[1], qr[3], qr[5]])\n", 747 | "\n", 748 | "# Display circuit for confirmation\n", 749 | "# st_qcs[-1].decompose().draw() # view decomposition of trotter gates\n", 750 | "st_qcs[-1].draw() # only view trotter gates" 751 | ] 752 | }, 753 | { 754 | "cell_type": "markdown", 755 | "id": "1742151c-1261-4b42-80a4-da2c0ad90ac5", 756 | "metadata": {}, 757 | "source": [ 758 | "### 2-6 Execute\n", 759 | "For your final submission, you will need to execute your solution on a real backend with 8 repetitions. For faster debugging, considering using a simulated backend and/or 1 repetition." 760 | ] 761 | }, 762 | { 763 | "cell_type": "code", 764 | "execution_count": 20, 765 | "id": "79c3ef21-c143-418a-8b50-f0ab39c5ae35", 766 | "metadata": { 767 | "ExecuteTime": { 768 | "end_time": "2023-09-22T18:54:05.095636Z", 769 | "start_time": "2023-09-22T18:53:23.732433Z" 770 | } 771 | }, 772 | "outputs": [ 773 | { 774 | "name": "stdout", 775 | "output_type": "stream", 776 | "text": [ 777 | "Job ID d4dd849e-cb81-4c07-a136-121d4526fba9\n", 778 | "Job ID a088ab89-0da4-4d65-8515-67c71f30a12a\n", 779 | "Job ID bcbb7daf-4728-4261-8ce5-0f518ae809a9\n", 780 | "Job ID 14d9744d-e143-4e32-a338-1336d2674f2b\n", 781 | "Job ID 5daaeb9d-0e42-498a-a731-0a3da4f1e2fe\n", 782 | "Job ID 9c1aec1e-5124-414f-87a5-be4e56482844\n", 783 | "Job ID 69195673-b16a-4c9c-b16c-7fb4e042e662\n", 784 | "Job ID 42e968a7-8879-4b7c-8460-449995057540\n", 785 | "Job ID 298d5178-a268-4e76-a84c-51960bbc3514\n", 786 | "Job ID 10760156-a123-4d92-9345-5d21dce8da8f\n", 787 | "Job ID a68652eb-b00b-4772-8d0e-fc452a2b35b0\n", 788 | "Job ID 7dd20d81-936b-4db5-8a53-1ea1346ec184\n", 789 | "Job ID 6b8125d5-850c-47eb-94a7-9b8a43136ca8\n", 790 | "Job ID bf83e250-4ba1-4dfb-b1e9-bcf81efc36d5\n", 791 | "Job ID 962c97bc-7bcd-471e-a700-a44da6af2b5e\n", 792 | "Job ID 2ed07dd1-5cda-4c11-9a67-cffc4f473a17\n" 793 | ] 794 | } 795 | ], 796 | "source": [ 797 | "shots = 8192\n", 798 | "reps = 16\n", 799 | "backend = sim_noisy_jakarta\n", 800 | "# reps = 8\n", 801 | "# backend = jakarta\n", 802 | "\n", 803 | "jobs = []\n", 804 | "for _ in range(reps):\n", 805 | " # execute\n", 806 | " job = execute(st_qcs, backend, shots=shots)\n", 807 | " print('Job ID', job.job_id())\n", 808 | " jobs.append(job)" 809 | ] 810 | }, 811 | { 812 | "cell_type": "markdown", 813 | "id": "be7acc76-86f0-4b1f-94e4-e4e1014f3956", 814 | "metadata": {}, 815 | "source": [ 816 | "We can monitor the status of the jobs using Qiskit's job monitoring tools." 817 | ] 818 | }, 819 | { 820 | "cell_type": "code", 821 | "execution_count": 18, 822 | "id": "1b142880-af5b-4913-8f50-9248e5d1646f", 823 | "metadata": { 824 | "ExecuteTime": { 825 | "end_time": "2023-09-22T18:53:09.902361Z", 826 | "start_time": "2023-09-22T18:53:09.894264Z" 827 | } 828 | }, 829 | "outputs": [ 830 | { 831 | "name": "stdout", 832 | "output_type": "stream", 833 | "text": [ 834 | "\r", 835 | "Job Status: job has successfully run\n", 836 | "\r", 837 | "Job Status: job has successfully run\n", 838 | "\r", 839 | "Job Status: job has successfully run\n", 840 | "\r", 841 | "Job Status: job has successfully run\n", 842 | "\r", 843 | "Job Status: job has successfully run\n", 844 | "\r", 845 | "Job Status: job has successfully run\n", 846 | "\r", 847 | "Job Status: job has successfully run\n", 848 | "\r", 849 | "Job Status: job has successfully run\n" 850 | ] 851 | } 852 | ], 853 | "source": [ 854 | "for job in jobs:\n", 855 | " job_monitor(job)\n", 856 | " try:\n", 857 | " if job.error_message() is not None:\n", 858 | " print(job.error_message())\n", 859 | " except:\n", 860 | " pass" 861 | ] 862 | }, 863 | { 864 | "cell_type": "markdown", 865 | "id": "e4186e06-db3d-4d0d-aef4-51906f41df61", 866 | "metadata": {}, 867 | "source": [ 868 | "### 2-7 Results Analysis\n", 869 | "Extract the results for the completed jobs and compute the state tomography fidelity for each repetition. You may choose to include other post-processing analyses here as well." 870 | ] 871 | }, 872 | { 873 | "cell_type": "code", 874 | "execution_count": 19, 875 | "id": "f87c0c22-1f37-4f56-9ec5-7e3c5d7a8384", 876 | "metadata": { 877 | "ExecuteTime": { 878 | "end_time": "2023-09-22T18:53:11.790788Z", 879 | "start_time": "2023-09-22T18:53:11.574615Z" 880 | } 881 | }, 882 | "outputs": [ 883 | { 884 | "name": "stdout", 885 | "output_type": "stream", 886 | "text": [ 887 | "state tomography fidelity = 0.0002 ± 0.0001\n" 888 | ] 889 | } 890 | ], 891 | "source": [ 892 | "# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits\n", 893 | "def state_tomo(result, st_qcs):\n", 894 | " # The expected final state; necessary to determine state tomography fidelity\n", 895 | " target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)\n", 896 | " # Fit state tomography results\n", 897 | " tomo_fitter = StateTomographyFitter(result, st_qcs)\n", 898 | " rho_fit = tomo_fitter.fit(method='lstsq')\n", 899 | " # Compute fidelity\n", 900 | " fid = state_fidelity(rho_fit, target_state)\n", 901 | " return fid\n", 902 | "\n", 903 | "# Compute tomography fidelities for each repetition\n", 904 | "fids = []\n", 905 | "for job in jobs:\n", 906 | " fid = state_tomo(job.result(), st_qcs)\n", 907 | " fids.append(fid)\n", 908 | " \n", 909 | "print('state tomography fidelity = {:.4f} \\u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))" 910 | ] 911 | }, 912 | { 913 | "cell_type": "code", 914 | "execution_count": 17, 915 | "id": "a7a0994c-f8bf-4613-8b1e-c78eb2864b8e", 916 | "metadata": {}, 917 | "outputs": [ 918 | { 919 | "data": { 920 | "text/html": [ 921 | "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.18.3
qiskit-aer0.9.1
qiskit-ignis0.6.0
qiskit-ibmq-provider0.18.1
qiskit-aqua0.9.5
qiskit0.32.1
qiskit-nature0.1.3
System information
Python3.8.8 (default, Apr 13 2021, 12:59:45) \n", 922 | "[Clang 10.0.0 ]
OSDarwin
CPUs8
Memory (Gb)64.0
Mon Nov 29 09:12:47 2021 EST
" 923 | ], 924 | "text/plain": [ 925 | "" 926 | ] 927 | }, 928 | "metadata": {}, 929 | "output_type": "display_data" 930 | } 931 | ], 932 | "source": [ 933 | "import qiskit.tools.jupyter\n", 934 | "%qiskit_version_table" 935 | ] 936 | } 937 | ], 938 | "metadata": { 939 | "kernelspec": { 940 | "display_name": "Python 3 (ipykernel)", 941 | "language": "python", 942 | "name": "python3" 943 | }, 944 | "language_info": { 945 | "codemirror_mode": { 946 | "name": "ipython", 947 | "version": 3 948 | }, 949 | "file_extension": ".py", 950 | "mimetype": "text/x-python", 951 | "name": "python", 952 | "nbconvert_exporter": "python", 953 | "pygments_lexer": "ipython3", 954 | "version": "3.8.17" 955 | }, 956 | "toc": { 957 | "base_numbering": 1, 958 | "nav_menu": {}, 959 | "number_sections": true, 960 | "sideBar": true, 961 | "skip_h1_title": false, 962 | "title_cell": "Table of Contents", 963 | "title_sidebar": "Contents", 964 | "toc_cell": false, 965 | "toc_position": {}, 966 | "toc_section_display": true, 967 | "toc_window_display": false 968 | }, 969 | "toc-autonumbering": false, 970 | "toc-showcode": false, 971 | "toc-showmarkdowntxt": false, 972 | "toc-showtags": false, 973 | "varInspector": { 974 | "cols": { 975 | "lenName": 16, 976 | "lenType": 16, 977 | "lenVar": 40 978 | }, 979 | "kernels_config": { 980 | "python": { 981 | "delete_cmd_postfix": "", 982 | "delete_cmd_prefix": "del ", 983 | "library": "var_list.py", 984 | "varRefreshCmd": "print(var_dic_list())" 985 | }, 986 | "r": { 987 | "delete_cmd_postfix": ") ", 988 | "delete_cmd_prefix": "rm(", 989 | "library": "var_list.r", 990 | "varRefreshCmd": "cat(var_dic_list()) " 991 | } 992 | }, 993 | "types_to_exclude": [ 994 | "module", 995 | "function", 996 | "builtin_function_or_method", 997 | "instance", 998 | "_Feature" 999 | ], 1000 | "window_display": false 1001 | } 1002 | }, 1003 | "nbformat": 4, 1004 | "nbformat_minor": 5 1005 | } 1006 | -------------------------------------------------------------------------------- /Session2 Notebook/1DPoisson+VQE.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Solving the Poisson's equation using VQE\n", 8 | "\n", 9 | "Author: Zhixin Song \\\n", 10 | "Last update: 09/22/2023" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "## 1. Introduction\n", 18 | "\n", 19 | "Poisson's equation is $\\Delta \\phi = f$, where $\\Delta = \\nabla^2$ is the Laplace operator. It is widely used in theoretical physics, including electrostatistics and gravitational field. In Cartesian coordinates, it takes the form\n", 20 | "\n", 21 | "$$\n", 22 | "\\bigg(\\frac{\\partial^2}{\\partial x^2} +\\frac{\\partial^2}{\\partial y^2} + \\frac{\\partial^2}{\\partial z^2}\\bigg)\\phi(x,y,z) = f(x,y,z).\n", 23 | "$$\n", 24 | "\n", 25 | "Here, we only consider the 1D case for simplicity. We will disscuss how to generalize it to higher dimensions in a different tutorial. Also, we consider the Dirichlet boundary conditions (B.C.s) in domain $[a,b]$.\n", 26 | "\n", 27 | "$$\n", 28 | "\\Delta \\phi(x)= \\frac{\\partial^2 \\phi(x)}{\\partial x^2} = f(x), \\text{ with } \\phi(a) = \\phi_a, \\phi(b) = \\phi_b.\n", 29 | "$$\n", 30 | "\n", 31 | "The classical approach to solve this type of PDE is discretizing the spatial domain into a grid mesh of $m$ points such that we can approximate the differential operator with a difference operator\n", 32 | "\n", 33 | "$$\n", 34 | "\\Delta \\phi(x) \\approx \\frac{\\phi_{i-1} - 2 \\phi_i + \\phi_{i+1}}{h^2},\n", 35 | "$$\n", 36 | "\n", 37 | "where $h = (b-a)/(m-1)$ is the separation between each grid point. Then, we can tramsform the orginal problem of solving PDE into a linear system $Ax=b$ where\n", 38 | "\n", 39 | "$$\n", 40 | "A = \n", 41 | "\\begin{bmatrix}\n", 42 | " -2 &1 &0 &\\cdots &0 &0 &0\\\\\n", 43 | " 1 &-2 &1 &\\cdots &0 &0 &0\\\\\n", 44 | " \\vdots &\\vdots &\\vdots &\\ddots &\\vdots &\\vdots &\\vdots\\\\\n", 45 | " 0 &0 &0 &\\cdots &1 &-2 &1\\\\\n", 46 | " 0 &0 &0 &\\cdots &0 &1 &-2\n", 47 | "\\end{bmatrix},\n", 48 | "b = \n", 49 | "\\begin{bmatrix}\n", 50 | " h^2f_1 - \\phi_a \\\\\n", 51 | " h^2 f_2 \\\\\n", 52 | " \\vdots \\\\\n", 53 | " h^2 f_{m-1} \\\\\n", 54 | " h^2 f_m - \\phi_b\n", 55 | "\\end{bmatrix}.\n", 56 | "$$\n", 57 | "\n", 58 | "The error from such an discretization procedure decreases exponentially with the size of grid. On a classical computer, one can solve this linear system using Gaussian elimination with Matlab when the problem size is small. " 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "## 2. Quantum Solution\n", 66 | "\n", 67 | "Notice that a quantum state actually maps to an **exponential** grid size. Therefore the amount of quantum resources is linear in number of qubits $n$ and the discretization error decreases exponentially $\\mathcal{O}(1/2^n)$. There are multiple routes to solve this linear system. For the long-term view, one would use the HHL algorithm for speedup. On NISQ machines, we consider the Variational Quantum Eigensolver (VQE).\n", 68 | "\n", 69 | "First of all, we need to transfer the problem into a Hamiltonian $H$ where\n", 70 | "\n", 71 | "$$\n", 72 | "H = A^\\dagger(I - |b\\rangle\\langle b|) A\n", 73 | "$$\n", 74 | "\n", 75 | "In order to see how this works, we can try to plug into the solution $|x\\rangle$\n", 76 | "\n", 77 | "$$\n", 78 | "H |x\\rangle = A^\\dagger(I - |b\\rangle\\langle b|) A |x\\rangle = A^\\dagger(I - |b\\rangle\\langle b|) |b\\rangle\n", 79 | "= A^\\dagger(|b\\rangle - |b\\rangle) = 0 |x\\rangle. \n", 80 | "$$\n", 81 | "\n", 82 | "One can see that the solution is encoded in the ground state of $H$ with an eigenvalue of $0$. Then, we can use VQE to find the ground state.\n", 83 | "\n", 84 | "**Note**: Quantum solvers uaually find a normalized solution $|x\\rangle/||x||$." 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "## 3. Numerics\n", 92 | "\n", 93 | "Consider the driving function $f(x)=x$, boundary $[a,b]= [0,1]$ and boundary conditions $\\phi_a = \\phi_b=0$. Then, the analytical solution is $\\phi(x)=(x^3-x)/6$." 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 2, 99 | "metadata": { 100 | "ExecuteTime": { 101 | "end_time": "2023-09-26T04:47:28.279804Z", 102 | "start_time": "2023-09-26T04:47:26.640495Z" 103 | } 104 | }, 105 | "outputs": [], 106 | "source": [ 107 | "from IPython.display import clear_output\n", 108 | "!pip install qiskit==0.39.0\n", 109 | "clear_output()" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "### 3.0 Setup backend" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 6, 122 | "metadata": { 123 | "ExecuteTime": { 124 | "end_time": "2023-09-26T04:48:53.779234Z", 125 | "start_time": "2023-09-26T04:48:49.009493Z" 126 | } 127 | }, 128 | "outputs": [ 129 | { 130 | "name": "stderr", 131 | "output_type": "stream", 132 | "text": [ 133 | "ibmqfactory.load_account:WARNING:2023-09-26 00:48:49,246: Credentials are already in use. The existing account in the session will be replaced.\n" 134 | ] 135 | } 136 | ], 137 | "source": [ 138 | "from qiskit import QuantumCircuit, transpile\n", 139 | "from qiskit.circuit import Parameter\n", 140 | "\n", 141 | "from qiskit import IBMQ\n", 142 | "IBMQ.load_account() # Load account from disk\n", 143 | "# IBMQ.providers() # List all available providers\n", 144 | "\n", 145 | "from qiskit.providers.fake_provider import FakeGuadalupe\n", 146 | "\n", 147 | "# Noisy simulator backend\n", 148 | "noisy_sim = FakeGuadalupe()\n", 149 | "\n", 150 | "from qiskit import Aer\n", 151 | "backend = Aer.get_backend('statevector_simulator')" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "### 3.1 Encode the problem Hamiltonian" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 7, 164 | "metadata": { 165 | "ExecuteTime": { 166 | "end_time": "2023-09-26T04:48:56.315508Z", 167 | "start_time": "2023-09-26T04:48:55.995572Z" 168 | } 169 | }, 170 | "outputs": [], 171 | "source": [ 172 | "import numpy as np\n", 173 | "from scipy import sparse\n", 174 | "from scipy.sparse import diags\n", 175 | "from scipy.sparse.linalg import eigs\n", 176 | "import matplotlib.pyplot as plt\n", 177 | "plt.rcParams.update({\"font.size\": 16}) # enlarge matplotlib fonts\n", 178 | "\n", 179 | "from qiskit.opflow import MatrixOp" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 8, 185 | "metadata": { 186 | "ExecuteTime": { 187 | "end_time": "2023-09-26T04:48:58.646502Z", 188 | "start_time": "2023-09-26T04:48:58.578093Z" 189 | }, 190 | "colab": { 191 | "base_uri": "https://localhost:8080/" 192 | }, 193 | "id": "tG1j2d1-PP3O", 194 | "outputId": "c3af297d-5d30-4f13-a56f-ba76ebf8d131", 195 | "scrolled": true 196 | }, 197 | "outputs": [ 198 | { 199 | "name": "stdout", 200 | "output_type": "stream", 201 | "text": [ 202 | "Classical solution:\n", 203 | " [-0.04853869 -0.09707737 -0.14440259 -0.18930087 -0.23055876 -0.26696277\n", 204 | " -0.29729945 -0.32035532 -0.33491693 -0.3397708 -0.33370346 -0.31550146\n", 205 | " -0.28395131 -0.23783956 -0.17595273 -0.09707737]\n", 206 | "Eigenvector:\n", 207 | " [-0.04853869 -0.09707737 -0.14440259 -0.18930087 -0.23055876 -0.26696277\n", 208 | " -0.29729945 -0.32035532 -0.33491693 -0.3397708 -0.33370346 -0.31550146\n", 209 | " -0.28395131 -0.23783956 -0.17595273 -0.09707737]\n", 210 | "Lenth of Pauli String: 38\n", 211 | "SummedOp([\n", 212 | " 5.862046370967742 * IIII,\n", 213 | " -4.0 * IIIX,\n", 214 | " 0.01285282258064524 * IIIZ,\n", 215 | " IIXI,\n", 216 | " -2.0 * IIXX,\n", 217 | " -2.0 * IIYY,\n", 218 | " 0.012852822580645018 * IIZI,\n", 219 | " -0.13795362903225805 * IIZZ,\n", 220 | " 0.5 * IXXI,\n", 221 | " -1.0 * IXXX,\n", 222 | " IXYY,\n", 223 | " -1.0 * IYXY,\n", 224 | " 0.5 * IYYI,\n", 225 | " -1.0 * IYYX,\n", 226 | " 0.012852822580645185 * IZII,\n", 227 | " -0.1379536290322581 * IZIZ,\n", 228 | " -0.1379536290322581 * IZZI,\n", 229 | " 0.012852822580645185 * IZZZ,\n", 230 | " 0.25 * XXXI,\n", 231 | " -0.49838709677419357 * XXXX,\n", 232 | " 0.49838709677419357 * XXYY,\n", 233 | " 0.49838709677419357 * XYXY,\n", 234 | " -0.25 * XYYI,\n", 235 | " 0.49838709677419357 * XYYX,\n", 236 | " -0.5016129032258064 * YXXY,\n", 237 | " 0.25 * YXYI,\n", 238 | " -0.5016129032258064 * YXYX,\n", 239 | " 0.25 * YYXI,\n", 240 | " -0.5016129032258064 * YYXX,\n", 241 | " 0.5016129032258064 * YYYY,\n", 242 | " 0.01285282258064524 * ZIII,\n", 243 | " -0.13795362903225805 * ZIIZ,\n", 244 | " -0.13795362903225805 * ZIZI,\n", 245 | " 0.01285282258064524 * ZIZZ,\n", 246 | " -0.1379536290322581 * ZZII,\n", 247 | " 0.012852822580645185 * ZZIZ,\n", 248 | " 0.012852822580645185 * ZZZI,\n", 249 | " -0.1379536290322581 * ZZZZ\n", 250 | "])\n" 251 | ] 252 | } 253 | ], 254 | "source": [ 255 | "total_res = {}\n", 256 | "\n", 257 | "N = 4 # number of qubits\n", 258 | "dim = 2**N # dimension of the operator A\n", 259 | "\n", 260 | "# Setup a tridiagonal matrix\n", 261 | "k = [np.ones(dim-1), -2*np.ones(dim), np.ones(dim-1)]\n", 262 | "offset = [-1, 0, 1]\n", 263 | "A = diags(k,offset).toarray()\n", 264 | "\n", 265 | "# Setup the driving term f(x) = x\n", 266 | "b = np.linspace(0, 1, dim)\n", 267 | "h = 1/(dim-1)\n", 268 | "sampled_b = b*(h**2)\n", 269 | "bt = np.linspace(0, 1, dim)\n", 270 | "\n", 271 | "# Setup the Dirichlet B.C.s\n", 272 | "phi_a, phi_b = 0, 0\n", 273 | "sampled_b[0] -= phi_a\n", 274 | "sampled_b[dim-1] -= phi_b\n", 275 | "norm = np.linalg.norm(sampled_b)\n", 276 | "sampled_b = sampled_b/norm\n", 277 | "\n", 278 | "# Solve the linear system of equations\n", 279 | "x = np.linalg.solve(A, sampled_b)\n", 280 | "f = np.linalg.norm(x)\n", 281 | "x = x/f\n", 282 | "\n", 283 | "# Build Hamiltonian\n", 284 | "sampled_b = sampled_b.reshape([dim, 1])\n", 285 | "Hamiltonian = A@(np.eye(dim)- sampled_b@sampled_b.T)@A\n", 286 | "# print(Hamiltonian)\n", 287 | "\n", 288 | "print(\"Classical solution:\\n\", x)\n", 289 | "eig_val, eig_state = np.linalg.eig(Hamiltonian)\n", 290 | "# print(\"Eigenvalues:\\n\", eig_val)\n", 291 | "# print(min(eig_val))\n", 292 | "vec = eig_state[:,-1]\n", 293 | "# print(eig_state)\n", 294 | "print(\"Eigenvector:\\n\", -vec)\n", 295 | "\n", 296 | "# Transform into Pauli operators\n", 297 | "H_op = MatrixOp(Hamiltonian).to_pauli_op()\n", 298 | "print(\"Lenth of Pauli String:\",len(H_op))\n", 299 | "print(H_op)" 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "### 3.2 Ansatz design" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 9, 312 | "metadata": { 313 | "ExecuteTime": { 314 | "end_time": "2023-09-26T04:49:03.988611Z", 315 | "start_time": "2023-09-26T04:49:03.631645Z" 316 | } 317 | }, 318 | "outputs": [ 319 | { 320 | "data": { 321 | "text/html": [ 322 | "
     ┌──────────┐┌──────────┐     ┌──────────┐┌───────────┐                          ┌───────────┐┌───────────┐                          ┌───────────┐┌───────────┐                          ┌───────────┐┌───────────┐                                    \n",
323 |        "q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[4]) ├──■──┤ Ry(θ[8]) ├┤ Rz(θ[12]) ├───────────────────■──────┤ Ry(θ[16]) ├┤ Rz(θ[20]) ├───────────────────■──────┤ Ry(θ[24]) ├┤ Rz(θ[28]) ├───────────────────■──────┤ Ry(θ[32]) ├┤ Rz(θ[36]) ├───────────────────■────────────────\n",
324 |        "     ├──────────┤├──────────┤┌─┴─┐└──────────┘└┬──────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐              \n",
325 |        "q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[5]) ├┤ X ├─────■───────┤ Ry(θ[9]) ├┤ Rz(θ[13]) ├────┤ X ├──────────■──────┤ Ry(θ[17]) ├┤ Rz(θ[21]) ├────┤ X ├──────────■──────┤ Ry(θ[25]) ├┤ Rz(θ[29]) ├────┤ X ├──────────■──────┤ Ry(θ[33]) ├┤ Rz(θ[37]) ├────┤ X ├──────■───────\n",
326 |        "     ├──────────┤├──────────┤└───┘   ┌─┴─┐     └──────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐┌─┴─┐     \n",
327 |        "q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[6]) ├────────┤ X ├──────────■──────┤ Ry(θ[10]) ├┤ Rz(θ[14]) ├────┤ X ├──────────■──────┤ Ry(θ[18]) ├┤ Rz(θ[22]) ├────┤ X ├──────────■──────┤ Ry(θ[26]) ├┤ Rz(θ[30]) ├────┤ X ├──────────■──────┤ Ry(θ[34]) ├┤ Rz(θ[38]) ├┤ X ├──■──\n",
328 |        "     ├──────────┤├──────────┤        └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤└───┘┌─┴─┐\n",
329 |        "q_3: ┤ Ry(θ[3]) ├┤ Rz(θ[7]) ├─────────────────────┤ X ├────┤ Ry(θ[11]) ├┤ Rz(θ[15]) ├─────────────────┤ X ├────┤ Ry(θ[19]) ├┤ Rz(θ[23]) ├─────────────────┤ X ├────┤ Ry(θ[27]) ├┤ Rz(θ[31]) ├─────────────────┤ X ├────┤ Ry(θ[35]) ├┤ Rz(θ[39]) ├─────┤ X ├\n",
330 |        "     └──────────┘└──────────┘                     └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘     └───┘
" 331 | ], 332 | "text/plain": [ 333 | " ┌──────────┐┌──────────┐ ┌──────────┐┌───────────┐ ┌───────────┐┌───────────┐ ┌───────────┐┌───────────┐ ┌───────────┐┌───────────┐ \n", 334 | "q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[4]) ├──■──┤ Ry(θ[8]) ├┤ Rz(θ[12]) ├───────────────────■──────┤ Ry(θ[16]) ├┤ Rz(θ[20]) ├───────────────────■──────┤ Ry(θ[24]) ├┤ Rz(θ[28]) ├───────────────────■──────┤ Ry(θ[32]) ├┤ Rz(θ[36]) ├───────────────────■────────────────\n", 335 | " ├──────────┤├──────────┤┌─┴─┐└──────────┘└┬──────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ \n", 336 | "q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[5]) ├┤ X ├─────■───────┤ Ry(θ[9]) ├┤ Rz(θ[13]) ├────┤ X ├──────────■──────┤ Ry(θ[17]) ├┤ Rz(θ[21]) ├────┤ X ├──────────■──────┤ Ry(θ[25]) ├┤ Rz(θ[29]) ├────┤ X ├──────────■──────┤ Ry(θ[33]) ├┤ Rz(θ[37]) ├────┤ X ├──────■───────\n", 337 | " ├──────────┤├──────────┤└───┘ ┌─┴─┐ └──────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐┌─┴─┐ \n", 338 | "q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[6]) ├────────┤ X ├──────────■──────┤ Ry(θ[10]) ├┤ Rz(θ[14]) ├────┤ X ├──────────■──────┤ Ry(θ[18]) ├┤ Rz(θ[22]) ├────┤ X ├──────────■──────┤ Ry(θ[26]) ├┤ Rz(θ[30]) ├────┤ X ├──────────■──────┤ Ry(θ[34]) ├┤ Rz(θ[38]) ├┤ X ├──■──\n", 339 | " ├──────────┤├──────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤└───┘┌─┴─┐\n", 340 | "q_3: ┤ Ry(θ[3]) ├┤ Rz(θ[7]) ├─────────────────────┤ X ├────┤ Ry(θ[11]) ├┤ Rz(θ[15]) ├─────────────────┤ X ├────┤ Ry(θ[19]) ├┤ Rz(θ[23]) ├─────────────────┤ X ├────┤ Ry(θ[27]) ├┤ Rz(θ[31]) ├─────────────────┤ X ├────┤ Ry(θ[35]) ├┤ Rz(θ[39]) ├─────┤ X ├\n", 341 | " └──────────┘└──────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘" 342 | ] 343 | }, 344 | "execution_count": 9, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "from qiskit.circuit.library import EfficientSU2\n", 351 | "\n", 352 | "depth = 5 # depth of ansatz\n", 353 | "ansatz = EfficientSU2(N, entanglement='linear', reps=depth, skip_final_rotation_layer=True).decompose()\n", 354 | "ansatz.draw(fold=300)" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "### 3.3 Transpile" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": 16, 367 | "metadata": { 368 | "ExecuteTime": { 369 | "end_time": "2023-09-26T04:51:01.568999Z", 370 | "start_time": "2023-09-26T04:51:01.528723Z" 371 | }, 372 | "scrolled": false 373 | }, 374 | "outputs": [ 375 | { 376 | "name": "stdout", 377 | "output_type": "stream", 378 | "text": [ 379 | "number and type of gates in the cirucit: OrderedDict([('ry', 20), ('rz', 20), ('cx', 15)])\n", 380 | "number of parameters in the circuit: 40\n" 381 | ] 382 | }, 383 | { 384 | "data": { 385 | "text/html": [ 386 | "
     ┌──────────┐┌──────────┐     ┌──────────┐┌───────────┐                          ┌───────────┐┌───────────┐                          ┌───────────┐┌───────────┐                          ┌───────────┐┌───────────┐                                    \n",
387 |        "q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[4]) ├──■──┤ Ry(θ[8]) ├┤ Rz(θ[12]) ├───────────────────■──────┤ Ry(θ[16]) ├┤ Rz(θ[20]) ├───────────────────■──────┤ Ry(θ[24]) ├┤ Rz(θ[28]) ├───────────────────■──────┤ Ry(θ[32]) ├┤ Rz(θ[36]) ├───────────────────■────────────────\n",
388 |        "     ├──────────┤├──────────┤┌─┴─┐└──────────┘└┬──────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐    └───────────┘├───────────┤┌───────────┐    ┌─┴─┐              \n",
389 |        "q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[5]) ├┤ X ├─────■───────┤ Ry(θ[9]) ├┤ Rz(θ[13]) ├────┤ X ├──────────■──────┤ Ry(θ[17]) ├┤ Rz(θ[21]) ├────┤ X ├──────────■──────┤ Ry(θ[25]) ├┤ Rz(θ[29]) ├────┤ X ├──────────■──────┤ Ry(θ[33]) ├┤ Rz(θ[37]) ├────┤ X ├──────■───────\n",
390 |        "     ├──────────┤├──────────┤└───┘   ┌─┴─┐     └──────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐    ┌─┴─┐    └───────────┘├───────────┤┌───┴───┴───┐┌─┴─┐     \n",
391 |        "q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[6]) ├────────┤ X ├──────────■──────┤ Ry(θ[10]) ├┤ Rz(θ[14]) ├────┤ X ├──────────■──────┤ Ry(θ[18]) ├┤ Rz(θ[22]) ├────┤ X ├──────────■──────┤ Ry(θ[26]) ├┤ Rz(θ[30]) ├────┤ X ├──────────■──────┤ Ry(θ[34]) ├┤ Rz(θ[38]) ├┤ X ├──■──\n",
392 |        "     ├──────────┤├──────────┤        └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤    └───┘        ┌─┴─┐    ├───────────┤├───────────┤└───┘┌─┴─┐\n",
393 |        "q_3: ┤ Ry(θ[3]) ├┤ Rz(θ[7]) ├─────────────────────┤ X ├────┤ Ry(θ[11]) ├┤ Rz(θ[15]) ├─────────────────┤ X ├────┤ Ry(θ[19]) ├┤ Rz(θ[23]) ├─────────────────┤ X ├────┤ Ry(θ[27]) ├┤ Rz(θ[31]) ├─────────────────┤ X ├────┤ Ry(θ[35]) ├┤ Rz(θ[39]) ├─────┤ X ├\n",
394 |        "     └──────────┘└──────────┘                     └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘                 └───┘    └───────────┘└───────────┘     └───┘
" 395 | ], 396 | "text/plain": [ 397 | " ┌──────────┐┌──────────┐ ┌──────────┐┌───────────┐ ┌───────────┐┌───────────┐ ┌───────────┐┌───────────┐ ┌───────────┐┌───────────┐ \n", 398 | "q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[4]) ├──■──┤ Ry(θ[8]) ├┤ Rz(θ[12]) ├───────────────────■──────┤ Ry(θ[16]) ├┤ Rz(θ[20]) ├───────────────────■──────┤ Ry(θ[24]) ├┤ Rz(θ[28]) ├───────────────────■──────┤ Ry(θ[32]) ├┤ Rz(θ[36]) ├───────────────────■────────────────\n", 399 | " ├──────────┤├──────────┤┌─┴─┐└──────────┘└┬──────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ └───────────┘├───────────┤┌───────────┐ ┌─┴─┐ \n", 400 | "q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[5]) ├┤ X ├─────■───────┤ Ry(θ[9]) ├┤ Rz(θ[13]) ├────┤ X ├──────────■──────┤ Ry(θ[17]) ├┤ Rz(θ[21]) ├────┤ X ├──────────■──────┤ Ry(θ[25]) ├┤ Rz(θ[29]) ├────┤ X ├──────────■──────┤ Ry(θ[33]) ├┤ Rz(θ[37]) ├────┤ X ├──────■───────\n", 401 | " ├──────────┤├──────────┤└───┘ ┌─┴─┐ └──────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐ ┌─┴─┐ └───────────┘├───────────┤┌───┴───┴───┐┌─┴─┐ \n", 402 | "q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[6]) ├────────┤ X ├──────────■──────┤ Ry(θ[10]) ├┤ Rz(θ[14]) ├────┤ X ├──────────■──────┤ Ry(θ[18]) ├┤ Rz(θ[22]) ├────┤ X ├──────────■──────┤ Ry(θ[26]) ├┤ Rz(θ[30]) ├────┤ X ├──────────■──────┤ Ry(θ[34]) ├┤ Rz(θ[38]) ├┤ X ├──■──\n", 403 | " ├──────────┤├──────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤ └───┘ ┌─┴─┐ ├───────────┤├───────────┤└───┘┌─┴─┐\n", 404 | "q_3: ┤ Ry(θ[3]) ├┤ Rz(θ[7]) ├─────────────────────┤ X ├────┤ Ry(θ[11]) ├┤ Rz(θ[15]) ├─────────────────┤ X ├────┤ Ry(θ[19]) ├┤ Rz(θ[23]) ├─────────────────┤ X ├────┤ Ry(θ[27]) ├┤ Rz(θ[31]) ├─────────────────┤ X ├────┤ Ry(θ[35]) ├┤ Rz(θ[39]) ├─────┤ X ├\n", 405 | " └──────────┘└──────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘ └───────────┘└───────────┘ └───┘" 406 | ] 407 | }, 408 | "execution_count": 16, 409 | "metadata": {}, 410 | "output_type": "execute_result" 411 | } 412 | ], 413 | "source": [ 414 | "ansatz_opt = transpile(ansatz, backend=backend, optimization_level=3)\n", 415 | "\n", 416 | "print('number and type of gates in the cirucit:', ansatz_opt.count_ops())\n", 417 | "print('number of parameters in the circuit:', ansatz_opt.num_parameters)\n", 418 | "ansatz_opt.draw(fold=300)" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "### 3.4 Optimizer" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": 17, 431 | "metadata": { 432 | "ExecuteTime": { 433 | "end_time": "2023-09-26T04:51:04.390962Z", 434 | "start_time": "2023-09-26T04:51:04.382428Z" 435 | } 436 | }, 437 | "outputs": [], 438 | "source": [ 439 | "from qiskit.algorithms.optimizers import SPSA, COBYLA, L_BFGS_B, NELDER_MEAD, SLSQP, ADAM, AQGD, CG, POWELL, QNSPSA\n", 440 | "\n", 441 | "# optimizer = SPSA(maxiter=500)\n", 442 | "optimizer = L_BFGS_B(maxiter=5000)\n", 443 | "# optimizer = ADAM(maxiter=200, lr=0.2)\n", 444 | "# optimizer = AQGD(maxiter=1000, eta=1.0, tol=1e-06, momentum=0.25, param_tol=1e-06, averaging=10)\n", 445 | "# optimizer = POWELL()\n", 446 | "# optimizer = COBYLA(maxiter=10000)\n", 447 | "# optimizer = SLSQP(maxiter=10000)" 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": {}, 453 | "source": [ 454 | "### 3.5 Define VQE program" 455 | ] 456 | }, 457 | { 458 | "cell_type": "code", 459 | "execution_count": 18, 460 | "metadata": { 461 | "ExecuteTime": { 462 | "end_time": "2023-09-26T04:51:05.760036Z", 463 | "start_time": "2023-09-26T04:51:05.735225Z" 464 | } 465 | }, 466 | "outputs": [], 467 | "source": [ 468 | "from qiskit.utils import QuantumInstance\n", 469 | "from qiskit.algorithms import VQE\n", 470 | "\n", 471 | "quantum_instance = QuantumInstance(backend=backend, seed_simulator=28, seed_transpiler=28,\n", 472 | " basis_gates=None,\n", 473 | " optimization_level=3)" 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": 23, 479 | "metadata": { 480 | "ExecuteTime": { 481 | "end_time": "2023-09-26T04:53:43.556984Z", 482 | "start_time": "2023-09-26T04:53:12.942913Z" 483 | } 484 | }, 485 | "outputs": [ 486 | { 487 | "name": "stdout", 488 | "output_type": "stream", 489 | "text": [ 490 | "[-0.0493348 -0.09796455 -0.14599025 -0.19196375 -0.23355753 -0.26817149\n", 491 | " -0.29595613 -0.31682692 -0.3305809 -0.33576174 -0.33128343 -0.31572619\n", 492 | " -0.28691542 -0.24269034 -0.1809713 -0.09975125]\n", 493 | "Current round using ansatz TwoLocal with depth 5, found eigenvalue 0.000100065994558574. Best so far 0.000100065994558574\n" 494 | ] 495 | } 496 | ], 497 | "source": [ 498 | "best_result = 99999\n", 499 | "\n", 500 | "vqe = VQE(ansatz_opt, optimizer,quantum_instance=quantum_instance,initial_point=2*np.pi*np.random.rand(ansatz_opt.num_parameters))\n", 501 | "result = vqe.compute_minimum_eigenvalue(H_op)\n", 502 | "quantum_solution = -1*np.abs(result.eigenstate).real\n", 503 | "print(quantum_solution)\n", 504 | "\n", 505 | "if result.eigenvalue.real < best_result:\n", 506 | " best_result = result.eigenvalue.real\n", 507 | " kept_result = result\n", 508 | "print(\"Current round using ansatz TwoLocal with depth {}, found eigenvalue {}. Best so far {}\".format(depth, result.eigenvalue.real,best_result))\n", 509 | "total_res.update({(N, depth):kept_result})" 510 | ] 511 | }, 512 | { 513 | "cell_type": "markdown", 514 | "metadata": { 515 | "id": "QYVEEusrcJny" 516 | }, 517 | "source": [ 518 | "### 3.7 Benchmark with analytical solution" 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": 24, 524 | "metadata": { 525 | "ExecuteTime": { 526 | "end_time": "2023-09-26T04:54:41.648535Z", 527 | "start_time": "2023-09-26T04:54:41.485176Z" 528 | }, 529 | "colab": { 530 | "base_uri": "https://localhost:8080/", 531 | "height": 295 532 | }, 533 | "id": "qkxcXsCsN-oH", 534 | "outputId": "dd1ef506-0ab1-428b-bd66-ac76b0954c70" 535 | }, 536 | "outputs": [ 537 | { 538 | "data": { 539 | "image/png": "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", 540 | "text/plain": [ 541 | "
" 542 | ] 543 | }, 544 | "metadata": {}, 545 | "output_type": "display_data" 546 | } 547 | ], 548 | "source": [ 549 | "t = np.arange(0., 1., 0.02)\n", 550 | "res = (t**3-t)/6\n", 551 | "norm_res = np.linalg.norm(res)\n", 552 | "res_norm = res/norm_res\n", 553 | "\n", 554 | "xt = np.arange(0,1,1/dim)\n", 555 | "exact = [1/6*(x**3-x) for x in np.arange(0,1,1/dim)]\n", 556 | "norm = np.linalg.norm(exact)\n", 557 | "exact = exact/norm\n", 558 | "\n", 559 | "# red dashes, blue squares and green triangles\n", 560 | "plt.plot(t, res_norm, 'r-', label='analytical')\n", 561 | "plt.plot(bt, x, 'o-.', label='classical')\n", 562 | "plt.plot(bt, quantum_solution, 'gx--', label='quantum')\n", 563 | "# plt.legend()\n", 564 | "plt.legend(loc=\"lower left\")\n", 565 | "plt.xlabel('Boundary [0,1]')\n", 566 | "plt.ylabel('Solution Profile')\n", 567 | "plt.title(\"4-qubit VQE for Poisson Eqn, TwoLocal, BFGS\")\n", 568 | "plt.grid(linestyle = '--', linewidth = 0.5)\n", 569 | "# plt.show()\n", 570 | "# plt.savefig(\"Poisson.png\", bbox_inches='tight', dpi=300)" 571 | ] 572 | }, 573 | { 574 | "cell_type": "code", 575 | "execution_count": 25, 576 | "metadata": { 577 | "ExecuteTime": { 578 | "end_time": "2023-09-26T04:54:47.574890Z", 579 | "start_time": "2023-09-26T04:54:47.499539Z" 580 | }, 581 | "id": "cGJ8L6j6YScY" 582 | }, 583 | "outputs": [ 584 | { 585 | "data": { 586 | "text/html": [ 587 | "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.6.0
qiskit-ibmq-provider0.19.2
qiskit0.39.0
System information
Python version3.8.17
Python compilerClang 14.0.6
Python builddefault, Jul 5 2023 16:18:40
OSDarwin
CPUs8
Memory (Gb)16.0
Tue Sep 26 00:54:47 2023 EDT
" 588 | ], 589 | "text/plain": [ 590 | "" 591 | ] 592 | }, 593 | "metadata": {}, 594 | "output_type": "display_data" 595 | } 596 | ], 597 | "source": [ 598 | "import qiskit.tools.jupyter\n", 599 | "%qiskit_version_table" 600 | ] 601 | }, 602 | { 603 | "cell_type": "code", 604 | "execution_count": null, 605 | "metadata": {}, 606 | "outputs": [], 607 | "source": [] 608 | } 609 | ], 610 | "metadata": { 611 | "colab": { 612 | "provenance": [] 613 | }, 614 | "gpuClass": "standard", 615 | "kernelspec": { 616 | "display_name": "Python 3 (ipykernel)", 617 | "language": "python", 618 | "name": "python3" 619 | }, 620 | "language_info": { 621 | "codemirror_mode": { 622 | "name": "ipython", 623 | "version": 3 624 | }, 625 | "file_extension": ".py", 626 | "mimetype": "text/x-python", 627 | "name": "python", 628 | "nbconvert_exporter": "python", 629 | "pygments_lexer": "ipython3", 630 | "version": "3.8.17" 631 | }, 632 | "toc": { 633 | "base_numbering": 1, 634 | "nav_menu": {}, 635 | "number_sections": true, 636 | "sideBar": true, 637 | "skip_h1_title": false, 638 | "title_cell": "Table of Contents", 639 | "title_sidebar": "Contents", 640 | "toc_cell": false, 641 | "toc_position": {}, 642 | "toc_section_display": true, 643 | "toc_window_display": false 644 | }, 645 | "varInspector": { 646 | "cols": { 647 | "lenName": 16, 648 | "lenType": 16, 649 | "lenVar": 40 650 | }, 651 | "kernels_config": { 652 | "python": { 653 | "delete_cmd_postfix": "", 654 | "delete_cmd_prefix": "del ", 655 | "library": "var_list.py", 656 | "varRefreshCmd": "print(var_dic_list())" 657 | }, 658 | "r": { 659 | "delete_cmd_postfix": ") ", 660 | "delete_cmd_prefix": "rm(", 661 | "library": "var_list.r", 662 | "varRefreshCmd": "cat(var_dic_list()) " 663 | } 664 | }, 665 | "types_to_exclude": [ 666 | "module", 667 | "function", 668 | "builtin_function_or_method", 669 | "instance", 670 | "_Feature" 671 | ], 672 | "window_display": false 673 | } 674 | }, 675 | "nbformat": 4, 676 | "nbformat_minor": 1 677 | } 678 | -------------------------------------------------------------------------------- /slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/comp-physics/qce23-qpde-tutorial/10e8c1f090571f96d856fd1eb9967a36adc0d014/slides.pdf --------------------------------------------------------------------------------