├── LICENSE ├── README.md ├── ibmq-qsim-challenge.ipynb ├── ibmq-qsim-sup-mat.ipynb ├── qiskit-default-winning-submission.zip └── qiskit-pulse-winning-submission.zip /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright 2021 IBM and its contributors. 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # IBM Quantum Awards: Open Science Prize 2021 2 | 3 | IBM Quantum is excited to announce the fourth annual quantum awards (and the second annual Open Science Prize)—an award for those who can present an open source solution to some of the most pressing problems in the field of quantum computing. 4 | 5 | This year, the challenge will feature one problem from the field of quantum simulation, solvable through one of two approaches. The best open source solution to each approach will receive a $40,000 prize, and the winner overall will receive another $20,000. 6 | 7 | Simulating physical systems on quantum computers is a promising application of near-term quantum processors. This year's problem asks participants to simulate a Heisenberg model Hamiltonian for three interacting atoms on IBM Quantum's 7-qubit Jakarta system. The goal is to simulate the evolution of a known quantum state with the best fidelity as possible using Trotterization. 8 | 9 | **Read more at our [blog](https://www.research.ibm.com/blog/quantum-open-science-prize) and register [here](https://ibmquantumawards.bemyapp.com)**. 10 | 11 | The competition will conclude and judging will commence on April 16, 2022. 12 | 13 | Participants must choose one solution method and may submit their answer using 1) Qiskit Pulse or 2) solving the problem using Qiskit defaults, as outlined below: 14 | 15 | - Each team or participant may only contribute to one submission 16 | - Solution may only be executed on the designated device (ibmq_jakarta) 17 | - Each submission must use Trotterization to evolve the specified state, under the specified Hamiltonian, for the specified duration (as outlined in the included Jupyter Notebook) with at least 4 Trotter steps. 18 | - Only use Open Pulse and or pulsed gates functionality as outlined in the included Jupyter notebooks. 19 | - Only use libraries that can be installed using either pip install or conda install and no purchased libraries. 20 | - Document code with concise, clear language about the chosen methodology. 21 | - State tomography fidelity (for 4 or more trotter steps) must meet a minimum value of 30%. 22 | 23 | The submissions will be judged on the following criteria: 24 | - Performance as measured by the state tomography fidelity in comparison to other submissions (Max 15 points) 25 | - Clarity of provided documentation and solution code (Max 5 points) 26 | - Creativity in developing a unique, innovative, and original solution (Max 5 points) 27 | -------------------------------------------------------------------------------- /ibmq-qsim-challenge.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 Open Science Prize 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 and competing in the Open Science Prize. Continuing from Section 1, the notebook showns an example solution." 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "id": "d1548b05-e691-40a5-8b35-c0eaa87a2a72", 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "import numpy as np\n", 30 | "import matplotlib.pyplot as plt\n", 31 | "plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts\n", 32 | "\n", 33 | "# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)\n", 34 | "from qiskit.opflow import Zero, One, I, X, Y, Z\n", 35 | "\n", 36 | "# Suppress warnings\n", 37 | "import warnings\n", 38 | "warnings.filterwarnings('ignore')" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "id": "c764af20-017f-4209-9483-4f89f10cb562", 44 | "metadata": {}, 45 | "source": [ 46 | "### 1-2 The $XXX$ Heisenberg Spin Model\n", 47 | "\n", 48 | "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 Open Science Prize, you will work with the $XXX$ Heisenberg Hamiltonian $H_{\\text{Heis}}$ as defined below\n", 49 | "\n", 50 | "$$\n", 51 | "\\begin{equation}\n", 52 | "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", 53 | "\\end{equation}\n", 54 | "$$\n", 55 | "\n", 56 | "$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", 57 | "\n", 58 | "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", 59 | "$$\n", 60 | "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", 61 | "$$\n", 62 | "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", 63 | "\n", 64 | "*See the supplementary material for further details on $H_{\\text{Heis}}$, $H_{\\text{Heis3}}$ and its matrix repsentation.*" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 2, 70 | "id": "e6d371fd-f5c4-446a-83f4-ac7593fdcee1", 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "# Returns the matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line\n", 75 | "def H_heis3():\n", 76 | " # Interactions (I is the identity matrix; X, Y, and Z are Pauli matricies; ^ is a tensor product)\n", 77 | " XXs = (I^X^X) + (X^X^I)\n", 78 | " YYs = (I^Y^Y) + (Y^Y^I)\n", 79 | " ZZs = (I^Z^Z) + (Z^Z^I)\n", 80 | " \n", 81 | " # Sum interactions\n", 82 | " H = XXs + YYs + ZZs\n", 83 | " \n", 84 | " # Return Hamiltonian\n", 85 | " return H" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "id": "35323a1f-9aac-493a-87a8-116c3b7980ca", 91 | "metadata": {}, 92 | "source": [ 93 | "### 1-3 Time Evolution\n", 94 | "\n", 95 | "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", 96 | "$$\n", 97 | "i\\hbar \\dfrac{d}{dt}|\\psi(t)\\rangle = H |\\psi(t)\\rangle\n", 98 | "$$\n", 99 | "\n", 100 | "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", 101 | "$$\n", 102 | "\\begin{align}\n", 103 | "U_{\\text{Heis3}}(t) &= e^{-it H_\\text{Heis3}} = \\exp\\left(-it H_\\text{Heis3}\\right) \\\\\n", 104 | "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", 105 | "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", 106 | "\\end{align}\n", 107 | "$$.\n", 108 | "\n", 109 | "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", 110 | "\n", 111 | "*See the supplementary material for more information on exponentiating an operator or matrix.*" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 3, 117 | "id": "ccdedbc8-f335-468c-9db5-b594aa2e50bd", 118 | "metadata": {}, 119 | "outputs": [], 120 | "source": [ 121 | "# 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", 122 | "def U_heis3(t):\n", 123 | " # Compute XXX Hamiltonian for 3 spins in a line\n", 124 | " H = H_heis3()\n", 125 | " \n", 126 | " # Return the exponential of -i multipled by time t multipled by the 3 spin XXX Heisenberg Hamilonian \n", 127 | " return (t * H).exp_i()" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "id": "1668a459-1c19-4769-9263-ff0d8de330af", 133 | "metadata": {}, 134 | "source": [ 135 | "### 1-4 Classical Simulation of $H_{\\text{Heis3}}$\n", 136 | "\n", 137 | "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", 138 | "\n", 139 | "(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.)" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 4, 145 | "id": "0813fede-9945-4477-9304-9f9891ce50a7", 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "data": { 150 | "image/png": "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\n", 151 | "text/plain": [ 152 | "
" 153 | ] 154 | }, 155 | "metadata": { 156 | "needs_background": "light" 157 | }, 158 | "output_type": "display_data" 159 | } 160 | ], 161 | "source": [ 162 | "# Define array of time points\n", 163 | "ts = np.linspace(0, np.pi, 100)\n", 164 | "\n", 165 | "# Define initial state |110>\n", 166 | "initial_state = One^One^Zero\n", 167 | "\n", 168 | "# Compute probability of remaining in |110> state over the array of time points\n", 169 | " # ~initial_state gives the bra of the initial state (<110|)\n", 170 | " # @ is short hand for matrix multiplication\n", 171 | " # U_heis3(t) is the unitary time evolution at time t\n", 172 | " # t needs to be wrapped with float(t) to avoid a bug\n", 173 | " # (...).eval() returns the inner product <110|U_heis3(t)|110>\n", 174 | " # np.abs(...)**2 is the modulus squared of the innner product which is the expectation value, or probability, of remaining in |110>\n", 175 | "probs_110 = [np.abs((~initial_state @ U_heis3(float(t)) @ initial_state).eval())**2 for t in ts]\n", 176 | "\n", 177 | "# Plot evolution of |110>\n", 178 | "plt.plot(ts, probs_110)\n", 179 | "plt.xlabel('time')\n", 180 | "plt.ylabel(r'probability of state $|110\\rangle$')\n", 181 | "plt.title(r'Evolution of state $|110\\rangle$ under $H_{Heis3}$')\n", 182 | "plt.grid()\n", 183 | "plt.show()" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "id": "04db5341-8ba0-433b-b671-d929aba1fbe0", 189 | "metadata": {}, 190 | "source": [ 191 | "### 1-5 Decomposition of $U_{\\text{Heis3}}(t)$ Into Quantum Gates\n", 192 | "\n", 193 | "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 Open Science Prize, 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", 194 | "\n", 195 | "Below, we show an example Trotterization as outlined in \\[1-2\\].\n", 196 | "\n", 197 | "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", 198 | "\n", 199 | "$$\n", 200 | "U_{\\text{Heis3}}(t) = \\exp\\left[-i t \\left(H^{(0,1)}_{\\text{Heis2}} + H^{(1,2)}_{\\text{Heis2}} \\right)\\right].\n", 201 | "$$\n", 202 | "\n", 203 | "$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", 204 | "\n", 205 | "$$\n", 206 | "\\begin{align}\n", 207 | "U_{\\text{Heis3}}(t) &= \\exp\\left[-i t \\left(H^{(0,1)}_{\\text{Heis2}} + H^{(1,2)}_{\\text{Heis2}} \\right)\\right] \\\\\n", 208 | "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", 209 | "\\end{align}\n", 210 | "$$\n", 211 | "\n", 212 | "$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", 213 | "\n", 214 | "$$\n", 215 | "\\begin{align}\n", 216 | "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", 217 | "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", 218 | "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", 219 | "\\end{align}\n", 220 | "$$\n", 221 | "\n", 222 | "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", 223 | "$$\n", 224 | "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", 225 | "$$\n", 226 | "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", 227 | "\n", 228 | "\n", 229 | "\\[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", 230 | "\n", 231 | "\\[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" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "id": "509e3761-6196-4b8f-aa5d-434bf1070eeb", 237 | "metadata": {}, 238 | "source": [ 239 | "# 2 The Open Science Prize\n", 240 | "### 2-1 Contest Details\n", 241 | "The Open Science Prize requirements and judging criteria can be found in the terms and conditions when registering on the [website](https://ibmquantumawards.bemyapp.com/#/event). Below is an outline of those requirements.\n", 242 | "\n", 243 | "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." 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "id": "c794b8f1-6de7-497b-a000-0b37f9d094b3", 249 | "metadata": {}, 250 | "source": [ 251 | "### 2-2 Import Qiskit\n", 252 | "\n", 253 | "Feel free to import packages as needed. However, only free packages and those obtained through ```pip install``` or ```conda install``` are allowed." 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 5, 259 | "id": "8b3e598e-1156-4263-abc6-890e554cf4fb", 260 | "metadata": {}, 261 | "outputs": [], 262 | "source": [ 263 | "# Importing standard Qiskit modules\n", 264 | "from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile\n", 265 | "from qiskit.providers.aer import QasmSimulator\n", 266 | "from qiskit.tools.monitor import job_monitor\n", 267 | "from qiskit.circuit import Parameter\n", 268 | "\n", 269 | "# Import state tomography modules\n", 270 | "from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter\n", 271 | "from qiskit.quantum_info import state_fidelity\n", 272 | "\n", 273 | "# suppress warnings\n", 274 | "import warnings\n", 275 | "warnings.filterwarnings('ignore')" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "id": "900d2ab8-b568-4d28-87d8-473962fdc998", 281 | "metadata": {}, 282 | "source": [ 283 | "### 2-3 Quantum Devices\n", 284 | "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." 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 6, 290 | "id": "7345d1e9-4803-4bd8-a578-0af5294cb22a", 291 | "metadata": {}, 292 | "outputs": [], 293 | "source": [ 294 | "# load IBMQ Account data\n", 295 | "\n", 296 | "# IBMQ.save_account(TOKEN) # replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n", 297 | "provider = IBMQ.load_account()" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 7, 303 | "id": "78e0af5d-6da9-4a08-912a-5a172535e03b", 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | "# Get backend for experiment\n", 308 | "provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n", 309 | "jakarta = provider.get_backend('ibmq_jakarta')\n", 310 | "# properties = jakarta.properties()\n", 311 | "\n", 312 | "# Simulated backend based on ibmq_jakarta's device noise profile\n", 313 | "sim_noisy_jakarta = QasmSimulator.from_backend(provider.get_backend('ibmq_jakarta'))\n", 314 | "\n", 315 | "# Noiseless simulated backend\n", 316 | "sim = QasmSimulator()" 317 | ] 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "id": "d4e8a24c-5846-4de9-95ea-3033653c4037", 322 | "metadata": {}, 323 | "source": [ 324 | "### 2-4 Decomposition of $U_{\\text{Heis3}}(t)$ into Quantum Gates (Example)\n", 325 | "\n", 326 | "The following circuit code is written based on the example given in Section 1. This is where you write your solution." 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "id": "207beaa7-58e9-40c1-a35c-f359ddb7aa8b", 332 | "metadata": {}, 333 | "source": [ 334 | "YOUR TROTTERIZATION GOES HERE -- START (beginning of example)" 335 | ] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": 8, 340 | "id": "9156980e-d3a7-4494-8ad4-7ec15ca92e7f", 341 | "metadata": {}, 342 | "outputs": [], 343 | "source": [ 344 | "# Parameterize variable t to be evaluated at t=pi later\n", 345 | "t = Parameter('t')" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 9, 351 | "id": "ec328a9f-809c-49d6-8400-fa09579c1d8c", 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [ 355 | "# Build a subcircuit for XX(t) two-qubit gate\n", 356 | "XX_qr = QuantumRegister(2)\n", 357 | "XX_qc = QuantumCircuit(XX_qr, name='XX')\n", 358 | "\n", 359 | "XX_qc.ry(np.pi/2,[0,1])\n", 360 | "XX_qc.cnot(0,1)\n", 361 | "XX_qc.rz(2 * t, 1)\n", 362 | "XX_qc.cnot(0,1)\n", 363 | "XX_qc.ry(-np.pi/2,[0,1])\n", 364 | "\n", 365 | "# Convert custom quantum circuit into a gate\n", 366 | "XX = XX_qc.to_instruction()" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 10, 372 | "id": "52977709-1b68-4ebf-98de-dc5c88265acb", 373 | "metadata": {}, 374 | "outputs": [], 375 | "source": [ 376 | "# Build a subcircuit for YY(t) two-qubit gate\n", 377 | "YY_qr = QuantumRegister(2)\n", 378 | "YY_qc = QuantumCircuit(YY_qr, name='YY')\n", 379 | "\n", 380 | "YY_qc.rx(np.pi/2,[0,1])\n", 381 | "YY_qc.cnot(0,1)\n", 382 | "YY_qc.rz(2 * t, 1)\n", 383 | "YY_qc.cnot(0,1)\n", 384 | "YY_qc.rx(-np.pi/2,[0,1])\n", 385 | "\n", 386 | "# Convert custom quantum circuit into a gate\n", 387 | "YY = YY_qc.to_instruction()" 388 | ] 389 | }, 390 | { 391 | "cell_type": "code", 392 | "execution_count": 11, 393 | "id": "4fd739df-0dc4-48ef-823e-230fb0c8fd64", 394 | "metadata": {}, 395 | "outputs": [], 396 | "source": [ 397 | "# Build a subcircuit for ZZ(t) two-qubit gate\n", 398 | "ZZ_qr = QuantumRegister(2)\n", 399 | "ZZ_qc = QuantumCircuit(ZZ_qr, name='ZZ')\n", 400 | "\n", 401 | "ZZ_qc.cnot(0,1)\n", 402 | "ZZ_qc.rz(2 * t, 1)\n", 403 | "ZZ_qc.cnot(0,1)\n", 404 | "\n", 405 | "# Convert custom quantum circuit into a gate\n", 406 | "ZZ = ZZ_qc.to_instruction()" 407 | ] 408 | }, 409 | { 410 | "cell_type": "markdown", 411 | "id": "4335d6d3-4a8e-4140-aad0-97b9b189905a", 412 | "metadata": {}, 413 | "source": [ 414 | "Combine subcircuits into single gate representing one ($n=1$) trotter step." 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": 12, 420 | "id": "8ef03f79-2c47-49da-93d5-0c0ae3ea5872", 421 | "metadata": {}, 422 | "outputs": [], 423 | "source": [ 424 | "# Combine subcircuits into a single multiqubit gate representing a single trotter step\n", 425 | "num_qubits = 3\n", 426 | "\n", 427 | "Trot_qr = QuantumRegister(num_qubits)\n", 428 | "Trot_qc = QuantumCircuit(Trot_qr, name='Trot')\n", 429 | "\n", 430 | "for i in range(0, num_qubits - 1):\n", 431 | " Trot_qc.append(ZZ, [Trot_qr[i], Trot_qr[i+1]])\n", 432 | " Trot_qc.append(YY, [Trot_qr[i], Trot_qr[i+1]])\n", 433 | " Trot_qc.append(XX, [Trot_qr[i], Trot_qr[i+1]])\n", 434 | "\n", 435 | "# Convert custom quantum circuit into a gate\n", 436 | "Trot_gate = Trot_qc.to_instruction()" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "id": "0641237c-048e-41e7-b47c-88a364683fb7", 442 | "metadata": {}, 443 | "source": [ 444 | "YOUR TROTTERIZATION GOES HERE -- FINISH (end of example)" 445 | ] 446 | }, 447 | { 448 | "cell_type": "markdown", 449 | "id": "b9fb21ba-a2ea-4595-ba76-a4cef87ea666", 450 | "metadata": {}, 451 | "source": [ 452 | "### 2-5 Trotterized Time Evolution\n", 453 | "\n", 454 | "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", 455 | "\n", 456 | "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." 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": 13, 462 | "id": "c6135540-dcea-4313-8ce8-0eb8e3ee23e7", 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "data": { 467 | "text/html": [ 468 | "
                                                                    ░          \n",
469 |        "q4_0: ──────────────────────────────────────────────────────────────░──────────\n",
470 |        "           ┌────────────┐┌────────────┐┌────────────┐┌────────────┐ ░ ┌─┐      \n",
471 |        "q4_1: ─────┤0           ├┤0           ├┤0           ├┤0           ├─░─┤M├──────\n",
472 |        "           │            ││            ││            ││            │ ░ └╥┘      \n",
473 |        "q4_2: ─────┤            ├┤            ├┤            ├┤            ├─░──╫───────\n",
474 |        "      ┌───┐│            ││            ││            ││            │ ░  ║ ┌─┐   \n",
475 |        "q4_3: ┤ X ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├─░──╫─┤M├───\n",
476 |        "      └───┘│            ││            ││            ││            │ ░  ║ └╥┘   \n",
477 |        "q4_4: ─────┤            ├┤            ├┤            ├┤            ├─░──╫──╫────\n",
478 |        "      ┌───┐│            ││            ││            ││            │ ░  ║  ║ ┌─┐\n",
479 |        "q4_5: ┤ X ├┤2           ├┤2           ├┤2           ├┤2           ├─░──╫──╫─┤M├\n",
480 |        "      └───┘└────────────┘└────────────┘└────────────┘└────────────┘ ░  ║  ║ └╥┘\n",
481 |        "q4_6: ──────────────────────────────────────────────────────────────░──╫──╫──╫─\n",
482 |        "                                                                    ░  ║  ║  ║ \n",
483 |        "c0: 3/═════════════════════════════════════════════════════════════════╩══╩══╩═\n",
484 |        "                                                                       0  1  2
" 485 | ], 486 | "text/plain": [ 487 | " ░ \n", 488 | "q4_0: ──────────────────────────────────────────────────────────────░──────────\n", 489 | " ┌────────────┐┌────────────┐┌────────────┐┌────────────┐ ░ ┌─┐ \n", 490 | "q4_1: ─────┤0 ├┤0 ├┤0 ├┤0 ├─░─┤M├──────\n", 491 | " │ ││ ││ ││ │ ░ └╥┘ \n", 492 | "q4_2: ─────┤ ├┤ ├┤ ├┤ ├─░──╫───────\n", 493 | " ┌───┐│ ││ ││ ││ │ ░ ║ ┌─┐ \n", 494 | "q4_3: ┤ X ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├┤1 Trot(π/4) ├─░──╫─┤M├───\n", 495 | " └───┘│ ││ ││ ││ │ ░ ║ └╥┘ \n", 496 | "q4_4: ─────┤ ├┤ ├┤ ├┤ ├─░──╫──╫────\n", 497 | " ┌───┐│ ││ ││ ││ │ ░ ║ ║ ┌─┐\n", 498 | "q4_5: ┤ X ├┤2 ├┤2 ├┤2 ├┤2 ├─░──╫──╫─┤M├\n", 499 | " └───┘└────────────┘└────────────┘└────────────┘└────────────┘ ░ ║ ║ └╥┘\n", 500 | "q4_6: ──────────────────────────────────────────────────────────────░──╫──╫──╫─\n", 501 | " ░ ║ ║ ║ \n", 502 | "c0: 3/═════════════════════════════════════════════════════════════════╩══╩══╩═\n", 503 | " 0 1 2 " 504 | ] 505 | }, 506 | "execution_count": 13, 507 | "metadata": {}, 508 | "output_type": "execute_result" 509 | } 510 | ], 511 | "source": [ 512 | "# The final time of the state evolution\n", 513 | "target_time = np.pi\n", 514 | "\n", 515 | "# Number of trotter steps\n", 516 | "trotter_steps = 4 ### CAN BE >= 4\n", 517 | "\n", 518 | "# Initialize quantum circuit for 3 qubits\n", 519 | "qr = QuantumRegister(7)\n", 520 | "qc = QuantumCircuit(qr)\n", 521 | "\n", 522 | "# 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", 523 | "qc.x([3,5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)\n", 524 | "\n", 525 | "# Simulate time evolution under H_heis3 Hamiltonian\n", 526 | "for _ in range(trotter_steps):\n", 527 | " qc.append(Trot_gate, [qr[1], qr[3], qr[5]])\n", 528 | "\n", 529 | "# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time\n", 530 | "qc = qc.bind_parameters({t: target_time/trotter_steps})\n", 531 | "\n", 532 | "# Generate state tomography circuits to evaluate fidelity of simulation\n", 533 | "st_qcs = state_tomography_circuits(qc, [qr[1], qr[3], qr[5]])\n", 534 | "\n", 535 | "# Display circuit for confirmation\n", 536 | "# st_qcs[-1].decompose().draw() # view decomposition of trotter gates\n", 537 | "st_qcs[-1].draw() # only view trotter gates" 538 | ] 539 | }, 540 | { 541 | "cell_type": "markdown", 542 | "id": "1742151c-1261-4b42-80a4-da2c0ad90ac5", 543 | "metadata": {}, 544 | "source": [ 545 | "### 2-6 Execute\n", 546 | "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." 547 | ] 548 | }, 549 | { 550 | "cell_type": "code", 551 | "execution_count": 14, 552 | "id": "79c3ef21-c143-418a-8b50-f0ab39c5ae35", 553 | "metadata": {}, 554 | "outputs": [ 555 | { 556 | "name": "stdout", 557 | "output_type": "stream", 558 | "text": [ 559 | "Job ID 69578ef6-8d0d-4413-88c8-46179605d4d6\n", 560 | "Job ID 0d5068ed-6957-4a5e-9956-e5c924377a26\n", 561 | "Job ID 568ff236-6b75-4ad5-b6a3-c67a733b1f30\n", 562 | "Job ID 8f795bf9-9092-423c-bce0-8bbafd0b588e\n", 563 | "Job ID bd3b6064-dca9-4611-9817-1050c1ff6c41\n", 564 | "Job ID eb0ffe57-fabd-46e6-a7bd-468d5a5645e7\n", 565 | "Job ID 2a44d28d-2fee-4b40-b576-be625eee43fc\n", 566 | "Job ID df446ee1-4eb5-48ec-a246-903d8ca63c6d\n" 567 | ] 568 | } 569 | ], 570 | "source": [ 571 | "shots = 8192\n", 572 | "reps = 8\n", 573 | "backend = sim_noisy_jakarta\n", 574 | "# reps = 8\n", 575 | "# backend = jakarta\n", 576 | "\n", 577 | "jobs = []\n", 578 | "for _ in range(reps):\n", 579 | " # execute\n", 580 | " job = execute(st_qcs, backend, shots=shots)\n", 581 | " print('Job ID', job.job_id())\n", 582 | " jobs.append(job)" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "id": "be7acc76-86f0-4b1f-94e4-e4e1014f3956", 588 | "metadata": {}, 589 | "source": [ 590 | "We can monitor the status of the jobs using Qiskit's job monitoring tools." 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": 15, 596 | "id": "1b142880-af5b-4913-8f50-9248e5d1646f", 597 | "metadata": {}, 598 | "outputs": [ 599 | { 600 | "name": "stdout", 601 | "output_type": "stream", 602 | "text": [ 603 | "Job Status: job has successfully run\n", 604 | "Job Status: job has successfully run\n", 605 | "Job Status: job has successfully run\n", 606 | "Job Status: job has successfully run\n", 607 | "Job Status: job has successfully run\n", 608 | "Job Status: job has successfully run\n", 609 | "Job Status: job has successfully run\n", 610 | "Job Status: job has successfully run\n" 611 | ] 612 | } 613 | ], 614 | "source": [ 615 | "for job in jobs:\n", 616 | " job_monitor(job)\n", 617 | " try:\n", 618 | " if job.error_message() is not None:\n", 619 | " print(job.error_message())\n", 620 | " except:\n", 621 | " pass" 622 | ] 623 | }, 624 | { 625 | "cell_type": "markdown", 626 | "id": "e4186e06-db3d-4d0d-aef4-51906f41df61", 627 | "metadata": {}, 628 | "source": [ 629 | "### 2-7 Results Analysis\n", 630 | "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." 631 | ] 632 | }, 633 | { 634 | "cell_type": "code", 635 | "execution_count": 16, 636 | "id": "f87c0c22-1f37-4f56-9ec5-7e3c5d7a8384", 637 | "metadata": {}, 638 | "outputs": [ 639 | { 640 | "name": "stdout", 641 | "output_type": "stream", 642 | "text": [ 643 | "state tomography fidelity = 0.0378 ± 0.0013\n" 644 | ] 645 | } 646 | ], 647 | "source": [ 648 | "# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits\n", 649 | "def state_tomo(result, st_qcs):\n", 650 | " # The expected final state; necessary to determine state tomography fidelity\n", 651 | " target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)\n", 652 | " # Fit state tomography results\n", 653 | " tomo_fitter = StateTomographyFitter(result, st_qcs)\n", 654 | " rho_fit = tomo_fitter.fit(method='lstsq')\n", 655 | " # Compute fidelity\n", 656 | " fid = state_fidelity(rho_fit, target_state)\n", 657 | " return fid\n", 658 | "\n", 659 | "# Compute tomography fidelities for each repetition\n", 660 | "fids = []\n", 661 | "for job in jobs:\n", 662 | " fid = state_tomo(job.result(), st_qcs)\n", 663 | " fids.append(fid)\n", 664 | " \n", 665 | "print('state tomography fidelity = {:.4f} \\u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))" 666 | ] 667 | }, 668 | { 669 | "cell_type": "code", 670 | "execution_count": 17, 671 | "id": "a7a0994c-f8bf-4613-8b1e-c78eb2864b8e", 672 | "metadata": {}, 673 | "outputs": [ 674 | { 675 | "data": { 676 | "text/html": [ 677 | "

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", 678 | "[Clang 10.0.0 ]
OSDarwin
CPUs8
Memory (Gb)64.0
Mon Nov 29 09:12:47 2021 EST
" 679 | ], 680 | "text/plain": [ 681 | "" 682 | ] 683 | }, 684 | "metadata": {}, 685 | "output_type": "display_data" 686 | } 687 | ], 688 | "source": [ 689 | "import qiskit.tools.jupyter\n", 690 | "%qiskit_version_table" 691 | ] 692 | } 693 | ], 694 | "metadata": { 695 | "kernelspec": { 696 | "display_name": "Python 3", 697 | "language": "python", 698 | "name": "python3" 699 | }, 700 | "language_info": { 701 | "codemirror_mode": { 702 | "name": "ipython", 703 | "version": 3 704 | }, 705 | "file_extension": ".py", 706 | "mimetype": "text/x-python", 707 | "name": "python", 708 | "nbconvert_exporter": "python", 709 | "pygments_lexer": "ipython3", 710 | "version": "3.8.8" 711 | }, 712 | "toc-autonumbering": false, 713 | "toc-showcode": false, 714 | "toc-showmarkdowntxt": false, 715 | "toc-showtags": false 716 | }, 717 | "nbformat": 4, 718 | "nbformat_minor": 5 719 | } 720 | -------------------------------------------------------------------------------- /ibmq-qsim-sup-mat.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "852ab4ac-e501-4694-bf67-90cd4122140e", 6 | "metadata": {}, 7 | "source": [ 8 | "# Open Science Prize: Supplementary Material\n", 9 | "\n", 10 | "This notebook is meant to provide a little more information about the Open Science Prize, but mostly, this notebook is a launching point from which the motivated learner can find open access sources with even more detailed information." 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "id": "c764af20-017f-4209-9483-4f89f10cb562", 16 | "metadata": {}, 17 | "source": [ 18 | "## 1 The Heisenberg Spin Model\n", 19 | "In the open prize notebook, the Hamiltonian you are simulating is defined as the [Heisenberg XXX model](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model#XXX_model) for 3 spins in a line:\n", 20 | "$$\n", 21 | "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", 22 | "$$\n", 23 | "\n", 24 | "### 1-1 Why call it XXX?\n", 25 | "The XXX model is one of a family of spin models known as [Heisenberg spin models](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model). In some sense, the most general form of Heisenberg model is often refered to as the XYZ model. The name 'XYZ' is used because the three pair-wise operators $\\sigma_x\\sigma_x$, $\\sigma_y\\sigma_y$, and $\\sigma_z \\sigma_z$ in the Hamitlonian have different coefficients $J_x$, $J_y$, and $J_z$ respectively. In the case where $J_x = J_y = J_z$, the model is labeled the 'XXX' model.\n", 26 | "\n", 27 | "### 1-2 Numerically computing the matrix representation\n", 28 | "To compute the matrix representation of $H_{\\text{Heis3}}$, we are actually missing some pieces namely the identity operator $I$ and the [tensor product](https://en.wikipedia.org/wiki/Tensor_product#Tensor_product_of_linear_maps) $\\otimes$ symbol. They are both often left out in when writing a Hamiltonian, but they are implied to be there. Writing out the full $H_{\\text{Heis3}}$ including the identity operators and tensor product symbols\n", 29 | "$$\n", 30 | "H_{\\text{Heis3}} = \\sigma_x^{(0)}\\otimes\\sigma_x^{(1)}\\otimes I^{(2)} + I^{(0)} \\otimes\\sigma_x^{(1)}\\otimes\\sigma_x^{(2)} + \\sigma_y^{(0)}\\otimes\\sigma_y^{(1)}\\otimes I^{(2)} + I^{(0)} \\otimes \\sigma_y^{(1)}\\otimes\\sigma_y^{(2)} + I^{(0)} \\otimes\\sigma_z^{(0)}\\otimes\\sigma_z^{(1)} + I^{(0)}\\otimes\\sigma_z^{(1)}\\otimes\\sigma_z^{(2)}.\n", 31 | "$$\n", 32 | "You can see why physicists don't write that all out all the time.\n", 33 | "\n", 34 | "#### 1-2.1 Tensor product vs Kronecker product\n", 35 | "\n", 36 | "A point of clarity about jargon. To numerically compute the [tensor product](https://en.wikipedia.org/wiki/Tensor_product#Tensor_product_of_linear_maps) of $\\sigma_x\\otimes\\sigma_x$, as an example, we often have already chosen to be working with the matrix representation of the operators at hand ($\\sigma_x = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$ in this example). Because a computer works in the matrix representation, what a computer does is actually called a [Kronecker product](https://en.wikipedia.org/wiki/Kronecker_product#Examples). When doing numerically computations, Kronecker product is the name you would look up for the given software package you're using such as [Mathematica](https://reference.wolfram.com/language/ref/KroneckerProduct.html), [numpy](https://numpy.org/doc/stable/reference/generated/numpy.kron.html), or [Qiskit](https://qiskit.org/documentation/tutorials/operators/01_operator_flow.html#Pauli-operators,-sums,-compositions,-and-tensor-products). \n", 37 | "\n", 38 | "Below is an example in Qiskit and numpy." 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 1, 44 | "id": "6e8a2e34-0eaf-4e95-b9fa-753cd35f611a", 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "import numpy as np\n", 49 | "import matplotlib.pyplot as plt\n", 50 | "plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts\n", 51 | "\n", 52 | "# Import Qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)\n", 53 | "from qiskit.opflow import Zero, One, I, X, Y, Z\n", 54 | "\n", 55 | "# Suppress warnings\n", 56 | "import warnings\n", 57 | "warnings.filterwarnings('ignore')" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 2, 63 | "id": "6a7b4f61-08ea-40ad-b595-581632eb53a7", 64 | "metadata": {}, 65 | "outputs": [ 66 | { 67 | "name": "stdout", 68 | "output_type": "stream", 69 | "text": [ 70 | "Qiskit Kronecker product:\n", 71 | " [[0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n", 72 | " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 73 | " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", 74 | " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n", 75 | "----------------\n", 76 | "Numpy Kronecker product:\n", 77 | " [[0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n", 78 | " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 79 | " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", 80 | " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "# Compute a kronecker product in qiskit\n", 86 | "# Qiskit already knows what I and X are (the identity and Pauli-X operators), so to compute the kronecker product it's very simple: ^\n", 87 | "IX_qiskit = (I^X)\n", 88 | "print('Qiskit Kronecker product:\\n', IX_qiskit.to_matrix())\n", 89 | "\n", 90 | "print(\"----------------\")\n", 91 | "\n", 92 | "# Compute a kronecker product in numpy\n", 93 | "X_numpy = np.array([[0,1],[1,0]], dtype=complex)\n", 94 | "I_numpy = np.eye(2, dtype=complex)\n", 95 | "\n", 96 | "IX_numpy = np.kron(I_numpy, X_numpy)\n", 97 | "print('Numpy Kronecker product:\\n', IX_numpy)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "id": "2482ca28-5d74-4313-8e1f-cdbb18c7c121", 103 | "metadata": {}, 104 | "source": [ 105 | "## 2 Using OpFlow\n", 106 | "Qiskit offers [functionality for mathematically working with quantum states and operators](https://qiskit.org/documentation/apidoc/opflow.html) called ```opflow``` with tutorials found [here](https://qiskit.org/documentation/tutorials/operators/index.html). Opflow is especially convenient when dealing with large numbers of qubits as tensor products can become unweildy when using numpy both in size and syntax. For example, to define $H_{\\text{Heis3}}$, we could use ```numpy```'s ```numpy.kron(...)``` function to compute the tensor product as shown below." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 3, 112 | "id": "b664ad3b-cc82-41fd-b72b-b59140cafa33", 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "# Returns matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line (uses np.kron())\n", 117 | "def H_heis3_np_kron():\n", 118 | " #iden is the identity matrix; sig_x, sig_y, and sig_z are Pauli matrices\n", 119 | " iden = np.eye(2,2)\n", 120 | " sig_x = np.array([[0,1],[1,0]])\n", 121 | " sig_y = np.array([[0,-1j],[1j,0]])\n", 122 | " sig_z = np.array([[0,1],[0,-1]])\n", 123 | " \n", 124 | " # Interactions (np.kron(A,B) is the tensor product of A and B)\n", 125 | " XXs = np.kron(iden, np.kron(sig_x, sig_x)) + np.kron(sig_x, np.kron(sig_x, iden))\n", 126 | " YYs = np.kron(iden, np.kron(sig_y, sig_y)) + np.kron(sig_y, np.kron(sig_y, iden))\n", 127 | " ZZs = np.kron(iden, np.kron(sig_z, sig_z)) + np.kron(sig_z, np.kron(sig_z, iden))\n", 128 | " \n", 129 | " # Sum interactions\n", 130 | " H = XXs + YYs + ZZs\n", 131 | " \n", 132 | " # Return Hamiltonian\n", 133 | " return H\n", 134 | "\n", 135 | "# Returns matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line (uses opflow)\n", 136 | "def H_heis3_opflow():\n", 137 | " \n", 138 | " # Interactions (I is the identity matrix; X, Y, and Z are Pauli matricies; ^ is a tensor product)\n", 139 | " XXs = (I^X^X) + (X^X^I)\n", 140 | " YYs = (I^Y^Y) + (Y^Y^I)\n", 141 | " ZZs = (I^Z^Z) + (Z^Z^I)\n", 142 | " \n", 143 | " # Sum interactions\n", 144 | " H = XXs + YYs + ZZs\n", 145 | " \n", 146 | " # Return Hamiltonian\n", 147 | " return H" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "id": "199e6d25-b57a-4a7b-ac11-4b48d2e29efa", 153 | "metadata": {}, 154 | "source": [ 155 | "Using opflow, however, the math is much easier to read and does not require recursive function calls, which can be confusing when generalizing a Hamiltonian to many qubits. Also, the operators do not need to be explicity computed in opflow saving memory. In opflow, the carrot symbol ```^``` denotes a tensor product. Important note, paranetheses are often needed to clarify the order of operations especially if doing other math operations such as ```+```. See below." 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 4, 161 | "id": "fc4e4da7-292d-46fe-972e-4f9c7f32ebce", 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "matrix dimensions of op: (8, 8)\n" 169 | ] 170 | } 171 | ], 172 | "source": [ 173 | "# Example of incorrectly adding two PauliOp objects.\n", 174 | "op = X^X + Z^Z\n", 175 | "print('matrix dimensions of op:', op.to_matrix().shape)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "id": "dbb4bb92-2fc8-439c-8d05-0eb086367098", 181 | "metadata": {}, 182 | "source": [ 183 | "The shape of ```op``` should be (4,4) since $X$ and $Z$ are 2x2, but without parentheses, the order of operations is not correct. Shown below is the correct way of adding the two tensored Pauli operators in opflow." 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 5, 189 | "id": "9de48874-6287-4721-9d7e-d9037994e216", 190 | "metadata": {}, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "matrix dimensions of op: (4, 4)\n" 197 | ] 198 | } 199 | ], 200 | "source": [ 201 | "# Example of correctly adding two PauliOp objects.\n", 202 | "op = (X^X) + (Z^Z)\n", 203 | "print('matrix dimensions of op:', op.to_matrix().shape)" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "id": "d780ee45-42a2-4b8f-b7ec-0e08da813b71", 209 | "metadata": {}, 210 | "source": [ 211 | "## 3 Solution to the Time-Independent Schrödinger Equation\n", 212 | "\n", 213 | "The [Schrödinger equation](https://en.wikipedia.org/wiki/Schrödinger_equation) is a foundational pillar of quantum mechanics. It relates how a quantum state $|\\psi(t)\\rangle$ changes in time given what the state was initially $|\\psi(0)\\rangle$. It's solution is relatively simple (more on how it's not simple in the next section) when the Hamiltonian $H$ that governs the state evolvution does not depend on time. Treating Schrödinger equation as the differential equation it is, we can use separation of variables to solve it\n", 214 | "\n", 215 | "$$\n", 216 | "\\begin{align}\n", 217 | "i \\hbar \\frac{d |\\psi(t)\\rangle}{dt} &= H|\\psi(t)\\rangle \\\\\n", 218 | "|\\psi(t)\\rangle &= e^{-iHt / \\hbar} |\\psi(0)\\rangle.\n", 219 | "\\end{align}\n", 220 | "$$" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "id": "b4ded8ca-3fad-4518-aa09-4c21386a06e7", 226 | "metadata": {}, 227 | "source": [ 228 | "## 4 Exponential of a Matrix\n", 229 | "The solution to the [Schrödinger equation](https://en.wikipedia.org/wiki/Schrödinger_equation) for a Hamiltonian $H$ that does not depend on time (and $\\hbar = 1$) is\n", 230 | "$$\n", 231 | "|\\psi(t)\\rangle = e^{-iHt}|\\psi(0)\\rangle.\n", 232 | "$$\n", 233 | "But, what does it mean to take $e$ to the power of an operator $H$? Let's briefly address this topic and give references where you can learn more.\n", 234 | "\n", 235 | "Working with the the matrix representation of $H$, the time evolution $U_H(t) = e^{-iHt}$ can be numerically and algebraically evaluated using a [taylor series expansion](https://en.wikipedia.org/wiki/Taylor_series#Exponential_function) ($e^x = 1 + x + x^2/2! + x^3/3! + ... $) . This is often where computers step in. Although, single Pauli operators (e.g. $H=\\sigma_x$) have a nice algebraic result. On a computer, many different software packages have methods for computing $e^A$ where $A$ is a matrix (see scipy's [expm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html) or opflow's [.exp_i()](https://qiskit.org/documentation/tutorials/operators/01_operator_flow.html#Evolutions,-exp_i(),-and-the-EvolvedOp)).\n", 236 | "\n", 237 | "We do need to be careful when the matrix that is being exponentiated is a sum of operators that do not commute ($[A,B] = AB - BA \\neq 0$). For example, if $H = \\sigma_x + \\sigma_z$, we need to take care in working with $e^{it(\\sigma_x + \\sigma_z)}$ since the Pauli operatos $\\sigma_x$ and $\\sigma_z$ do not commute $[\\sigma_x, \\sigma_z] = \\sigma_x \\sigma_z - \\sigma_z \\sigma_x = -2i\\sigma_y \\neq0$. If we want to apply $e^{it(\\sigma_x + \\sigma_z)}$ on a quantum computer, however, we will want to decompose the sum in the exponential into a product of exponentials. Each product can then be implemented on the quantum computer as a single or two-qubit gate. Continuing the example, $\\sigma_x$ and $\\sigma_z$ do not commute ($[\\sigma_x, \\sigma_z] \\neq 0$), so we cannot simply decompose the exponential into a product of exponentials $e^{-it(\\sigma_x + \\sigma_z)} \\neq e^{-it\\sigma_x}e^{-it\\sigma_z}$. This is where approximation methods come in such as Trotterization (more on that in the next section)." 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "id": "959cf31a-b738-4ab4-bc2b-825b1bc7cf87", 243 | "metadata": {}, 244 | "source": [ 245 | "## 5 Trotterization\n", 246 | "\n", 247 | "The Open Science Prize notebook ends the decomposition of the unitary time evolution $U_{\\text{Heis3}}(t)$ calculation with\n", 248 | "$$\n", 249 | "U_{\\text{Heis3}}(t) \\approx \\left[XX^{(0,1)}(t/n) YY^{(0,1)}(t/n) ZZ^{(0,1)}(t/n) XX^{(1,2)}(t/n) YY^{(1,2)}(t/n) ZZ^{(1,2)}(t/n) \\right]^{n}\n", 250 | "$$\n", 251 | "where $t$ is time and $n$ is the number of Trotter steps. (Remember, this is not the only possible Trotterization.)\n", 252 | "\n", 253 | "The physical implementation of the two-qubit gates $XX(t)$, $YY(t)$, and $ZZ(t)$ are outlined in the Open Science Prize notebook, though without explanation. Here we provide a brief explanation with references where you can learn more.\n", 254 | "\n", 255 | "Qiskit has a library of circuits that include such gates called the [circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html), but not every gate in the library is native to a physical device. Nonnative gates (such as $XX$, $YY$, $ZZ$, or $ZX$) need to be decomposed into gates that are [native to the physical device](https://qiskit.org/documentation/tutorials/circuits_advanced/08_gathering_system_information.html#Configuration). You may even come across three-qubit gates like XXY or XYZ in some models. These interactions can be decomposition into native gates, or you may find it effective go further and [engineer a typically nonnative interaction](https://qiskit.org/textbook/ch-quantum-hardware/hamiltonian-tomography.html) using Pulse.\n", 256 | "\n", 257 | "Assuming you want to only use native gates and not pulses, this review article is a useful starting point: 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", 258 | "\n", 259 | "\n", 260 | "In this notebook, let's start with the [ZZ gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZZGate.html)\n", 261 | "$$\n", 262 | "\\begin{align}\n", 263 | "ZZ(2t) &= e^{-it\\sigma_z \\otimes \\sigma_z} \\\\\n", 264 | "ZZ(2t) &= \\begin{bmatrix} e^{-it} & 0 & 0 & 0 \\\\ 0 & e^{it} & 0 & 0 \\\\ 0 & 0 & e^{it} & 0 \\\\ 0 & 0 & 0 & e^{-it} \\\\ \\end{bmatrix}\n", 265 | "\\end{align}.\n", 266 | "$$\n", 267 | "This can be implemented in terms of two-qubit [CNOT gates](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html#qiskit.circuit.library.CXGate) sandwiching a single qubit rotation [$R_z(2t)$ rotation](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZGate.html) as shown below. (Note that $R_z$ is evaluated at the angle $2t$ instead of the typical $t$ to simplify writing the exponential terms.)" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 6, 273 | "id": "4b52e0cf-8c7f-4d85-a5a5-21937352f236", 274 | "metadata": {}, 275 | "outputs": [], 276 | "source": [ 277 | "from qiskit.circuit import Parameter\n", 278 | "from qiskit import QuantumCircuit, QuantumRegister, execute\n", 279 | "\n", 280 | "t = Parameter('t')" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 7, 286 | "id": "7899531d-1294-4bfc-94d6-4a97b755b427", 287 | "metadata": {}, 288 | "outputs": [ 289 | { 290 | "data": { 291 | "image/png": "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\n", 292 | "text/plain": [ 293 | "
" 294 | ] 295 | }, 296 | "execution_count": 7, 297 | "metadata": {}, 298 | "output_type": "execute_result" 299 | } 300 | ], 301 | "source": [ 302 | "# ZZ in two and single qubit gates\n", 303 | "qc = QuantumCircuit(2)\n", 304 | "qc.cnot(0,1)\n", 305 | "qc.rz(2 * t, 1)\n", 306 | "qc.cnot(0,1)\n", 307 | "\n", 308 | "qc.draw(output='mpl')" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "id": "b281b10f-69ec-4dfe-a5b2-797569a0d56d", 314 | "metadata": {}, 315 | "source": [ 316 | "For fun, let's check this mathematically by evaluating the circuit library ZZ gate and decomposed circuit at various time values." 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 8, 322 | "id": "dc7629c2-f881-4505-b904-bb56173cb30f", 323 | "metadata": {}, 324 | "outputs": [], 325 | "source": [ 326 | "from qiskit.circuit.library import RXXGate, RYYGate, RZZGate, CXGate\n", 327 | "from qiskit.quantum_info.operators import Operator\n", 328 | "\n", 329 | "import qiskit.quantum_info as qi" 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": 9, 335 | "id": "c84f1be2-930c-4545-98d4-36dc6396eda8", 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "data": { 340 | "text/plain": [ 341 | "True" 342 | ] 343 | }, 344 | "execution_count": 9, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "# time \n", 351 | "time = np.pi/2 # try different time values as a check that the decomposition of ZZ into native gates is accurate\n", 352 | "\n", 353 | "# Qiskit circuit library ZZ gate\n", 354 | "qc = QuantumCircuit(2)\n", 355 | "qc.append(RZZGate(time), [0,1])\n", 356 | "qc_ZZ_matrix = qi.Operator(qc)\n", 357 | "\n", 358 | "# Decomposed ZZ gate\n", 359 | "CNOT = Operator(np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]))\n", 360 | "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n", 361 | "I_Rz = (Operator(I)^Rz)\n", 362 | "np_ZZ_matrix = CNOT@I_Rz@CNOT\n", 363 | "\n", 364 | "# Confirm matrices are the same at time t\n", 365 | "np.array_equal(qc_ZZ_matrix, np_ZZ_matrix)" 366 | ] 367 | }, 368 | { 369 | "cell_type": "markdown", 370 | "id": "da817ff1-df52-43ec-af83-6e17030d355d", 371 | "metadata": {}, 372 | "source": [ 373 | "The $ZZ(t)$ gate can be rotated to the $XX(t)$ gate by adding single qubit rotations. Single qubit rotations such as $R_y(\\pi/2) \\sigma_z R_y(-\\pi/2) = \\sigma_x$ can transform $\\sigma_z$ to $\\sigma_x$. Consider computing the calculation yourself. Remember that Pauli matrices can be decomposed from an exponential form like so $R_z(2\\theta)= \\exp\\left(-i\\theta\\sigma_z\\right) = \\cos(\\theta)I - i \\sin(\\theta)\\sigma_z$. Below is an abbreviated calculation to guide your own. Note that most tensor products with the identity have been omitted (e.g. $\\sigma_z^{(0)} = \\sigma_z^{(0)} \\otimes I^{(1)}$), and for extra clarity, each operator has the qubit it acts on indexed in the superscript, so $\\sigma_z^{(0)}$ would be the $\\sigma_z$ operator acting on qubit $0$.\n", 374 | "\n", 375 | "$$\n", 376 | "\\begin{align}\n", 377 | "\\left(R_y^{(0)}(\\pi/2) \\otimes R_Y^{(1)}(\\pi/2)\\right) ZZ(t)^{(0,1)}\\left( R_y^{(0)}(-\\pi/2) \\otimes R_Y^{(1)}(-\\pi/2)\\right) &= \\\\\n", 378 | "\\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\exp\\left[\\frac{-it}{2} \\sigma_z^{(0)} \\otimes \\sigma_z^{(1)}\\right] \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] &= \\\\\n", 379 | "\\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\left[\\cos(t/2)(I^{(0)} \\otimes I^{(1)}) -i\\sin(t/2)(\\sigma_z^{(0)} \\otimes \\sigma_z^{(1)}) \\right] \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] &= \\\\\n", 380 | "\\cos(t/2) \\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] (I^{(0)} \\otimes I^{(1)}) \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] - i \\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\sin(t/2)(\\sigma_z \\otimes \\sigma_z) \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] &= \\\\\n", 381 | "\\cos(t/2) (I^{(0)} \\otimes I^{(1)}) - \\frac{i \\sin(t/2)}{4} \\left[\\left(I^{(0)} - i \\sigma_y^{(0)}\\right) \\sigma_z^{(0)} \\left(I^{(0)} + i \\sigma_y^{(0)}\\right)\\right] \\otimes \\left[\\left(I^{(1)} - i \\sigma_y^{(1)}\\right) \\sigma_z^{(1)} \\left(I^{(1)} + i \\sigma_y^{(1)}\\right)\\right] &= \\\\\n", 382 | "\\cos(t/2) (I^{(0)} \\otimes I^{(1)}) - i \\sin(t/2) (\\sigma_x^{(0)} \\otimes \\sigma_x^{(1)}) &= \\\\\n", 383 | "\\exp\\left[\\frac{-it}{2} \\sigma_x^{(0)} \\otimes \\sigma_x^{(1)}\\right] &= \\\\\n", 384 | "&= XX(t) \\\\\n", 385 | "\\end{align}\n", 386 | "$$\n" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": 10, 392 | "id": "c18e249f-58ce-43d6-9f49-c5680b1b19c6", 393 | "metadata": {}, 394 | "outputs": [ 395 | { 396 | "data": { 397 | "image/png": "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\n", 398 | "text/plain": [ 399 | "
" 400 | ] 401 | }, 402 | "execution_count": 10, 403 | "metadata": {}, 404 | "output_type": "execute_result" 405 | } 406 | ], 407 | "source": [ 408 | "# XX(t)\n", 409 | "qc = QuantumCircuit(2)\n", 410 | "qc.ry(np.pi/2,[0,1])\n", 411 | "qc.cnot(0,1)\n", 412 | "qc.rz(2 * t, 1)\n", 413 | "qc.cnot(0,1)\n", 414 | "qc.ry(-np.pi/2,[0,1])\n", 415 | "\n", 416 | "qc.draw(output='mpl')" 417 | ] 418 | }, 419 | { 420 | "cell_type": "markdown", 421 | "id": "4614a7cc-813b-4d5f-87eb-d509b4534447", 422 | "metadata": {}, 423 | "source": [ 424 | "Let's check for fun again." 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": 11, 430 | "id": "1401b27f-be6d-4eaf-af29-80fea03bc190", 431 | "metadata": {}, 432 | "outputs": [ 433 | { 434 | "data": { 435 | "text/plain": [ 436 | "True" 437 | ] 438 | }, 439 | "execution_count": 11, 440 | "metadata": {}, 441 | "output_type": "execute_result" 442 | } 443 | ], 444 | "source": [ 445 | "# time \n", 446 | "time = np.pi/6 # try different time values as a check that the decomposition of XX into native gates is accurate\n", 447 | "\n", 448 | "# Qiskit circuit library XX gate\n", 449 | "qc = QuantumCircuit(2)\n", 450 | "qc.append(RXXGate(time), [0,1])\n", 451 | "qc_XX_matrix = qi.Operator(qc).data\n", 452 | "\n", 453 | "# Decomposed XX gate\n", 454 | "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n", 455 | "Ry = Operator(np.array([[np.cos(np.pi/4), -np.sin(np.pi/4)],[np.sin(np.pi/4), np.cos(np.pi/4)]]))\n", 456 | "Ry_minus = Operator(np.array([[np.cos(-np.pi/4), -np.sin(-np.pi/4)],[np.sin(-np.pi/4), np.cos(-np.pi/4)]]))\n", 457 | "I_Rz = (Operator(I)^Rz)\n", 458 | "\n", 459 | "np_XX_matrix = (Ry^Ry)@CNOT@I_Rz@CNOT@(Ry_minus^Ry_minus)\n", 460 | "\n", 461 | "# Confirm matrices are the same at time t\n", 462 | "np.array_equal(np.round(qc_XX_matrix, 6), np.round(np_XX_matrix, 6))" 463 | ] 464 | }, 465 | { 466 | "cell_type": "markdown", 467 | "id": "41154af6-1176-40f4-a799-4e49b5467451", 468 | "metadata": {}, 469 | "source": [ 470 | "The $ZZ(t)$ gate can be rotated to the $YY(t)$ gate by adding single qubit rotations $R_x(\\pi/2) \\sigma_z R_x(-\\pi/2) = -\\sigma_y$ around the $ZZ$ gate just as was done with the $XX$ gate." 471 | ] 472 | }, 473 | { 474 | "cell_type": "code", 475 | "execution_count": 12, 476 | "id": "9e0fa136-3964-4614-9be6-0aece7c37872", 477 | "metadata": {}, 478 | "outputs": [ 479 | { 480 | "data": { 481 | "image/png": "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\n", 482 | "text/plain": [ 483 | "
" 484 | ] 485 | }, 486 | "execution_count": 12, 487 | "metadata": {}, 488 | "output_type": "execute_result" 489 | } 490 | ], 491 | "source": [ 492 | "# YY(t)\n", 493 | "qc = QuantumCircuit(2)\n", 494 | "qc.rx(np.pi/2,[0,1])\n", 495 | "qc.cnot(0,1)\n", 496 | "qc.rz(2 * t, 1)\n", 497 | "qc.cnot(0,1)\n", 498 | "qc.rx(-np.pi/2,[0,1])\n", 499 | "\n", 500 | "qc.draw(output='mpl')" 501 | ] 502 | }, 503 | { 504 | "cell_type": "code", 505 | "execution_count": 13, 506 | "id": "4d484c88-5494-4adb-9e4a-deb8b009a4c6", 507 | "metadata": {}, 508 | "outputs": [ 509 | { 510 | "data": { 511 | "text/plain": [ 512 | "True" 513 | ] 514 | }, 515 | "execution_count": 13, 516 | "metadata": {}, 517 | "output_type": "execute_result" 518 | } 519 | ], 520 | "source": [ 521 | "# time \n", 522 | "time = np.pi/6 # try different time values as a check that the decomposition of YY into native gates is accurate\n", 523 | "\n", 524 | "# Qiskit circuit library YY gate\n", 525 | "qc = QuantumCircuit(2)\n", 526 | "qc.append(RYYGate(time), [0,1])\n", 527 | "qc_YY_matrix = qi.Operator(qc).data\n", 528 | "\n", 529 | "# Decomposed YY gate\n", 530 | "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n", 531 | "Rx = Operator(np.array([[np.cos(np.pi/4), -1j*np.sin(np.pi/4)],[-1j*np.sin(np.pi/4), np.cos(np.pi/4)]]))\n", 532 | "Rx_minus = Operator(np.array([[np.cos(-np.pi/4), -1j*np.sin(-np.pi/4)],[-1j*np.sin(-np.pi/4), np.cos(-np.pi/4)]]))\n", 533 | "I_Rz = (Operator(I)^Rz)\n", 534 | "\n", 535 | "np_YY_matrix = (Rx^Rx)@CNOT@I_Rz@CNOT@(Rx_minus^Rx_minus)\n", 536 | "\n", 537 | "# Confirm matrices are the same at time t\n", 538 | "np.array_equal(np.round(qc_YY_matrix, 6), np.round(np_YY_matrix, 6))" 539 | ] 540 | }, 541 | { 542 | "cell_type": "markdown", 543 | "id": "4fcf11bd-7678-4627-9fbc-a090fba9d674", 544 | "metadata": {}, 545 | "source": [ 546 | "## 6 State Tomography\n", 547 | "[State tomography](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) is a method for determining the quantum state of a qubit, or qubits, even if the state is in a superposition or entangled. Repeatedly measuring a prepared quantum state may not be enough to determine the full state. For example, what if you want to know if the result of a quantum calculation is the state $|0\\rangle -i|1\\rangle$?\n", 548 | "\n", 549 | "Repeated measurements in the $Z$-basis would return $|0\\rangle$ 50% of the time and $|1\\rangle$ 50% of the time. However, there are other states that give the same measurement result, such as $|0\\rangle + |1\\rangle$, $|0\\rangle - |1\\rangle$, and $|0\\rangle + i|1\\rangle$. How could you determine the state you have has the $-i$ phase you're looking for? This requires measurements in [different bases](https://qiskit.org/textbook/ch-states/single-qubit-gates.html#measuring). In state tomography, a quantum circuit is repeated with measurements done in different bases to exhaustively determine the full quantum state (including any phase information). The Open Science Prize this year is using this technique to determine the full quantum state after the quantum simulation. That state is then compared to the exact expected result to compute a fidelity. Although this fidelity only gives information on how well the quantum simulation produces one particular state, it's a more lightweight approach than a full [process tomography](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) caluclation. In short, a high fidelity measured by state tomography doesn't gaurentee a high fidelity quantum simulation, but a low fidelity state tomography does imply a low fidelity quantum simulation." 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "id": "f54d9f18-0385-4b0a-9568-5f1e8efdafb4", 555 | "metadata": {}, 556 | "source": [ 557 | "# 7 Two-Qubit Gate with Pulse\n", 558 | "[Qiskit Pulse](https://qiskit.org/documentation/apidoc/pulse.html) offers low-level control of a device's qubits. Pulse allows users to program the physical interactions happening on the superconducting chip. This can be a powerful tool for streamlining circuits \\[1-4\\], crafting new types of gates \\[1-4\\], getting [higher fidelity readout](https://www.youtube.com/watch?v=_1XTChcvbOs), and more. Of course, the increased level of control requires more understanding of [the physics of the qubit and how gates are physically generated on chip](https://qiskit.org/textbook/ch-quantum-hardware/transmon-physics.html). For someone new to Pulse, this may seem intimidating. However, there are great tutorials, and the [qiskit textbook](https://qiskit.org/textbook/ch-quantum-hardware/index-pulses.html) can slowly introduce you to these ideas with real and practically useful examples. For those more experienced with Pulse, it may be time to review papers such as this [general overview](https://arxiv.org/pdf/2004.06755.pdf). There will be other papers you find useful for this competition. Below, there is a small--and far from exhaustive--list to get you started \\[1-4\\].\n", 559 | "\n", 560 | "To aid your efforts, we've provided a simple example of implementing a pulse-efficient [$R_{ZX}$ gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZXGate.html#qiskit.circuit.library.RZXGate) as outlined in paper [3](https://arxiv.org/pdf/2105.01063.pdf). Note that although the example below is interesting, it is not the only way to make a \"pulse-efficient\" two-qubit rotation gate.\n", 561 | "\n", 562 | "\\[1\\] T. Alexander, et al., *Qiskit Pulse: Programming Quantum Computers Through the Cloud with Pulses*, [Quantum Sci. and Technol. **5** 044006 (2020)](https://arxiv.org/pdf/2004.06755.pdf)\n", 563 | "\n", 564 | "\n", 565 | "\\[2\\] J. Stenger, et al., *Simulating the dynamics of braiding of Majorana zero modes using an IBM quantum computer*, [Phys. Rev. Research **3**, 033171 (2021)](https://arxiv.org/pdf/2012.11660.pdf)\n", 566 | "\n", 567 | "\\[3\\] N. Earnest, et al., *Pulse-efficient circuit transpilation for quantum applications on cross-resonance-based hardware*, [arXiv:2105.01063 \\[quant-ph\\] (2021)](https://arxiv.org/pdf/2105.01063.pdf)\n", 568 | "\n", 569 | "\\[4\\] S. Oomura, et al., *Design and application of high-speed and high-precision CV gate on IBM Q OpenPulse system*, [arXiv:2102.06117 \\[quant-ph\\] (2021)](https://arxiv.org/pdf/2102.06117.pdf)\n", 570 | "\n", 571 | "[qiskit experiments repo](https://github.com/Qiskit/qiskit-experiments)" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 14, 577 | "id": "bcf02aae-a24a-478b-9651-fc25f8dad0d8", 578 | "metadata": {}, 579 | "outputs": [], 580 | "source": [ 581 | "# Import qiskit packages\n", 582 | "from qiskit import IBMQ\n", 583 | "from qiskit import schedule, transpile\n", 584 | "from qiskit.tools.monitor import job_monitor\n", 585 | "\n", 586 | "# load IBMQ Account data\n", 587 | "# IBMQ.save_account(TOKEN)\n", 588 | "provider = IBMQ.load_account()\n", 589 | "\n", 590 | "provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n", 591 | "backend = provider.get_backend('ibmq_jakarta')" 592 | ] 593 | }, 594 | { 595 | "cell_type": "markdown", 596 | "id": "a057968d-c6d1-4ea0-a773-3d9fae612066", 597 | "metadata": {}, 598 | "source": [ 599 | "## 7.1 The [$R_{ZX}$ Gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZXGate.html#qiskit.circuit.library.RZXGate)\n", 600 | "It's now time for an example of implementing a rotational two-qubit gate and how you might go about using Pulse to implement it as efficiently as possible. Remembering the dicussion in sections 4 and 5, we can write out the form of the $R_{ZX}(\\theta)$ gate:\n", 601 | "\n", 602 | "$$\n", 603 | "R_{ZX}(2\\theta) = \\exp\\left(-i \\theta \\sigma_z^{(0)} \\otimes \\sigma_x^{(1)}\\right) = \\cos(\\theta)(I^{(0)}\\otimes I^{(1)}) -i \\sin(\\theta)(\\sigma_z^{(0)} \\otimes \\sigma_x^{(1)})\n", 604 | "$$\n", 605 | "\n", 606 | "Let's follow paper [\\[3\\]](https://arxiv.org/pdf/2105.01063.pdf)'s same line of reasoning. First, implement an $R_{ZX}$ using native circuit gates. Second, compare that circuit's performance to an $R_{ZX}$ gate contrusted from native pulses. Since the competition focuses on Jakarta's qubits 1, 3, and 5, let's just consider an $R_{ZX}$ gate between 1 and 3." 607 | ] 608 | }, 609 | { 610 | "cell_type": "code", 611 | "execution_count": 15, 612 | "id": "bc34997b-9248-4521-9c60-6cc6e34bcffc", 613 | "metadata": {}, 614 | "outputs": [ 615 | { 616 | "name": "stdout", 617 | "output_type": "stream", 618 | "text": [ 619 | " \n", 620 | "q0_0: ──────────────────────────────────────────────\n", 621 | " \n", 622 | "q0_1: ──────────────■─────────────────■─────────────\n", 623 | " │ │ \n", 624 | "q0_2: ──────────────┼─────────────────┼─────────────\n", 625 | " ┌──────────┐┌─┴─┐┌───────────┐┌─┴─┐┌─────────┐\n", 626 | "q0_3: ┤ Ry(-π/2) ├┤ X ├┤ Rz(3π/11) ├┤ X ├┤ Ry(π/2) ├\n", 627 | " └──────────┘└───┘└───────────┘└───┘└─────────┘\n" 628 | ] 629 | }, 630 | { 631 | "data": { 632 | "image/png": "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\n", 633 | "text/plain": [ 634 | "
" 635 | ] 636 | }, 637 | "execution_count": 15, 638 | "metadata": {}, 639 | "output_type": "execute_result" 640 | } 641 | ], 642 | "source": [ 643 | "# RZX gate circuit (see section 5 for details on why this is the circuit for RZX)\n", 644 | "theta = 3*np.pi/11 # pick arbitrary rotation angle theta\n", 645 | "\n", 646 | "qrs = QuantumRegister(4)\n", 647 | "qc = QuantumCircuit(qrs)\n", 648 | "qc.ry(-np.pi/2, 3)\n", 649 | "qc.cx(1, 3)\n", 650 | "qc.rz(theta, 3)\n", 651 | "qc.cx(1, 3)\n", 652 | "qc.ry(np.pi/2, 3)\n", 653 | "print(qc.draw())\n", 654 | "\n", 655 | "qct = transpile(qc, backend) # display the typical circuit diagram\n", 656 | "schedule(qct, backend).draw() # display what the pulse schedule looks like for the circuit" 657 | ] 658 | }, 659 | { 660 | "cell_type": "markdown", 661 | "id": "087e3714-4129-47a2-b1e6-c1b26a31ff8e", 662 | "metadata": {}, 663 | "source": [ 664 | "Now that we have an $R_{ZX}$ circuit implementation (shown above in circuit and pulse schedule forms), let's make the \"pulse-efficient\" version of $R_{ZX}$. (Spoiler: it's only two pulses!)" 665 | ] 666 | }, 667 | { 668 | "cell_type": "code", 669 | "execution_count": 16, 670 | "id": "7785e505-f8c3-457f-9d17-7cf5f1c411ca", 671 | "metadata": {}, 672 | "outputs": [], 673 | "source": [ 674 | "# The PassManager helps decide how a circuit should be optimized\n", 675 | "# (https://qiskit.org/documentation/tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.html)\n", 676 | "from qiskit.transpiler import PassManager\n", 677 | "\n", 678 | "# This function will pull pulse-level calibration values to build RZX gates and tell the PassManager to leave RZX gates alone\n", 679 | "from qiskit.transpiler.passes import RZXCalibrationBuilderNoEcho" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": 17, 685 | "id": "f96a9cdc-578a-4e23-8ee3-9d4d8867d22d", 686 | "metadata": {}, 687 | "outputs": [ 688 | { 689 | "data": { 690 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyUAAAHmCAYAAABtdyGsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB7MElEQVR4nO3dd3gc1dXH8e/ZVe+25Y4LYLBpBtNNCaZ3CITQewmQkORNQi+hhF5SINSETggQuundphuDwWCwccG9qfe6e98/ZiWvZUle25Jmd/X7PI8eaWdmZ87sju7MmbnFnHOIiIiIiIj4JeB3ACIiIiIi0rspKREREREREV8pKREREREREV8pKREREREREV8pKREREREREV8pKREREREREV8ldVJiZteYmTOzN9uZ96yZfeBDWN3OzCZE9nvrHtre6ZHt5UReD4h89iNjfP+OZvaImc0ys7CZPdLBcleZ2TtmVhnZXrvrN7NzzOxHM2swsx/M7OT13K9HIttxZtZsZiVm9pGZXWpm+euzzg1hZptHPteCNtNX+/z9YGb9zexOM5tiZo1mNr+D5Y4zs+fNbFkk5tM7WG5/M/vYzCrMbIWZvWBmozvZ/v9F1vdsjPHubmafm1mdmf1kZr+L5X3trCen7X6Y2cVmNmF91iciItJbJXVSEuUAM9vJ7yB60FfAeGBuD23v1cj2aiOvBwBXAyNjfP/uwB7AF8DyTpY7F0gB3u9oATM7AbgfeB44HHgDeMzMjooxlrZm4u3bnsCpkW1fCEyLNenqQpvjfa4Fbaa3/fz9MBQ4Du/7+7qT5Y7BOy5e6WgBM9sBb5+WAL8Efg1sArxtZnntLD8A+DNQFEugZjYKeBP4CTgU73j5q5mdHcv7Y3AxMKGL1iUiItIrpPgdQA8oBRYDVwA/9zeUnuGcqwQ+62wZM8t0ztV10faKiPGCsAN3Oef+EYlraifLDXfOhc3sMOCIDpa5BnjCOXdp5PVbZjYC+AvwwnrEVuOci/4sXzWz+4EpwMPA3uuxzlZmlgqEnXOh9V1HF3z+XWG6c24ggJndjpd8tOe4yHeYA3SUBPwS7//2ROdcc2Sds4Fv8BLY19ssfxNeEjMsxlgvApYCJ0fW/56ZDQeuNrMHnUaUFRER6XG94UmJA24EjjCzbTpayMwGm9lDZjYvUqXjRzO73szSopYZGamqcbyZPRypRrS4pXpQpNrGUjMrMrNbzCzQZhtbm9mrZlYV+fmfmQ1an50ys7FmNtHMys2sOlJtZv/IvDWqb0Ve/9HM/m5mRcC3kemZZnarmS2IVHf6ycxuavO+C9ps+xozK4563Vp9KPL04NvIrPdbqj91ti/OuXAs+7y25cwsC9gMeKfNrLeArbrqyYZzbjFwHTDBzMZEtt1uFSozmx+5SG95/YF5VQd/ZWZzgXpgiJmNMbOnzGyRmdWa2YxIlaRA5H0TgImR1fwU2db8jrZtZoVm9qh5Vc5qI9vdsb3YzOwPkeO4LBJDwXp8Jl3yHUakArUtCUlEeeS3RS8YeQJ6LHApsTsYeL7N+p8CNgI6rfJoZr+IlA11ZjYZGNNm/nygH16C01L1b8I6xCYiItIr9YakBOB/wI94T0s6Uoh3d/aPwEHAbcAZwF3tLHsLsAz4BfAh8KiZ3QHsDJwJ/B2vCsexLW+IVBn5GMgATgFOB7YCJpqZRS033zpoUxG1zJjIugYD5wFH4T0FWNud4osi7zkF+F1kuy8B5wN3A4fgVQ8qXMt6OrMMOCny92/wqhWN34D1rYt0vIvWxjbTGyK/x9B13o783nU93rs73md+CV4Vswq86k+z8KoqHQL8C7g2sgx4VfIujPx9NN5n2lmVtBeBAyPvOQ7vf/39yHEY7VhgX+BXkW0dhpfEt4rlmOxiT+AlapeYWR8zGwb8Fa8q3btRcRnwT+BW59ySWFZsZtl4/ycz28z6IfK7w2PEzLYHnsZ7YnM08DLwTJvFjsL7Ph9k1bH/VSyxiYiI9Ga9ofoWkeoiNwMPmtmfnXM/trPMt6y66MPMPgZqgIfM7LfOuegL3fecc5dHlvscr6rKEcCYSDWcN8zsSLwLlKci77kar779wS3rMrPpeBdHh+BVPwFoBtZWledqvAufPaOqYL3dyfItljvnjovaxwOB/YEjnXMvRy33WAzrapdzriGyXwDft6n61K2cc2VmVgrsxKrPHbxkEaBvF25uceT3wPV4bwEwzjkX3X7m3chPy8X2R0AWcA5wk3Ou0sxmRZad5pyb39HKzewgvMRngnNuUmTae8B8vMT03KjFm4CfR1WT2hI4Hi85ahHLMdllnHPTzKui9z/g5sjkmcCBzrmGqEXPAAYBtxO7gsjv8jbTyyK/+3Ty3kvxbm4cG6ni9bqZpQPXt4m9GVjck8e+iIhIoustT0rAu/u6ELisvZnm+T8z+97M6vAu1v6Dd/d9eJvFW+/WRtpvFAGT2rQLmIN397vFfnhPM8JmlmJmKXgNbecDrdVqnHOjnHNnrWVf9gGeXo82Ia+2eb0PUNomIek2ZhZs2ffI/neH+4BzzezoyF32E/CeDEHXXljb2hfp0JdtEhLMLMPMrjWzOXhPdpqAG4CN1+Oz2hkoaklIAJxzNXiNy/dos+z7baoxfQ8MsKhqizEek13GzLYCnsTrrGA/4Ei8pOE1izR0N6/3sxuBi9azbVRHVQo7q2q4M/BymzYnz6/HtkVERKSNXpOURC68bgVONq/hc1v/B9yBlzgciXcB8pvIvIw2y5a3ed3YwbTo9xXiVY9pavOzCbE30G3RD6+a1Lpa0UXrWV9zidr3rmrj0cYNwGvAc3jV8f6J1/gd1tz/DdGScK7POtt7zy14T+oewHtythOr7sC3Pf7WZnAH21jBmk+Lytu8bsRLuNLwz1+A2c65s5xz70aS5kOBjVnVOP5yYBFeRwYFkXYwKUBq5HWwg3WXR34XtJnep8389gwCVraZ1va1iIiIrIdeUX0rykPAlayqpx/tl8D/nHOt7U4iVVm6SilewvPvduYVtzOtMyV4F57rqu1d4FjW08CaF6jrWw3qcLwnTy2Wrud6OuScqwWONbOBQH+8J1aH4V1sd2Xd/gMivz+N/K6P/G77WbVXHai9u/G/xOuF7NaWCWZ26HrGtgyvW+a2BuIdh/FuDG26fY5UzVsAbBqZNBrvCWMZayrD68L5o7YznHM1ZraINduOtLxu29Yk2nLW/Fzb+5xFRERkHfWaJyXgtXfAq39+JmtejGeyqkF0i5PoOu/i9ezzpXNuapuf+euxrmPNbF3voLe3nr6R+vsdWQxs0fIi0hvUPmtZb0v7m9Xic85922a/2zZI7zLOuRXOue8isZwHPBuparfBzGwj4Cq8qk8t7Txa2phEf1a7AGuMq9GB1Y6/yJ3+49ss0+7n2o7P8apg/SxqfVl4TxvWuFCPQwuAcdETzKwf3vgm8yOTrsTrjjn65xtgcuTvb+nY68BRbZ6mHIf35OW7Tt73BV4vftFV945uZ7m2T0lFRERkLXrbkxLwBkq7HNgNmBQ1/W28Hqk+x6tmdBLQtqeiDXEN3tgWr5rZQ3hPR4biNTR/xDn3AUCkTcGktdThvxbvAmlypNevEryLuBLn3EPrENPbeIPIPWlm1+E9SRgM/Mw519IY+gXgN2Y2DZiHV31mbRfaC4E64DQzqwCanHMdjj9iZv2BvSIv+wAjzOwYAOfcs1HL7YX39GOHyKSDzeve+Hvn3PeRZQ4DRuD1pjQAr6H4GOC0NtucD3zgnDt9LfuSbWa74lVpKsA7bs4DqvAaWreYgjfY351mdhXe06SLgVgTobfxPuc5eE8zfsPqT5XA650LvDYzT+F1m7vGxbdz7s1IRw1Pm9mleMfHhXiJz20xxtMqxmOSlu8Mb5DHrKjXkyJjqbQ8fdySVRftO5pZNau3gbkPeDHS49d/gWy8p5uNeO28iCScbbdfDhS3/C9Fpu2Fl3zvG7X+2/D+vx83s3/hVZU7Fzh/LWOU3IKX8D1jZg/i3WRo7zOZCRxqZm8A1cAs51xVJ+sVERER51zS/uAlAsXtTL8crwrNB1HTcvAGwyuN/Pwbr9qPA7aOLDMy8vqwNuubD9zeZtojwNQ208YAz0bWX4dXteh+YKM263okhn0bi9d2oiry8znehRd4o0m3xh2Z5oAL2llPJt7To8V4d+p/Am5o87k8Gol5Od4d6tU+V7zujR2QEzXtJLyeihq9w6zTfWmJd42fNst90MFy10QtcxAwHW9081K8i9rh7WxzJV5Xsp3F9UjUNkKR9X2M1wtTfjvL74SXLNYC0/B6wFrt2Ijsw7PtvHcgXgJYidf241a8hKrt5/onvCcJzcD8Tj7//ni9qJVFjrVJwE4xHLftrWs+sR2T7X6HeL2ARf9PtrfMB23WdWzks6yMfFevAdutZftrfLZRx9aENtP3wEsk6yP797sYy5Rf4v3f1uM9ddopsv7To5bZAW/w0pr2tq0f/ehHP/rRj37W/DHnNHix9C5mtjHeheVmzrl5fscjIiIi0tv1qjYlIhG7AS8qIRERERGJD3pSIiIiIiIivkrahu79CgvdiOFtxzwUEREREZFYTZs2rdg517+7t5O0ScmI4cOZNPlDv8MQEREREUlYebk5C3piO2pTIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivkrxOwAREdkwMxYEV3u91YiQT5GIiMSftmUkqJyMR0pKREQSUHsn2bbzdNIVkd5M5WRiUfUtEZEE09mJdn2WExFJNionE4+elIiIJJB1PYHqbqCI9Cbrk2SonIwPelIiIpIgNuSOnu4GiohIPFNSIiKSALoiqVBiIiLJbEPLOJWR/lJSIiIS57ryRKmTrogko64q22YsCKqc9ImSEhGROKaTo4hI51ROJgclJSIivYxO4CKSLLqrPFM52fOUlIiIxKnuPCnqhCsiia67yzGVkz1LSYmISBzqiZOhTrgiIhIvlJSIiMQZJQsiIp3rqXJS5XHPUVIiItKL6YQrIiLxQEmJiEgc8SNJUGIiIomkp8ssdRPcM5SUiIjECZ30REQ6p3IyeSkpERERnehFJO75XU75vf1kp6RERCQOxMPJLh5iEBGR3klJiYiIiIjEtXi5aRIvcSQjJSUiIj6Lp5NcPMUiIiK9h5ISEREfKQkQEelcvJWT8RZPslBSIiIiq9EJV0Skcyonu56SEhERn+ikJiLSOZWTvYeSEhERWYMuBEREOqdysmspKRER8YFOZiIinVM52bsoKRERkXbpgkBE/JIo5U+ixJkIlJSIiPSwRDqJJVKsIiKSuJSUiIiIiEjcSLSbIYkWb7xSUiIi0oMS8eSViDGLiEhiUVIiItJDdHEvItK5RC0nEzXueKKkRERE1konXBGRzqmc3DBKSkREeoBOViIinVM52bspKRERkZjogkFEpHMqJ9efkhIRkW6mk5SISOdUToqSEhERiZkuHESkqyVbuZJs+9NTlJSIiHSjZDw5JeM+iYiIv5SUiIiIiIgvkvUmR7LuV3dSUiIi0k2S+aSUzPsmIiI9T0mJiEg30EW7iEjnkr2cTPb962pKSkREZL3ohCsi0jmVk7FTUiIi0sV0EhIR6ZzKSWlLSYmIiKw3XViIyLrqbeVGb9vf9aWkRESkC+nkIyIisu6UlIiIyAZRIiYiseqt5UVv3e91oaRERKSL9OaTTm/edxER2XBKSkREuoAuyvUZiEjnensZ0dv3f22UlIiIbCCdaEREOqdy0qPPoWNKSkREpMvohCsi0jmVk+1TUiIisgF0chER6ZzKSYmFkhIRkfWkE2379LmISAuVB+3T57ImJSUiItLldMIVEZUDndPnszolJSIi60Enk7XTZyQiIrFSUiIiso50sR07fVYivZP+92Ojz2mVuElKzOwaM3ORn7CZlZnZF2Z2g5kNarPsr83sVTMriSw/wZ+oRaS30QlERKRzKifXjT4vT9wkJREVwHhgN+B44HngFOBbM9sharlTgb7Amz0eoYj0WjpxrB99biK9h/7f148+N0jxO4A2mp1zn0W9ftPM7gUmA0+b2WjnXAjYzTkXNrOtgRN8iVREehWdMDZMy+e31YiQz5GISHdROblhZiwI9uoyMt6elKzBOVcOXAxsCuwfmRb2MyYRERERWUUJSdfozZ9j3CclEe8DzcCufgciIr1Pbz5JdDV9liLJR//XXau3fp4JkZQ45xqAYmCg37GISO8xY0Gw154cupM+U5Hkof/n7tEbP9d4a1PSGfM7ABHpPZLhhPDh1EV+hwDAnjsOW2Nab687LZIMVE52jfbKSOh95WRCJCVmlgH0A1bE+p5p06aRl5vTfUGJiKxNztj1f2/19K6LQ0QkXqmclIiESEqAvfFi/TTWN4wbN45Jkz/svohERERERJJcT93kj/s2JWZWANwCzAHe8TcaERERERHpavH2pCTFzFp62MoFdgDOB7KAgyJjlGBmOwIjgZZKeHuZWSEw3zk3tWdDFhERERGRDRFvSUk+XhUtB1TiPR15ArjLObc8arkLgNOiXl8T+f0ocHq3RykiIiIiIl0mbpIS59w1rEou1rbs6Sj5EBERERFJCnHfpkRERERERJKbkhIREREREfGVkhIREREREfGVkhIREREREfGVkhIREREREfFVjyYlZnaUmS0ys2ozG9eT2xbpSl988QUH7L+f32GIiMQtlZMisi56+knJ7cAFzrkc59y0Ht62yGoOPvggdtl5J3Ybvyt77LE7p556Cv975hnC4bDfoYmskzv/8Q+eeOLxmJY96cQTmTNnTjdHJMlC5aQkC5WT8a+nk5IRwIz2ZphZ3IyZIr3HP+68i08+/YzXX3+DM888k4cffohrrr7a77BEAKitreXggw/itddebZ1WU1PDQQcewNtvvwVAaWkpEydO5JhjfhnTOk897TTuvefubolXkpPKSYlnKieTx1qTEjObb2YXmtl0M6sws6fNLCNq/jlmNsfMSs3sZTMb0s460s2sGggC35jZ3Kh1X2Jm04EaM0sxs13N7BMzKzezb8xsQtR6NjazSWZWZWZvm9k/zeyJLvgcpJfLzc1lwoS9ueXW25g48WXmzJ5NY2Mjf73jdg468AD22XsC1//lL9TX17f7/ocefJDDDj2E3cbvytFH/Zz33n0XgMbGRn625x7Mnv1j67KlJSXssvNOlJaW9sSuSQLLysriqqv+zG233tp6vPz9b39lyy23Yv/9DwDg5ZdfYo899yAjI6OzVbWaMGECX3zxBUVFRd0WtyQnlZMSj1ROJo9Yn5QcCxwEbAyMJTKaupntA9wUmT8YWAA81fbNzrkG51xO5OW2zrlNo2afABwKFAADgVeB64G+wIXAc2bWP7Lsk8CXQCHwF+C0GOMXick222zDwIED+WraV/z9739jwYIFPP3M/5j4yqusXLmCB+6/v933bTRsGA89/AgfffwJ5557HpdffhlFRUWkpaVx4EEH8eorq+7gvP7G6+yyyy707du3p3ZLEthuu+3GHnvuya233MwXX3zBW2+9xWWXX946/+OPPmLHHXYEvIu73Xcbz/bjtmP8rrswftdd2H7cduy804589tlnAKSnp7PFllvy6aef+LI/kvhUTkq8UTmZHGJNSu50zi11zpUCE4HtItNPAh5yzn3lnGsALgPGm9nIdYjhTufcIudcHXAy8Jpz7jXnXNg59zYwFTjEzIYDOwFXRZKcyZFYRLpU//79qaio4PnnnuPCiy4mPz+f7Oxszjr7HN544/V233PAAQcwYMAAAoEABx50EMNHjOC7774D4IjDj+D1119rrYP96iuvcOhhh/fY/kjiu+iii5k6dSoXXfgn/vDHP9G/f//WeXPmzGHEyJEApKWlcdHFl7Dzzrvw6Wef8+lnn7PRRsO497772HXXXVvfs8nGm/DjrB/bbkYkZionJd6onEx8sbbjWB71dy3QUkVrCPBVywznXLWZlQBDgfkxrntR1N8jgF+aWXRJlAq8H9lWmXOuJmreAmBYjNsRicnKlSsJhULU19dzwgnHr5rhHKFQqN33TJz4Mo8//jhLly4FoK62lvKyMgC2GTuWzMxMvpw6lcL+/Vm4aBETJkzo7t2QJJKXl8emm27KN998w7777rvavKqqKrKzs1tfz5k9m8022wzwjsPFixcxatRmq70nKzuL4qLi7g9ckpbKSYk3KicT34Y2Ll+Kl0gAYGbZQD9gyTqsw0X9vQh43Dl3TtuFzGwE0MfMsqMSk+Ft3i+yQb777jtWrlzJ3nvvwyMPP8xzzz3PwIEDO33P0qVLue7aa3nggX8xdtttCQaDHHvsL3FRh+bhRxzBq6++Sr/Cfuy/336kp6d3965IEnn1lVdYunQpu+yyC//4+9+58qqrWufl5uZSU7PqXs3sObM55JBDW/8uLCwkPz9/tfXV1tSSm5vbM8FL0lE5KfFI5WTi29Det54EzjCz7cwsHbgR+Nw5N3891/cEcLiZHWhmQTPLMLMJZraRc24BXlWua80szcz2APRsV7pEdXU1kydN4tJLLubQQw9l9OjRHHX00dx++22UlpQAsGLFCj75+OM13ltXV4eZ0advHwBefPFF5rbpSvCwww7jvffe5bVXX+Www3XYSuxKS0q4/fbb+POfr+bKq/7MW2+9yZdfTm2dv/nmm7NgwYLW19F3AH+c9WPr39Hm/TSPzUdv3v3BS1JROSnxSuVkctigpMQ59y5wFfAcsAzYFDi+0zd1vr5FwJHA5UAR3pOTi6LiPBHYBSgFrgYei35/ZFDGPdd3+9L7/P53v2W38bty0IEH8O9//4uTTzmVa6/7CwD/939/YNiwYZxyysnsvtt4zjv3V8yfP3+NdWy66aaccuqpnHrKKey7z97MmT2b7bbbbrVlBg4cxBZbbAFmbL/9Dj2wZ5Isbrr5JibsvTc77bwz/fv35//+8Aeuu/ZaGhsbAdhjjz1bT75lZWWUlZWxySabAPDT/J8YPmLEautrbGzkh++/Z9ddx/fsjkjCUjkp8U7lZHIw5xK39pOZXQOMcs6d3Hbe9ttv7yZN/rDngxLpwNV//jP9B/Tnggt+63cokiDee+89brrxBp57/gXy8vJap//qnLPZZuxYfvvb31FWVsZxx/6Slye+wvRvvuH666/n5YleHyCPPvoIjz/2GH/729/ZZuxYAN566y3eeP11/vq3v/myTyKdUTkp60rlZPfLy8350jm3Y3dvR0mJSA9YsmQJxx13LE8/9TRDN9rI73Akydx55z/o27cvJ598ylqXPfmkE7nmmmsZ1U51BRE/qZyU7qRycv0pKYmBkhJJBHf/85888cTjnHnWWZxzzq/8DkdEJO6onBSJX0pKNpCSEhERERGRDdNTScmG9r4lIiIiIiKyQZSUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr5SUiIiIiIiIr1L8DkB6j+YQ1DVCY7PRHALn/I5IzCA1CGkpjow0SAn6HZGIiIj0RkpKpNs4Bw1NUFFjVNYZjU3md0jSGYP0FEdupiM/25Ge6iUtIiIiIt1NSYl0OeegotYorTLqGnRVmzAcNDQZDU1GcSVkpjv65TryspySExEREelWSkqkyzgHVXXGinI9FUkGdQ3G4gYjLdUxqCBMTqaenIiIiEj3UFIiXaK+EVaUB6iu01VrsmlsMhYWBcnNcgwsCJOe6ndEIiIikmyUlMgGK640iioChMN+RyLdqarWqKkPMqAgTL9c9VIgIiIiXUdJiay35hAsKg5QW6+nI71FOAzLSwNU1Tk26hdWb10iIiLSJTROiayXmnqYt1wJSW9VU2fe99/gdyQiIiKSDJSUyDorrfLaGDQ1KyHpzZqajQUrg5TX6DgQERGRDaOkRNbJ8jJjWZnaj4gnHIalJQFWlisxERERkfWnNiUSE+dgSUmACt0Vlzacg6LKAE0hx9B+ylZFRERk3SkpkbUKhb2EpKpWCYl0wEF5teFcgCF9wwT0DFZERETWgZIS6VRzyEtINP6IxKKiJpKY9AsTVGIiIiIiMdJlg3RICYmsj8paY0lJgJBqcomIiEiMlJRIu8JhWFyshETWT1Wtsbg4QFhjLIqIiEgMlJTIGsIOFhYFqNEYJLIBquuMhUUqYkRERGTtdMUgqwlFnpAoIZGuUFNnLCpWF9IiIiLSOSUl0iochuVl6mVLulZljbGi3JSYiIiISIeUlEirFeVGebUSEul6pVUBiip0bImIiEj7lJQI4I3UXlqlw0G6T3GVRn4XERGR9ukqtJdzDkqrjBIlJNLdHBRXBijT0zgRERFpQ1eivVxVnbGsNADqulV6gHOwtCRAVZ3fkYiIiEg8UVLSi1XXeYMjivS0xcVBaur9jkJERETiha5Ie6n6Ri8hUY9I4odw2Dv+Gpr8jkRERETigZKSXqihyRscsTmkuv3in6Zmb3DFxma/IxERERG/KSnpZcKRwRGbmpWQiP8am4wlGlxRRESk11NS0ouEHSwsDlDfqIRE4kdtgzfqu1NnCyIiIr2WkpJeIhyG5aVGTZ0SEok/1XWRUd+VmIiIiPRKSkp6ieIqo6xaX7fEr5LKAGVVSppFRER6I12l9gIllUZRhb5qiX8rygOUKjERERHpdXSlmuSqamFFhQZHlMTgnJeYVGtwRRERkV5FSUkSq22AhcVBnHo2kgQSDnvHbV2j35GIiIhIT1FSkqQammBRUVBPSCQhuTAsXKkxTERERHoLJSVJqKm5ZXBEvyMRWX/NIdNxLCIi0ksoKUkyLQlJY5MaC0via2hUYiIiItIbKClJIqEwLCnV4IiSXOoajKWlAUJqGyUiIpK0lJQkkcXFAQ2OKEmpqtZYWqLiSkREJFnpLJ8Ews5LSKqVkEgSq6w1lpQENOq7iIhIElJSkuDCYVhRZlTUKCGR5FdebRSVmxITERGRJKOkJIE5BysrjNIqfY3SexRXBiiuMJwSExERkaShq9kEtrzMKKnUVyi9T1FFgJXlejooIiKSLHRFm6CWlRql1fr6pPcqrgqwvEyJiYiISDJI8TsAWTdhByvLVWVLBAcllQHMwgzId5jyExERkYSlK9sEEg57CYmqbImsUlwRYGWFGr+LiIgkMj0pSRDhMCwrC1BerdvBIm0VVwQIh8MMLHAElLOLiIgkHCUlCSAUhiUlAapqlZCIdKS0KkAo7BjcN0xQiYmIiEhC0ak7zoXCsGClEhKRWFTUGAuLAoTCfkciIiIi60JJSRyrb4R5ywPUNSghEYlVbb3x0/IADU1+RyIiIiKxUlISp6rqvCckjU1KSETWVUOTMX9FgOp6vyMRERGRWCgpiUMllcai4iDNISUkIuurOWQsKgpSWqX/IxERkXinhu5xxDmvQXtFrYG6NxXZYC291tU1Oob2U0MTERGReBU3T0rM7Bozc5GfsJmVmdkXZnaDmQ2KWi7NzJ4xs3lmVmdmRWb2upnt4Gf8G6q+EeYuC1BRo4REpEs5KK825i5TOxMREZF4FTdJSUQFMB7YDTgeeB44Bfg2KukI4l223wQcCpwDZAHvmdkmPR5xFyirNn5aEaRB7UdEuk19o/d/Vl6j/zMREZF4E2/Vt5qdc59FvX7TzO4FJgNPm9lo51wdcFz0m8zsHaAE+Dnw154KdkM1NXtVS9Tdr0jPCIVgSXGAqjrH4D5hUoJ+RyQiIiIQf09K1uCcKwcuBjYF9u9gsRqgHkjrobA2SNh54ynMXR5UQiLig8oaY+6yIJW1hlN1SREREd/FfVIS8T7QDOzaMsE8KZH2JrcCIeC/PsUXs4YmWFQUYHFxgFDI72hEeq/m0Kr/RbU1ERER8Ve8Vd9ql3OuwcyKgYFRky/Ba1cCUAQc4pxb0OPBxSgUhuIKo6Q6gFMnQCJxo7LWqK4P0i83TL88RzBRbtWIiIgkkYRISiLa1nN6BHgHGAz8GnjFzH7mnPu+pwPrTDgM5TVGUUWAZj0ZEYlL4TAUVQQoq3YMKHDkZzsCqlkpQCgUJuwgFHKEnSMcdoTC3u9wGJxzUfNoXabltXMO57zfLa/DrdPAservFk51CuOWmUV+R36wVX+bYUAgYKteGwSDhmEEAt68gBmBgBEMeNNstderpgfMvPeaCiPpHRIiKTGzDKAfsKJlmnNuObA8Mv91YAZwKXCqHzG2p6zaKKowmppVoIgkguaQsbTEKK509M93FGTr4rAntFy4h8MOx+oX8A5WJQB4F/zRF/nRCUDbhCDcmjx400KR9YSip4ejE43IvEiioeRA4kUwaK1JStvf1vqa1ZKbVfOjk6HVE6OW97QkUC3zVv3NavMMVku4lDBJV0qIpATYGy/WT9ub6ZxrNrNvgdYugadNm0Zebk4PhdcZW/23BaJeR36sg7/XmBeI/B1of7pF5q02re17ot8rEg9abhOHV/3G4dVzjPrdOj96mmv/Pa3TXfuv284DVtWrdG1+S3cxC5A3YDQ5fUdiCdPEUUTA0VhfTtmyGTTVV/gdjCSJuE9KzKwAuAWYg1ddq71lMoDtgY9bpo0bN45Jkz/siRAT0mp3D0NujeoJq+azenWF6Dua0b+dW3V3s011hNbqC1Hb1x3I+BF9pyv6Lhitf9Na9cBs9btoq/1uUwWh5Q5coM1du4CtuuvXMk96t6ZmWFkRoKLW1OZOJM5lpjv654XJzfI7EukpPXWTP96SkhQza+lhKxfYATgfb3DEg5xzITM7ATgYeANYyqo2JYNJoDFK/LbaxWCqv7GISO+WmgJD+4XplwsrygNU1ylRFYk3KUHHwD6OvCy1uZPuEW9JST5eFS0HVOI9HXkCuCvShgRgFnAyXgLSB1gGfA7s6Jyb0eMRi4hIl8hIg+H9w1TXeQPLqj2eiP/MoE9OmAEF6p1QulfcJCXOuWuAa2JY7ivg0O6OR0REep4Z5GZBVkaYogqjtCqgAS5FfJKZ7hjUJ0xWut+RSG8QN0mJiIhIi2AABvVx5GaGWFoaoLFJT01EetKAgjD9ch0BPR2RHqJDTURE4lZ2Bmw6OEyfnLA6DRTpAWmpjk0Hh+ifr4REepaelIiISFwLGAzp58jKCLOsNEBYPXSJdIv8bMfgvmG1HRFfKCkREZGEUJDtyEwLsbg4QH2jHpuIdBULwKCCMH1yHBoPUfyiXFhERBJGeiqMHBgmP1ut30W6QkrQMXJAiL65SkjEX3pSIiIiCSUY8MY1SU81VlYEVh+ZVURilpnu2KgwTJquBiUO9OiTEjM7yswWmVm1mY3ryW2LxOI3vz6fl19+ye8wRGQtzKB/vmNov7Aa4/agW645l8nvvuh3GNIF8rMdIwYoIZH4Ya4HO4A3s7nAH51z3X7Vt/3227tJkz/s7s1IF3jj9dd54onHmTNnDpmZmQwdOpTDjziCY489DkvgZ8n//ve/eP655ygrKyM3N5ftthvHrbfd5ndYIkmnuh6WFAdoDiVuedGZTye/xusvP8biBXNIz8ik/8Ch7LnPkex38PEJXUa+9MwDvP/Ws1RWlpKVncfmW4zjdxff4XdYvUJhXli9a0nM8nJzvnTO7djd2+np/HgE0O6o62aW4pxr7uF4xGePPfoojzzyMJddfjm77bY7WVlZzJo5k0cfe5SjjjqatLQ0v0NcLy+//BKvvvIK9z/wL4YNG0ZxcTEffPBBj8fR3NxMSopug0lyy8mAEQPCLCpOvvFMXn3hEV55/iFOP+8Kxo7bg4zMLBbMm8mrLz7MhP1/QWpqYpaRk999kY8+mMhlf/k3AwcPp7ysiK8+f7/H4wiFmgkGe1cZOahPWO1HJC6tNUc2s/lmdqGZTTezCjN72swyouafY2ZzzKzUzF42syHtrCPdzKqBIPBN5IlJy7ovMbPpQI2ZpZjZrmb2iZmVm9k3ZjYhaj0bm9kkM6sys7fN7J9m9kQXfA7ig6qqKu65524uv+IK9t//ALKzszEzxmyxBTfddDNpaWlMnjyZ4449lt13G8+BB+zPvffe0/r+L774ggP232+1dR588EF89tlnAHz77beceMLx7L7bePbZewK3R55SNDQ0cPlll7HXz/Zkjz1258QTT6CkpASAs846k+effw6ARYsWcc7ZZ7HXz/Zkwl4/47LLLqWysnK1bT366CP88phfsMfuu3HxRRfR0NAAwIzvZjB+t90YNmwYAIWFhRxzzDGt712yeDFnnXkGu43flXPP/RU33Xgjl192Wcz7deopJ7PHHruz3777cNONN9LU1NS67HbbjuWpp57i8MMP44jDDwNg8qRJHHvsL9ljj9059dRT+PHHH9fnKxOJWxlpXmKSlpo8DUxqa6p47sl/csb5V7LL7geSmeWVkSM33YLf/OlWUlPTmPbFJC7//S8467id+e2Z+/Lck3e3vv/7b6dwwRn7rLbO35+9P999/SkAc3+czpV/PJazjtuZ80/5GU88eAsAjY0N3HPHJZx70m6cc8KuXPXHY6koKwbg+stP5/23ngVgxbKF3HDFGZx70m6ce9Lu3H3HxdRUV662rVdfeJhLf3sUZx+/C3fe+icaG70yct7s7xg7bjcGDh4OQEGf/uxz0LGt7125fDF/uew0zjpuJ2666mweue967rnjkpj36+qLTuScE3blN6ftxSP3XU9zU2PrsicdsRVvvfokfzz3YP507iEAfPXFB1z2+6M554Rduebik1j406z1+s7imRkM7humX54SEolPsT64OxY4CNgYGAucDmBm+wA3ReYPBhYAT7V9s3OuwTmXE3m5rXNu06jZJwCHAgXAQOBV4HqgL3Ah8JyZ9Y8s+yTwJVAI/AU4Lcb4JQ5Nn/4NTU1NTJiwd4fLZGZmcv0N1/PhRx9z1z/v5n/PPMN7770X0/pvu/UWTjzxJD7+5FNeefU1DjjwAAAmvvwy1dVVvPHmW0yaNJkrr7yK9PT0Nd7vnOPMs87m7Xfe5fkXXmTF8uXcd9+9qy3z1ptvcfc99/Lqa68ze/aPvPySVzNx7NixvDJxIo888jAzZswgFAqt9r7LLruULbbYkg8mTeZXv/oVEye+HNM+AQSDQS686CI++GASjz72OFOmfM7TT6/+b/f+++/xxBP/4fkXXuSHH77n6qv/zFVXXsWkSZM55phj+P3vf0djY2MHWxBJTGkpMHJAmIy05EhMZs/8mqamRnbYZZ8Ol0nPyOS8P9zEv/77GRdddQ/vvP40Uz97N6b1P/avmznw8JN58Okp/O2B19ll94MA+PC9l6itreLOh97l/ic+5sxfX01qesYa73fOccQx5/DPRz7gtnsmUlK0nOf/e/dqy3z20Rtccs39/P1fb7Jo/o+t7VFGjd6WD99/mVeef4h5s78j3KaMvPuOi9l41Jbc98TH/Py48/jw/dhrfQcCQU4+6xLue+Ijrrn1SWZM/5y3X1u9jPzys/e47vb/cuvdL/PT3O/5151Xcdavr+H+Jz5mnwN/yR03XEBTU/KUkYEADOnnPSERiVexJiV3OueWOudKgYnAdpHpJwEPOee+cs41AJcB481s5DrEcKdzbpFzrg44GXjNOfeacy7snHsbmAocYmbDgZ2AqyJJzuRILJKgysvKKSgoWK160amnnsIee+zOLjvvxJdfTmWnnXZis802JxAIsPnmm3PQwQfz5ZdTY1p/SkoKCxctpKysjKysLMaO3bZ1enlFBYsWLSIYDLLllluSk5OzxvuHDx/O+PHjSUtLo2/fvpx8yql8OfXL1ZY58cQTGTBgAPn5+fxsr72YNcu7u3boYYdxyaWX8eknn3DWmWewz94TeOjBBwFYtmwZM2bM4De/+Q1paWnssMOO/GyvvWL+3LbcckvGjt2WlJQUhg4dyi+OOWaNuM468yzy8/PJyMjg+eee45hjfsk2Y8cSDAY54ogjSUtNZfr06TFvUyRRpKbA8P5hstIT/+KrqrKc3LyC1aoXXXPxSZxzwq6cfsz2/PDdVLbcZmeGj/TKyOEbj2a3nx3MD999EdP6g8EUVixbSFVlGRmZ2Ww2ZtvW6dVVFaxYupBAMMjGo7YiK2vNMnLQkBFsM243UlPTyMvvyyE/P40fvlu9fD7wsJPp028AObkFjNtpLxb8NBOAPfY+nNN+dQXTp33M9Zefzvmn7snLz/4LgOKipcyb/R3HnPRbUlPT2GLrHRm304SYP7eNR23FZmO2JRhMof/Aoexz4C+ZOWP1uI445mxycgtIS8/g/TefZZ8Df8mo0WMJBIP8bN+fk5qaxpxZ38S8zXgWCMCQvmEK1I22xLlYK1Iuj/q7FmipojUE+KplhnOu2sxKgKHA/BjXvSjq7xHAL83s8KhpqcD7kW2VOedqouYtAIbFuB2JM/kF+ZSXl6/W7uGxxx4H4ID99yMcdnw7fTr/+Mc/mDt3Dk1NTTQ2NrL//gfEtP6rr7mWe++5m6N+fiRDhg7lvHPP42d77cWhhx3G8hXLufSSi6mqquKQQw/lggt+S2pq6mrvLy0p4ZZbbuGrr76itraGcDhMXl7easv0Kyxs/TsjI4OilUWtrw899FAOPfRQmpqaeP/997n8sksZM2YMObk55OXlkZmV1brskMFDWL58ObFYMH8+t99+O99/P4P6+npCoRBbbLHFassMHDSo9e+ly5YxceJE/vvUf1unNTc1UVS0MqbtiSSa1BQY1j/MoqIAtQ2JW08lJ6+Aqsry1do9XHPrfwC44Ix9cC7MnFnTeeqxv7J4wRyam5tobmpk590PjGn9v/rdX3j2P3dx4fmHMWDgUI464ddsv9ME9tj7cEqKl3PX7RdSW1PF7nsdxrGn/J6UlNXLyIryEh77103MmvEldXU1OBcmOyd/tWUK+qwqI9PTMykvXVVG7j7hMHafcBjNzU18+dl73P3Xixm5yRZkZuWSnZNHRsaqMrKw/xBKi2MrI5ctmc8TD97KT3O+o6GhnnAoxMajtlxtmX79B7f+XVy0lA/fe4m3Xn2ydVpzUxNlJYlfRpp53WfnZSkhkfi3oa27luIlEgCYWTbQD1iyDuuI/k9ZBDzunDun7UJmNgLoY2bZUYnJcNRDfcIaO3ZbUlNT+eCD99lvv/3bXeayyy7luONP4O577iE9PZ1bb72F8rJywKvaVV9f37psKBSirLS09fWIESO4+ZZbCYfDvPvuO1x44Z+YNGkymVlZnHfe+Zx33vksWbKE317wG0aOGMlRRx+92rbvvPNOzOB/zz5LQUEB7733HjffdOM672dqaioHHHAAjzz8EHPmzGG//fensrKSutra1sRk2fJlGBbTft1ww/WMGTOGm2+5hezsbJ544nHeefud1bYZ3SPPoIGDOOvssznnnF+tc+wiiSolCMMHhFmwMkBdgiYmm43eltTUNL78/D123q39mzF333ExBxx6AhdffT9paek8/q+bqKosB7yqXY0Nda3LhkMhqirKWl8PGjKCCy66nXA4zBefvs2dN/+B+/7zMRkZWfzihF/zixN+TdGKJdx63XkMGboxEw74xWrbfvqxv2PATXe+QG5eAVM/e5dH7r9hnfczJSWVXfY4kInPP8iiBXPYefcDqKmupL6+tjUxKSleVUaubb8evvc6RmyyBRdceBuZWdm8/tJjTPnkrQ63369wEEce+yt+fuy56xx7vBveP0ROpt9RiMRmQzuDexI4w8y2M7N04Ebgc+fc/PVc3xPA4WZ2oJkFzSzDzCaY2UbOuQV4VbmuNbM0M9sDOLzz1Uk8y8vL49zzzuPGG27g7bffora2lnA4zMyZM6mr8044NTU15OfnkZ6ezrfffsvrr73W+v4RI0bQ2NjI5MmTaWpq4l//emC1Bt+vvvIKpaWlBAIBcnO9JxyBYJAvpkxh9uwfCYVC5OTkkJKSQiAYXCO+mtoaMrOyyM3NZcWKFTz66CMx79tLL73E5MmTqanxnrB89NGHzJ07l2222YYhQ4aw5ZZbcu+999DU1MS0r75i8qRJMe9XTU0t2dk5ZGVl8dNPP/G/Z57pNJajf/ELnv3f//h2+nScc9TV1rbGJpLMggGv8XuitjHJzsnjqOPP5+F7r+fzj9+kvs4rT+bP+4GGeq+MrK+rITsnn7S0dOb+OJ1PJq8qIwcPGUlTYyPTvphEc3MTLzxz/2rtJD56fyKVFV4ZmZ0dKSMDQWZM/5yF838kHAqRmZVNSjAFC655uVBfV0N6ZhbZ2bmUlqzglecfinnfJr37AtO+mERd5Cn0119+yOKFcxg1ehv6DxjCxqO24rkn76a5qZFZ33/JV1M+iHm/6upqyMzKJiMzi6WL5/HuG093GsveBxzDu288w5xZXhlZX1/bGluisoD3tFAJiSSSDXpS4px718yuAp4D+gCfAMdvwPoWmdmRwK3Af4EQMAU4P7LIicCjQCnwKfAYXgN5ACI9fB3snNMAJQnijDPOZMCAgTzy8CNcdeWVreOU/P7//sB2223H5VdcwV/vuIObb7qJHXbYkQMOOJCqqioAcnNzuezyK7ju2msIhUKcfsYZDBg4sHXdH3/8Mbfffhv19fUMHjyEm2+5lfT0dIpLirn++r+wYsUKsrKyOPDAgzj00EPXiO3cc8/jqiuvYI/dd2PY8OEcduhhPPHE4zHtV052Ng8++G+uuPwywuEwgwcP5vIrrmTc9tsDcNPNt3DVlVfwsz33YOy223LYYYfHvF9//NMf+ct11/HIIw8zZswYDjzwIKZMmdJhLFtttRV/vvpqbrr5JhYuXEhGejrbjRvHDjvsENO+iCSylsRk/soADY2J98Tk8F+cRd9+A3nl+Ye472+Xk56RyYBBG3HCaX9g8zHbcfp5V/Kfh27j0QduYMxWO7HL7gdSW+OVJVnZuZx+/pX8+59/JhwOc9jRZ9K3cFVZMv2rj/jPQ7fS0FBHYf8hXHDR7aSlpVNRVszD915HafEK0jOy2HXPg9hjwpr3AI8+4dfc+7fLOPuEXRg4eDh7TDiC119+LKb9ysrM4aX/PcA9f72UcDhE4YAhnHH+VYze0iuXLrjwVu77++X86qTd2Gz0duy59xEx79eJZ1zEg3dfwyvPP8TITbZg1z0OYsb0zzuMZZPNtubs31zDo/dfz/JlC0lLS2fzLbZnzFbdPixDtwgEvG5/VWVLEk2PDp7Y1czsGmCUc+7ktvM0eKIkknvvvYdFCxdx4003+R2KSFJqbIYFK5NvHJPe4rkn72bFsoX8+k+3+B1KfDMY3Ee9bEnX6qnBEzWWp4iIJL20SK9cyTSOiUhbSkgkkSkpERGRXiE9FYYVhkkJ6qJNks+AgjB9cnRsS+JK6OpbnVH1LRERaU9tA/y0Iqi+GyVpFOQ4hvYL+x2GJClV3xIREekGWekwon8I0xlQkkB+thISSQ4qkkVEpNfJyYRBBWElJpLQcjIdg/sqIZHkoOJYRER6pb65jv55uqCTxJSR5j0haWcIGZGEpENZRER6rcI8R6ESE0kwaamO4f3DpKw57q9IwlJSIiIivZYZ9M935GqgOUkQFvB6kUvdoOGvReKPkhIREenVAgFvDJOsdCUmEt8CAa+Thow0vyMR6XpKSkRERIBh/cOka3BFiVMWgEF9wmRn+B2JSPdQUiIiIgKkBL3EJDVFiYnEn/55GhxRkpuSEhERkYj0VLwejdSAWOJIYV6YfnlKSCS5KSkRERGJkp0BQzT2g8SJnExH/wJHwPyORKR7KSkRERFpIy/LMbRQiYn4KyvdMWJAWAmJ9ApKSkRERNpRkB0Zw0QXhOKD9FTHRkqMpRdRUiIiItKBgX0cBdmqyy89KzXFRTpd8DsSkZ6jpERERKQTg/uEyVNiIj0kJegNjpie6nckIj1LSYmIiEgnAgEvMdHgitLtDIYWhshM9zsQkZ6npERERGQtUoIwfECYjDQlJtI9zGB4YYgcDY4ovZSSEhERkRgEAzBiQJg0jfouXaxltPbcLL8jEfGPkhIREZEYpQRheP8wKUElJtJFzButvW+ujinp3ZSUiIiIrIP0VO+JSWqKLiJlww3ID9M/X8eSiJISERGRdZSRRqTLVl1MyvobUBCmME/HkAgoKREREVkvmZHERFW5ZJ0Z9M/3EhLT4JwigJISERGR9ZaZ5lXlSgn6HYkkCjMozAszoEAJiUg0JSUiIiIbICMNRgwIqSqXrJVFnpAMLNCxItKWkhIREZENlJEGIweGSdc4JtIBMxjcV43aRTqipERERKQLpKXAyAFhsjN00SmrswAM7x+iT46ODZGOKCkRERHpIi0jvxfo4lMiUlMcmwwMkZPpdyQi8S3F7wBERESSScBgaL8waSlGUWUAF/Y7IvFLdqZjaN8wqbraElkr/ZuIiIh0g/75jsy0EEtKAjSH1M1Sb1OYH6Z/niOgOikiMdG/ioiISDfJyYRRQ8LkZ6s6V2+RmuIYOTDEwAIlJCLrQk9KREREulEw4FXnyssylpcZTc16apKMzKAgx+vuN6hkRGSdKSkRERHpZmaQl+XIznCUVBolVQHCamuSNHIyHQPyw2Sm+x2JSOJSUiIiItJDggEYUODomxuitNoorQoQCvkdlawXg5wMR//8MJlpaHR2kQ2kpERERKSHpQRhQL6jMC9EdZ1RUWvU1JsSlHhnkJnmyM105Gc70nQVJdJl9O8kIiLik0CkWldelsM5aGiC+iajqRlCYQirfbyvDAgEIDUIaamOzDTUXkSkmygpERERiQNmkJEGGWnKRESk91G+LyIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivlJSIiIiIiIivkrxOwARERFpw4Uh3AiE/Y6klzOwFAik+h2ISNJTUiIiIuK35gqssQhrKsOaqyBc73dEEs2CEMzGpRbgUvvjUvtBQJdQIl1J/1EiIiJ+CDdg9YsI1C+CUJ3f0UhnXAiaK7HmSqxuIVgQlzaQcOYwSO3nd3QiSUFJiYiISE8K1ROom4vVL/YudiXxuBDWsJRgw1JI7UM4azNcWqHfUYkkNCUlIiIiPcGFsbq5BGrnKRlJJk1lBCqm4NL6E87eAlJy/I5IJCEpKREREeluTWUEq6ZDqMbvSKSbWGMRwaYSwlmb4jJHgZnfIYkkFCUlIiIi3cWFsLp5BGrnej1qSXJzYQI1s6GxmFDONnpqIrIONE6JiIhIdwjVEaic6l2kKiHpXZrKCFZ8htUv9TsSkYShJyUiIiJdramcYOVX6tq3Nws3EqiejgtVEs4e43c0InFPSYmIiEgXsoblBKq+1tMR8To3qJ1HIFRDOHccmCqoiHRESYn0OBcOE25uxOmE7TuzAIGUNCygE6VIV7DaeQRqZvodhsQZa1hBMPwZobwdIZDmdzgicUlJiXSrcKiZxupSGqpKaKypoLm+hnBzg99hSRuB1AxSM7JJzconPbcvabn9CASCfoclklAC1d9jdfP9DkPiVVM5wYpIYhLM8jsakbijpES6nAuHqa8sorZkCQ2VRbiw+uOPd+Gmehqa6mmoKqF6xTwskEJGfn8y+w4hI6+/nqSIrEWgaro3GKJIZ5qrCVZ8TihvJ/XMJdKGkhLpMuFQM7XFi6ha8RPhJjXuTGQu3Exd2TLqypYRTM0kZ9DGZBUO09MTkbZcmED1d0pIJHahOoIVUwjl7wQpuX5HIxI3lJTIBguHmqkpWkj18nmEQ41+hyNdLNRUR8Wi76laNpfcwZsqORFp4UIEqn9QQiLrLlxPsOILQvk764mJSISSEtkgdeUrqFj8A6GGWr9DkW4Wbm6gYtH31BQtJG/oaDILBvodkoh/XJhAzQ9Y/UK/I5FEFa4nWBlJTILZfkcj4jtVFJf1Emqsp2TuV5TO/VIJSS/TXF9N6dwvKZ33NaEmdVogvVOg5nusTgmJbKBIVS5CNX5HIuI7PSmRdVZbsoSKRT+oqlYvV1e2lIaqEvKHbUlW38F+hyPSYwLV32P1i/wOQ5JFqI5gxVSvjYl65ZJeTE9KJGbh5iZK531N2fzpSkgE8Kp0lf30NWXzvyXc3OR3OCLdyzms7iev21/n/I5GkkmohmDlVxBWOSq9l5ISiUlTbSUrZ35MXdlSQCdjieaoLVlE0axPaaqv9jsYkW5jDYsJVP/gdxiSrJorCVZOBadu9KV3UlIia1VbupSiWZ+p7Yh0qrm+mqKZn1JXttzvUES6nNUvJVA9w+8wJNk1lRGo+gbCzX5HItLjlJRIh1w4TMXiHyj76WucCkiJgQs1UTrvKyqX/ogLh/0OR6RrNJUQqJkBTse0dD9rWE6gdpaqCEqvo4bu0q5wcxOlP31NQ2WR36FIAqpaNoemumr6jBxLIKhiRhJYc4Xq+kuPs7oFBCxIOHuM36GI9Bg9KZE1NDfWUfzjZ0pIZIPUly+neNZn6jZYEleonmDFl0pIxBdWN9/rVEGkl1BSIqtprCmneNZnNNVV+R2KJIGmukqvAXxtpd+hiKybcJPX6Dhc73ck0lu1DNDZuNLvSER6hJISaVVXvoKS2VMJNdb5HYokkVBDLcVzplKvJ2+SKMJNBKqmQbOSafGZcwQqp0FTqd+RiHQ7JSUCQE3xYsp++kbjj0i3CDfVUzrva2pLl/kdikjnnCNQMwtrLPY7EhGPCxGs+kajvkvSU1LSyznnqF65gPIF36qHLelWLtRE2fxvqCla6HcoIh0K1PyA1esYlTgTqiNY8QWEVJNBkpeSkl7MhcNUr5hHxaIZaEBE6REuTPnC76he8ZO6DJa4Y3ULlJBI/ArVagwTSWpKSnopFw5TuXQWlUtm+R2K9EIVi3+gavkcJSYSN6xxpTc4osYikThmTaUEqr72OwyRbqGkpBdy4TDlC2dQveInv0ORXqxq2RwqFv+gxET811RCoPJrv6MQiYkSaElWSkp6odJ506gtWeR3GCLUFC2gbP50v8OQ3ixUQ7BqOjhViZHE4VU1XOB3GCJdSklJLxIOhyia9Rn1FSv8DkWkVV3ZUop/nIJzatckPSxUS7BiihoPS0IKVP+A1SkxkeShpKSXCDU3UvLjFBqr1de5xJ+GqmJKZk8h3KyRs6WHhJsIVn2thEQSWqBmFtagG42SHJSU9ALNjXWUzP6Cxpoyv0MR6VBDVQklc6YSatQI2tLNnCNQ9RU0lfsdiciGcc1ej1xNOr9L4lNSkuSa62somf0FTbUVfocislaNNWWUzJlKc0Ot36FIsnIhAlXfYI0lfkci0jVcszeGSXOV35GIbBAlJUmsqb6a4h+n0Fxf7XcoIjFrqqukePYUmus1erF0MReOVHdZ6nckIl3LNROsnAoh3dCRxKWkJEk1VpdRPOtzQk2qLy2JJ9RQS9GPn9NUW+l3KJJEArU/YnXz/Q5DpHuE6iKJiarASmJSUpKE6spXUDLnS8LNDX6HIrLewk31FM/+gobKYr9DkSQQqJmF1WlsJklyzdVKTCRhKSlJMrUlSyibP51wqNHvUEQ2WLi5gZJ506gtXeZ3KJKonMPqfsLq5oG6nZbeoLmSYNU0COs6QBKLkpIkUrV8HmULvsWF1K2qJA8XaqJ8wXSqV873OxRJQNawhED1D0pIpHdpKvOemOi4lwSipCQJuHCYisUzqVwyE1zY73BEupwLh6hY9AOVS3/UIIsSM6tbSKBqut9hiPijqZxgxWcQbvY7EpGYKClJcOHmJsoWfEv1inl+hyLSzRxVy+ZQvnAG4ZBOstI5q/uJQM33foch4q+mMgJVX0JYbUwl/ikpSWChxnpK531FXekSv0MR6TG1xQspnTdNgyxKh6x2LoGaWXpyLAJYYwmBymlq/C5xT0lJgmqqraTox89oqNIAYNL7NFQWUTx7Ck0ag0eiOYfVziFQ+6MSEpEo1lRKsPJLJSYS15SUJBjnHPUVK1k58xNCGvVaerHm+mqKfviE+soiv0OReODCBGp/JFDzoxr3irSnuYJgxecQ0vhlEp+UlCSQcDhE1bI5lMyZqruAIoALN1My+wuqls/DhfU/0WuFmwlUf4/VzvU7EpH4FqrxGr83V/gdicgalJQkiFBjPWXzvqZq2Wy/QxGJO5VLZlI2/xtCTWrM2euEGwlUfY3VL/Q7EpHEEKojWDEVa1zpdyQiq1FSkgAaq8somvUp9RUr/A5FJG7VlS2jeNZnNNbqDmCvEaolWPG5Lq5E1lW4gUDl11idknmJH0pK4pgLh6laPo+iWZ8SalQdUJG1aW6ooeiHT6heOV/VuZJdUynB8s+gucrvSEQSk2smUDODQPX3aoclcSHF7wCkfc0NtZQvnEGDGvGKrCNHxaLvaagsoWD4VgTTMvwOSLqY1S0kUPMDuJDfoYgkNuewuvkEQjWEc7eDQKrfEUkvpiclcaimeBErf/hYCYnIBqivWMHK7z+itkTj+CSNcBOBqm8IVH+nhESkC1ljEcHyj6Cp1O9QpBeLq6TEzD4ws2c7mDfVzB6J/P3ryOsyM6s1s28j06xHA+5izQ21FP84hfIF3+JCTX6HI5LwwqFGyuZ/Q/HsL2hWFcjE1lxFsOJTrF5Jpki3CNURrPhCvdiJbxK1+lYf4AVgOlAL7Av8E8gCbvcxrvUSDjVTU7SQqmVzcOFmv8MRSToNlUWs/P4j8oZsRlbhMAKBoN8hSaxcGKtfSKBmprpCF+luLkSgZhauqYRwzjYQzPQ7IulFEjIpcc7d0GbSu2Y2AjiVBEtK6spXULX0R5rq1FhTpDu5UBMVi76ntngxeRuNJiOvv98hydqEaghUz8Aai/2ORKRXscZiguUfE87eApc+BBK7IookiIRMSjpQAqT5HUSsmmorqVg8k4YqnWxFelJTXSUls6eSnldI/rAtSM3I8TskaYfVziFQO1dtR0T8Em4kUPUNrmEp4ZytIJjld0SS5BI6KTGzFCAD2BPvKclV/ka0dk21lVQtn0dd2VK/QxHpxZxXpWtGEVn9NiJn0CZKTuJFUwnBqu8gVON3JCJCpBF82STCWaNwmZuCxVVzZEkiCZuUmNkgYFnUpOudc3f5Fc/aNNaUU7V8HvUVK1UvWiSO1JYsprZ0KZkFg8gZtDFpWfl+h9Q7NVcSqJ2NNWiQWJG44xyBmtlQv5hw1ua49MFKTqTLJWxSAhQDOwE5wATgUjOrds7d4mtUUVw4TH3FSmqKFtBQVeJ3OCLSERemrmwpdWVLSc8tJHvACDLy+mMBnXS7Xag2kows0w0bkXgXqiNQ9Q3UzfOenKQP9jsiSSLxlpQ0Ax11ixOMzAfAOdcMTI28/MDMwsA1ZnaXc6522rRp5OX6Wx1j9GDoo44rRBJScTXMWel3FMktGIBthkKqcj+RhOOAhWWwstLvSCRZxFtSUgSM7GDeYKCzS4Sv8NqXDAHmjBs3jkmTP+za6NaVC2MNywjUzoZQrb+xiEhsgtmEszfHpQ1U9YQeUlu6jJqV82msKce71BGReBVISSe7/zCy+48gmJrudzjSA3rqJn+8JSUfAr8ws6HOudYRssxsF2BgZH5HdgcagPhpQW4BXMZQQulDsPoFBGrnQLjR76hEpD2BDMJZm+IyR/gdSa+T1XcwWX0H01hdRtWKn6gvX+53SCLSRjAtk9zBo8jsO0RjPUm3iLek5DHgj8BkM7seWABsAVwNfAK8CWBmXwCPArOAVGB/4ALgDudc/D2SMMNljiSUPsSrO12/WN1cisQLC+IyhhPOGgWBVL+j6dXScvrQL6cPTXVVVC750esYRE9ORHwVTM8id9CmZPXbCNN4JdKN4iopcc5Vm9nPgBuBm4G+wArgaeAK51pbQX4N/A7YCG9E99nAGcB/ejrmdRJI8/r6Th9KsOZ7aCr3OyKR3i21D6GcrSAlz+9IJEpqZi79Ru1AQ3UpVUtnq6MQER8EUtLJHbwpWYXD9GREekRcJSUAzrmlwOlrWeacnommm6QWEMofj9XN89qbqMcZkZ5lQa/dSObGfkcinUjP6UvaZjtTX7GSikXfE2qs8zskkV7AyBkwgtzBmxFI0dNj6Tlxl5T0Gma4rE0JpfUnWPUtNFf4HZFI75Dah1DONpCiwRITgZmRWTCQjLz+VC79kZqiBbiwqr+KdIe0nL4UDNuS1Cw9PZaep6TEbyl5hPJ38dqa1P3kdzQiSc1lbeq1HTFVRUg0FgiQv9EYsvoOoXzR9zRWl/odkkjSCATTyNtoNFl9h2p8JvGNkpJ4EEghnLMFltbPG5Qo3OR3RCLJJZBGOHc7XFqh35HIBkrNyqNws52pKV5IxeKZqv4qsoHScwspGLkNKWkaWE38paQkjri0AYQKdiNYOQ2aNRqRSJdILSCUuy0Es/2ORLqIBQLkDBhJel4hZfO+pqlO5aXIurJACnlDNydnwEi/QxEBQM/o4k0wm1D+zrj0wX5HIpLwXMZGhPJ2UkKSpFIzcigcM967qNJAlyIxS83Mo//oXZWQSFzp0VLczI4ys0VmVm1m43py2wklkEY4d1uv7rv0qPMue4iX3vrS7zCkC4SzRxPO2VpjjyS5QCBI/rAt6bvJOAKpGX6Hk/T+/NeHeOdjlZGJLLv/CArHjFdjdok75lzPDUxlZnOBPzrnXurubW2//fZu0uTOBoBPAM5hDUu9diZJ7PX3v+Hx5z5izvzlZGakMXRQX47Yf3uOO2LXhB6o6V9Pvs9zr02htLyG3JwMxm01ktuvOtHvsJKfGeGcbXEZQ/yORHpYc0MtpXO/SrrqXJM+/4YX3/qIBUuWk5GexsDCvuy7+/Ycundil5FPv/I+b06eQkVVDdlZGWw5aiSXnq8ysrtYIEj+sK3ILtzI71AkweTl5nzpnNuxu7fT021KRgAz2pthZinOueYejie+meEyhhK2FC8xScKP59H/Teahpydzxe+OZPcdNycrM42Zc5byyP8+5OiDdyItLTGbPb301pdMfOcr/nXr2Qwb0o/i0ire/+T7Ho+jORQiJdiLepoKpEYatPf3OxLxQUp6Fv232J3yBd9SW7KEZBgN/vk3JvPcG5M5/+Qj2X6rzcnMSGPewqU8/+aHHLjnTqSmJmYZ+c7HX/Lep19xw4VnM3hAP0orqvh8Ws+XkaFQiGAvKCOD6Vn022R7PR2RuLbWJyVmNh/4J3AqXlLxBnCac64+Mv8c4BK80dc/As6LDIAYvY50oATIxhuBfblzbtPIuu8FTgJGR+bvCPwV2BJYAPzeOfdBZD0bA48A2wOfAbOAAufcyW3jToonJdGaSr0G8OEGvyPpMlXV9ex7/A3ccPGx7P+zbdpdZvJnM7nr4TdZtKyUnOwMjj5oR3592v4AfPH1XC69+Wnefery1uUPPOlmrvnjLxi/w2Z8O3MR19/5IgsWF5Oelsqh+27HxecfRkNjE1ff8RwfTfmRcDjM8KGF/POG0yjsk8sZf7yfw/Ybxy8O2ZlFS0u45q/PMWvucsxgtx0354rfHUleTmbrtk44cjdefvsrlq0oY/edRnPDJb8kPS2VG+56iZRggEt+fXi7+7V4WSlX3vY/fpi9hLFbDGfksP5UVddx82XHx7RfN989kZ8WriQ9PZX99tyai887tPXiZJv9LuXy3x7JE89/RCgU5o0nLmHSZz9w18NvsXR5GZuMGMBV/3cUozdJsnZLgQxCedtDaoHfkUgcqF45n8olP+LCiXszp6a2nlP+eAN/OvtYdt+x/TJyyjczefyFN1m2spTszAwO2HNHTvq5V0ZOnzmX2//1NI/dsaosOeOim/nd6b9g3FabMWveIu55/EWWrPDKyAm7bsc5xx9GY1MT/3j4Ob781isjhwws5Orfn0af/FwuveV+9h4/jgN/tjPLVpZw5yPP8dMir4zcfuvNOf/kI8nJymzd1mH77sZ7n3zFypIydth6NH88+5ekpaZy7xMvEQwE+NWJ7ZeRy4tK+duD/2PugiWM3nQ4Gw3qT3VtHRf96viY9uuB/05k0dKVpKWlsvsOW3P28YeSmuKVkYeeeSnnn3QkL739EaFwmIduvYQpX//AYy+8xcriMoYNGcAFpx7FxsOSo4zMyB9AwYhtCKam+x2KJKh4e1JyLHAQUA98jDfi+n1mtg9wE3AA3hOQ24GngJ9Fv9k51wDkmJkDtnXOzYmafQJwKFAMDAReBU7BS372BZ4zszHOuSLgSeDTyPZ2iSzb7VXB4kJqX0L5OxKs/ApCyTGq8TffL6CxMcTeu2/Z4TKZGanccMlxjBo5gNnzV/Crix9k9Kgh7Lv7Vmtd/813T+Tko3bn8P23p7augdk/rQDgpbe+orqmnrf/eylpqSnMnLuUjLQ12x045zjrhL3ZcZuNqa6t5w/XPsG9j72zWqLx5qTp3HfTmaSnpXDK/93LS29+ybGH78rYLYZz890vM6BfHjtvtyljRg0hGFzVhOuSG59i2y2H88DNZzF95kJ+c8Uj7L1bx59DtEDAuPj8w9hq9FBWFFVw/uUP89TLn3HKL/ZoXea9j2fw5F2/IT09le9nL+HPtz/LXX85ja0234hX3p3G7656lIkPX5iwT6LWEMwilLcDpOT6HYnEiZwBI0nJyKZs/reEm+r9Dme9/DB3AU3NIXYd13HZkJGeyp/OPo7hQwawYMkKrrzjQTYZPoTx26+9jHzgvxM5cv/d2We37amrb2DBEq+MfPfjr6itq+eR2y8lNTWFeQuXkt5BGXnsoXuz9eYbU1tXzw33PMGTL76zWqLx0RfTue4PZ5KWmsKFN93LOx99ySF778roTYdz/5Mv069PHmPHbMomI4YQjBof47YHnmLMpsO5/k9nMWveQq75+yPs0snnEC0QMM45/jA2GzmU4rIK/vy3h3n1vc/4+QGryshPp83gr1f+hrS0VOYsWMLfH36WP//uNDbbeCPe/3Qa1935KA/ceGHCPolqkTNgJHlDx2jsEUkIsR6ldzrnljrnSoGJwHaR6ScBDznnvookHpcB481s5DrEcKdzbpFzrg44GXjNOfeacy7snHsbmAocYmbDgZ2Aq5xzDc65yZFYeo+UfEJ5O0IwOfoSL6uspSA/a7XqRSf/7h52O/IadjzkSqZOn8dO223K5psMIhAIMHqTwRyyz7ZM/WZeTOtPSQmwcGkJZRU1ZGWms+2WwwFIDQYor6xl4dISgsEAW22+ETnZazaQHT60kN122Iy0tBT6FuRw6jF7rrHtE4/anQGFeeTnZTFh1y2YOXcZAIfvN47LLjiCj6fO5ow/3c9ex1zPv//7AQDLVpQzY9ZiLjj9ANLSUthx7CbstesWMX9uW22+EdtuOZyUYJChg/ryy0N3Yer01eM6+4QJ5OdlkZGeynOvTuGYQ3dh7BbDCQYDHHnADqSlpvDNDwtj3mZcC2YRyt9ZCYmsISOvP4Wb70xKemL2vlZZXUteTtZq1Yv+dMM9HPubazjq3Cv5btY8xo7ZlJEbeWXkxsMGs9fO2/LtrNjKyGAwwNKVJVRU1ZCZkc6YTYe3Tq+srmXZyhKCgQCbjdyIrMw1y8ghAwsZt9VmpKamkJ+Xw1EH7Mm3P66+7cP3251+ffLIzclil223YN4ir4zcZ/w4zjvxCL78bjaX3HI/J/3+ep559QMAVpaU8+NPiznlqANITU1h69GbsPN2sZeRm43ciDGbDicYDDKwsC8H77UL37X5TI49dAK5OVmkp6Xy5qQpHLzXLt57AgH2230HUlNSmDkvgctIC5C/0RbkD9tSCYkkjFhvASyP+rsWaGlBOgT4qmWGc67azEqAocD8GNe9KOrvEcAvzSz6eW4q8H5kW2XOuZqoeQuAYTFuJzmk5BLK34VgxecJ/8SkIC+L8ora1do9PHHnrwHY9/gbcWHH9B8W8vd/v8Gc+StoamqmsSnEAXu1X42hrev+dAx3P/o2R5xxB0MH9eX8U/dlr1234LD9t2d5UQUXX/9fqmrqOGzfcfz2zANJTVm9XnFJWTU33/0yX307n5q6BsJhR17u6glhYZ+c1r8z0lNZWbKqge1h+47jsH3H0dQc4r2PZ3DpTU+zxagh5GRnkJebSVZmWuuyQwb2YXlReUz7NX9xEbfd+yozflxMfUMToVCYLTcbutoyg/oXtP69dGU5L7/9Ff998ZPWaU3NIYpKkqAxcKQL7WRJ1KXrpWbkUDh6V0rnTUu4UeDzsrOorK5drd3DHVd4ZeSpf7qRsHPMnLuQR557gwWLV9AcaqapKcQeO8VWRv7+jGN44oW3Oe+KOxhY2JcTj9iXnbfbgn3Gb09xaQW33Pdfamrr2Hv8OE49+kBS2pSR5ZXV3P/ky8z4cT619Q0451qrbrXok7eqjExPS6WkfFW5s/f4cew9fhzNzSE+nTaD2x94mk1HDCE7M4OcrEwy0leVkQP69aGotDym/VqyvIh/PfUqs+cvpqGxiXA4zKgRq5eRhX0LWv9eWVLOu598xcR3V5WRzaEQJWWJWUYGgmkUjNiazD6D/A5FZJ1s6HPJpXiJBABmlg30A5aswzqiG7UsAh53zp3TdiEzGwH0MbPsqMRkOMnQknFdRe4MByumJHRisu2Ww0lLC/L+x9932Kbkkhuf4oQjx3PvTWeQnpbKLfdMpKzC+/ozM9Kob2hqXTYUCrfOAxixUSG3XnEC4XCYdz6awR+v/Q8fPv9nsjLTOP/U/Tj/1P1YsryUX1/+CCOH9efog3dabdv/ePANzIznHvg9BfnZvPvxDG68a91rC6amBDlwr7E89PQk5sxfzv4/24bKqjpq6xpbE5NlK8tp6URnbft1/T9eZMyoIdx6xQlkZ6Xz+HMf8fbkb1fbZnSHPIP653POiXvzq5P2WefY41owm1D+TkpIZK2Cqen0G7Uj5QtnUFe6Lqcnf40ZNZzUlCCfTfu+wzYltz3wFIftO57r/nAGaampPPDkRCqqvfIiIz2NhsaosiQcpqJqVVkydGAhl5znlZGffDWDG+/5D0/d9Wcy0tM48cj9OPHI/VhRXMrVf3uEoYP6c+DPVi8jH3n2DcD453W/Jy8nm0+/msG9/1n3MjIlJcieO43l2dcmsWDxcvbYcRuqa+uob2hsTUyiE5K17dfdj7/IJsOHcPG5J5CVmc6Lb33Ex1PblJFRfxf2zefYQ/fm+MMTv4wMpmbSd5PtSMvp43coIutsQ5/pPQmcYWbbRRqz3wh87pybv57rewI43MwONLOgmWWY2QQz28g5twCvKte1ZpZmZnsA7beQ6w2C2ZFB4RL3giwvJ5PzTtmP6+98ibcmf0ttXQPhcJiZc5ZSV98IQG1dA/l53iP2b2cu4rX3vm59/4iN+tPY2Mzkz2bS1Bzigf+8R2NjqHX+xHemUVpeTSAQIDdSPSsYNKZ8PZcf5y0nFAqTk5VBSkqAQGDNbjVrahvIykgjNyeTFcUVPPLM5Jj37cU3pzL5s5nU1Hr79OGUWcydv4JtxgxnyMA+bLX5UO557G2ampr56tv5TPrsh5j3q6a2geysdLIy05i3cCXPTPys01iOOWRnnnnlc6b/sBDnHLV1ja2xJaxgViQhyfI7EkkQgWAKfUZsQ87ATfwOJWY5WZmceOR+3PPES3w09Vvq6r3yZO7CpdQ3eGVkXX0DudlZpKWmMmveIj74/OvW9w8d2J+mpmamfDOT5uYQT098j6bmVWXJe59Oo6LSKyOzI9WzAgHjmx/mMn/xckLhMFkZGaQE2y8j6+obyMxIIzsrk+KyCp57I/Yy8u2PpjLlm5mt5f7U6bNYuHQFozcZzoDCPmw2cihPvPg2Tc3NzPhxPp9/vaqMXNt+1dU3kJWZTmZGGouWreS19zsvIw/62c68/sHnzJzrlZH1DY2tsSWSlIwcCjffWQmJJKwNelLinHvXzK4CngP6AJ8Ax2/A+haZ2ZHArcB/gRAwBTg/ssiJwKNAKV6D98eAgpb3m1k1cLBzLom63epESg6hvJ0IVn6RsE9MzjxuLwYU5vHw05O44pZnyMxIY6PBffnD2Qez3VYjuOJ3P+f2+17lxrteYsexm3DAXmOpqvb2NTcngyt+dyRX//U5wuEwZxy7FwP7r+ru8OMvZnH7fa9QV9/EkIEF3HrlCaSnpVJcWsVf/v4CK4oryMxI56AJYzlsvzXH8jz/1P24/JZnGH/kNQwf2o/D9xvHY899FNN+5WRl8K//vs+lNz9FOOwYPKCAK3//c7bfZiQAN19+PFfe+j92P+o6tt1yOIfvv33M+/Wncw/h2r+9wMNPT2aLUUM4cMJYpkyb22EsW43eiGv+cDQ33vUyC5cUk56eyritR7LD2I1j2pe409KGRAmJrCMLBMgbOppgajoVi39Y+xviwDEH70W/gjyee30Sf/33M6SnpTGof1/OOOZgthg1gl+f8nP+/fSr3PfES2w9ehP23Gks1bVeWZKdlcH5Jx/JnY94ZckvDt6Lwj6rypIvv53Fv596hYbGJgb0K+CS804gLTWVsooq7n7sBYrLvDJyz53Gss/4NcvIE4/cjzv+/QzH/uYaBg/oxz7jx/Hi27GVkVmZGTzz6vvc/i+vjBzQr4Bfn/Jzttp8JAAX/ep4/vbg/zj+t9cxZtPh7Lvb9jHv11nHHsJdj77Ac69PZtPhQ9hz57FM/6HjMnKzjTfit6cfzX3/eZmlK4pJS0tly81GsvXmiVNGpmblU7jZzgRSNFisJK4eHTyxq5nZNcCoXtElcGeaKwlWfJFU3QX3Nvc8+jYLl5Zw82XrndP3DoGMSKP2nLUvK9KJmuLFlC/8DlzY71AkBv958W2Wrizhol+pjGwrI38AfUZuq4REuk1PdQmsLhmSQUqe1x2q6euUJGYphPJ3VEIiXSK7cCP6brwdFtSFnCSurH4b0Wfj7ZSQSFLQVWyySC3w6thbYvepLtKuQJp3fKdoNGLpOpl9BtF3k+0IpGhQOUk8OQNGkj98KwJBnfclOSR09a3O9KrqW1GsfimB6u/AJe4oxiKrCaQSzhmLSx/odySSpBqryyiZNy1hB1mU3id38ChyB43SGCTSI1R9S9aLyxhCOHu032GIdJlw9hZKSKRbpeX0oXDznQmkrjlAoEhcsQB5QzYnb8jmSkgk6eiITkIucwThnNhHvxWJV+HcbXAZG/kdhvQCqRk59N98l4Qd/V2SnwWC5A8dTe7gUX6HItItlJQkKZcxApc5Yu0LisQjM1zmxrh0JSTSc1Iysum3+c6kZqrtksQXCwTJH7YVOQMTp5tikXWlpCRZWYBwzlaq9iIJyaUN9p722ZoDtol0p5S0TPptthNp2RqATuKEBeiz8XZkF+omjSQ3JSVJLpyzLS6t0O8wRGLm0gcSzt3G7zCkFwumpnuJSU5fv0OR3s4CFG6+M5kFusEoyU9JSbILpBDOGQtB1ZOWBJCSSzhna7Cg35FILxcIptB/9K6k5+qmjvjDgqneMajkWHoJJSW9QTAyCnYw0+9IRDoWzPKO04DGjJD40W+zncjqp2oz0rOCqZn0H70radkFfoci0mOUlPQWwUxCueN0B1rik6UQyttBCYnEHTOjYMQ25AzcxO9QpJdISc+mcPQupGbm+h2KSI9SUtKbpBYQztseTF+7xBELEsrfAVJ0Apb4ZGbkDR1N/kbqal26V2pWPoVjxpOSnuV3KCI9TlenvYxL6084ewslJhIfLEg4ZytI7ed3JCKdMjOyB4ykz8bb+R2KJKn03EIKR+9KMCXN71BEfJHidwDS81zmCFy4Hqud63co0suFszbV4IiSMMyMrL5DCARTKJ33NS7c7HdIkiSy+g2jYPhWGqVdejUd/b1UOGtzDa4ovnJZm+AyN/U7DJF1lpE/gMLRuxBMVechsuHyhmxOwYitlZBIr6f/gN7KjHDWaFzaAL8jkV7IpQ8mnLWZBkeUhJWWlU//MePVO5KsPwvQd5PtyR08ClNZKKKkpFcLpHgN31ML/I5EehGX2pdwnnqCk8QXTMugcPNdyewzxO9QJMEEUzPpP2Y8mX0G+R2KSNxQUtLbWYBQ3o6QkuN3JNIbpOR7ibBIkrBAgL6bbEfekM2xgBJtWbv03H4UjtmVtKx8v0MRiStKSgQCaZExIjL8jkSSWTCTUN44CKhnGUk+uYNH0XfT7QmkqhyVjuUM3Ji+o3YkJU3tkUTaUlIinmC2Rn2X7hPMJJS/CwTV974kr4y8/gzYYncy8gf6HYrEmUBKOv0224n8jbYgoCdqIu1SUiKrpOQQyt1Wd7KlawXSCeVtr4REeoVgajp9N92e/GFbaTwoASC9JVnN6+93KCJxTeOUyOpS+xLKG0ew4gtwYb+jkURnAa9qYIrqTkvvYWbkDBhBRl4h5Qtn0FBV7HdI4oNASjp5Q0eTXaixmERiods4sqbUfoTzdtRdPtkwluJVCVTvbtJLpWRk02+zneiz8XZqa9LLZPcfzoCt9lRCIrIO9KRE2uXSCgnnjiNQPR3CTX6HI4kmkEY4d1tI7et3JCK+ahkFPrNgENUr5lG14idcSGVqcjIy8vuTN3Q0qZm5fgcjknCUlEiHXPpAwoxVYiLrJpBGOHcsLk31p0VaWCBA7uBRZPcfQU3xQmqKFhJqrPM7LOkKFiCzYBA5A0dqME2RDaCkRDrl0gcStm0JVH2jxETWLpDmdfub2s/vSETiUiAlldxBm5IzYGMaqoqpLVlCfUURLtzsd2iyTozUrDwy+wwmq99QgqnpfgckkvCUlMhaubQBhPJ2JFg5VYmJdCyQTih/J0jJ8zsSkbhngQAZ+QPIyB+AC4dprCmjsbqMxtpKmuurCTU1qJpXvLAAwZR0gumZpGXlkZpdQHpOX4Jpaick0pWUlEhsUvsQyt/VS0xCqnIgbQSzI71s5fgdiUjCsUCA9Nx+pOeu+YTROQfO+RCVAGCGmfkdhUivoKREYpeS6yUmVV9DU5nf0UiccGn9COdsC0HdNRTpamYGuigWkV5Afb7KuglmEsrbEZehbg4FXMZwwrk7KCERERGRDaInJbLuAqmEc7bGUvIIVH/vdzTiBzPC2VvhMobpLq6IiIhsMCUlsn4sgMscSSilgGDVNxCq8Tsi6SkpuYRyt1WDdhEREekyqr4lGya1gFDBbrjMERoBPtlZAJe5MaH8XZWQiIiISJfSkxLZcIFUwjlbQfoQgjUz1Qg+CbnUvoRztlQyIiIiIt1CSYl0ndQ+hArGYw3LCdTOhuYqvyOSDZWSTzhrFC59oN+RiIiISBJTUiJdzqUPIpQ+CGssxuoXY40rwWm04oRhKbj0gYQzhkFqX7+jERERkV5ASYl0G5dWiEsrBBfyEpSmUghVYqFaCDeAC/sdolgAAum4YDak5OFS++JS+4EF/Y5MREREehElJdL9LIhLH7hmFSCNUuw/decrIiIicUBJifhHF8QiIiIigroEFhERERERnykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERXykpERERERERX5lzzu8YuoWZFQELfA6jECj2OQaJfzpOJFY6ViQWOk4kVjpWJBajnXO53b2RlO7egF+cc/39jsHMpjrndvQ7DolvOk4kVjpWJBY6TiRWOlYkFmY2tSe2o+pbIiIiIiLiKyUlIiIiIiLiKyUl3esBvwOQhKDjRGKlY0VioeNEYqVjRWLRI8dJ0jZ0FxERERGRxKAnJSIiIiIi4islJV3MzLY0s3fNrNbMlprZdWYW9Dsu6Rlm9ksze9nMlphZtZl9aWYndLL8383Mmdnt7cz7uZlNN7MGM/vJzP7YvdGLX8xsaOR4cWaWEzW9wMweMrPSyPzXzWxUm/d+EHlfez/je35vpCut6/e7ljIlxcwuNbPZkXJlsZn9rWf2RLpbLOeMGMuU0zs43s7rub2RrmJmo8zsfjP7xsxCZvZBm/mDzey2yPxqM1tkZo+a2ZBO1tnROSvNzJ4xs3lmVmdmRZFjbIdYYk3aLoH9YGZ9gHeA74EjgU2BO/CSvyt9DE16zh+Bn4A/4PX9fgjwpJkVOufuil7QzLYEzgQq267EzHYHngceAi4EdgFuMbOwc+7v3boH4ofbgGogu830p4Gtgd8DFXjlyLtmto1zruW4+TWQ1+Z91wHjgC+6LWLpKTF/v52VKREPA/sC1wIzgWHAll0ZrPhjHc4ZsZQpLfYB6qJez+um8KV7bYV3LfIZkNbO/B2Ao4B/A58DA4FrgE/MbGvnXHU77+nonBUEHHATMBev7PoD8J6ZjXPOdX4MOef000U/wGVAGZAXNe1ioDZ6mn6S9wcobGfak8BP7Ux/B/gLMB+4vc28N4HJbab9FSgF0vzeT/106TGzZ+R7vTBSmOdEpo+PvN4natmBkfLkwk7WlxZZ371+75t+uuV46fD7XUuZchDQBGzp9z7op1uOi7WeM2ItU4DTo8si/ST2DxCI+vtZ4IM28wuAlDbTNo8cA6e1s752z1mdbD8HaAD+uLZYVX2rax0MvOlWv9vwFJAJ7OVPSNKTnHPtjYw7DRgQPcHMjgG2AG7uYFXb4V1gRHsL6IN3YpEkEKnaeRfene+2x852QDMwqWWCc24FMB04tJPVHoR3nPy3K2OVuNHu9xtDmXIm8J5z7vvuDU98sh1rP2dsx/qVKZLAnHPhtcwvd841t5n2I16y2vbapbNzVkdqgHraf0qzGiUlXWsM3iPxVs65hXhf7BhfIpJ4sBtelT4AzCwTr1rfpc65mg7ekwE0tpnWEPm9RZdHKH45D++7vrudeRlAs3Mu1GZ6A50fA8cDS4APuyRCiTdrfL8xlim7AD+a2T/NrDLS7vH5zuqNS0KJ5ZyxrmXKXDNrNrNZZnZu14Uq8c7MxgJZRF27RHR2zop+v0XasA0CbgVCxHCjTElJ1+oDlLczvSwyT3oZM9sXr31R9D/wZcAy4IlO3joH2KnNtJ0jv/t2WYDiGzPrh1fV5o/OuaZ2FpkDZJjZNlHvycSrD97uMWBmWcDhwNMu8txckkcn328sZcogvGo52+ElNmfg1SV/wcysO+KVHhXLOSPWMmUZcBVwCt7x9jlwn5n9oRviljhjZgHgH8BsvKdtLdPXds6KdgleddFlwGnAIc65BWvbthq6d732LgSsg+mSxMxsJF57kpecc49Epm2MVw9zn7VcNN4H3Gtm5+DVAd0Z+FNkXtu7XJKYbgA+d8691sH8N/E6TbjfzM7Aa7x8M5CPV9i353C8+ruqupWc1vh+16FMscjPkc65ksh7l+FV5dkHeLe7gpYeEcs5I6YyxTn3ZmTZFq+bWTpwpZn9Y23VgSTh3YRX5W+vNsnH2s5Z0R7Bq044GK+zjlfM7Gdrqz6qJyVdqwyvwVBb+bT/BEWSlJn1BV4HFgInR826OTJ9ZqRrxgK8/8P0yOuWO5YPETnJ4DUoex6vDifAiu7fA+lOZrYVXh3/a6OOg6zI7Hwzy3TONeLd0R6IVy10KbAJ8BgdHwPHA3Occ1O7M37xTXvfb6xlShnwbUtCEvERXpUf9cCV+NZ6zljPMqXFs3hPU0Z2cdwSR8zs18BFeA3cP4+avtZzVvR6nHPLnXNTnXMT8W6mlACXrm37Skq61kzatB0xs2F4XabNbPcdknQiVSxewWvUdWibOt6jgaPxLhBafoYBF0T+HgrgnAs55y4A+gNj8U4in0XW8RmS6DYDUoFPWXUctFTxW4zXkBDn3BRgFF65Mso5tydew8M1jgEzy8frbENPSZJQJ99vTGUK8ENHqwZ05zvBxXrOWJcypaNNdVnQElfM7Bd4556LnXNPt5kd0zmrPZFG9N/iJcCdUvWtrvU6cJGZ5TrnqiLTjsPr53tSx2+TZGFmKcD/8P6Bd3fOrWyzyNl41S+iPYV3fNwLFEXPcM61/PO33MH4xDmnBDfxfQTs3WbaQXj1cA8hajyASJWcWQBmthmwH96dp7aOAtJRUpKsOvp+Yy1TXsG7y1kY1Uvgz/AuNL7ploilx8VyzliHMiXaL/B6W1pruwBJPGY2AfgP8E/n3BoDr7IO56x21p0BbA98vLY4lJR0rfuA3wHPm9kteFnhNcBf3ZqDEklyugfvH/T3QF8z2zVq3rT2qtWYWT2wyDn3QdS0XYE9gK/xBh86ATgwMk0SXOSi8IPoaZE2SAAfushgVWZ2Fd5T1mJgG7zGp085595uZ7XHA9845zq6Iy6Jrd3vN9YyBXgA7/w00cxuBHKBW4B3nHMfdVvU0iNiPWfEUqaY2XPAFLyugoN4N1ePA36n9iSJJ1J745DIy6FAXqQLcYDXgBHAi3jHxdNtrluKnHNz1+GcdQLeE9038KoHtrQpGYw3bk6nlJR0IedcWaS3pX8CE/HakfwNLzGR3uGAyO9/tDNvY7xBzWLRhHcSuAavasWHeE9evt3A+CSx9AP+DhQCi4Db8bp+XY2ZFeKN1H1VTwYnPaMrvl/nXKWZ7QPcifckpRF4CW+0ZUl8sZ4zYilTZuG1HxiGV73ve+BU59zj3RS7dK8BeDU4orW83hivu/B8YFvWfJrxKF6vfbGahdeO9q94vc4uw+u9bUfn3Iy1vdnUa6SIiIiIiPhJDd1FRERERMRXSkpERERERMRXSkpERERERMRXSkpERERERMRXSkpERERERMRXSkpERERERMRXSkpERNaBmZ1uZl+aWZWZlZnZNDNb66BQ67iNnc3smq5cZzwzs2vMrHjtS651PZtH1lXQZvrpZubMrO3I5z3OzCaa2dVrWeawSLwjI68HRPZrZJvldjSzEjPL776IRUR6hpISEZEYmdllwL+BN4GjgVPxBqA7oos3tTPQ6YWrtGtzvM+toM30V4HxQG1PBxTNzHYB9gbuWse3DsDbr5HREyOjuX+NBkAUkSSgEd1FRGJ3AXC/c+7yqGkTzexavwKStXPOFQFFfscB/A54yTlX2oXrfBi43cyud841d+F6RUR6lJ6UiIjErgBY3naic861/G1mX5jZw22XMbNHzeyryN+pZna7mS00swYzW2pmL5hZmpmdTuROeqQKjzOzD6LWs7WZvRqpPlZlZv8zs0FR8ydE3rOvmb1kZjVmNtvMDjCzoJndZmbFZrbEzP4Yy06b2Tlm9q2Z1ZvZCjN71szyzexQMwub2cZtlt84Mv2IqGlHmdkUM6uLVDl6zcxGdLLNvmZ2f2R79Wb2SeRJQ0fLTwAmRl7+FPkM5kfmrVZ9y8xGRl4fb2YPm1mlmS02s5Mj8y+OfCdFZnaLmQXabKvT76CD+HKBo4Bn20y3SNWslZF1PQbkRc0fCXwbefl+yzERtYqXgb7AgZ1tX0Qk3ikpERGJ3VfAb83sNDPr18Ey/wZ+Gd1+IfL3L/DuagNcBpwEXAXsD/wfUAEE8aoa3RFZbnzk59eR9YwCPgYygFOA04Gt8J7WWJs47gc+wrsQXoB3MfxPIBc4MfL6DjPbtbMdNrMrI+uaBPwcOD8Saw7wBrAUOK3N207HezLxWmQdpwDPA3OBY4EzgB+B/h1sMx14J/LZXBTZbhHwTicX/18BF0b+Phrvczuqs30DbgGW4X03HwKPmtkdeNXnzgT+DlwcibkltnX5DqLtBmQCn7SZ/jvgz8ADwDFAHXBr1PxleMcKwG9YdUwA4JyrBGYA+61lX0VE4ptzTj/60Y9+9BPDDzAWmAc4IIx3MXgdkBe1TB5QA5wRNe1MoAHoF3n9CnBHJ9u5gMgDmDbTHwdmAWlR0zYDQsChkdcTIvFdHbXMlpFp70VNC+A99bmlkzgK8Nph/LWTZa4HfgIs8tqA+cDtUdtZAjzfyTquAYqjXp8FNAKbRU1LwUtqbutkPYdF9nNkm+mnR6bnRF6PjLx+uM331gTMBoJR06cAT6/Ld9BBbJcDRW2mBfGSunvbTH87ej+ArSOvJ3Sw7keAj/3+/9CPfvSjnw350ZMSEZEYOeemA1vgNWy/B+8C/CpgasuTEefduX4W70K4xenAy865ksjrr4HTI9WExq7lDnu0/YAXgLCZpZhZCl5CMB/Ysc2y70b9PSfy+72ofQnjJVhDO9neeLy7+2tUR4vyEDACLxkCryH3iKj3jAaGrGUdbe0HfIlXDatlP8F7WtN2PzdE62cU+d6KgEnOuVDUMnNY/TNal+8g2iCgbQ9jw4DBeJ0lRHt+HfaByHo7rT4mIhLvlJSIiKwD51yDc26ic+4C59yWwNl4d8rPilrsQWBPM9vUzDYF9sS7eG9xPXA3XrWsb4BFZvb7GDZfCFyCd0c/+mcTvAvcaOVRMTe2nRbRiFcNqSMtVdSWdbSAc24e8AFelSwiv6c452bEuo52FAK7suZ+nsGa+7khytu8buxgWvRntC7fQbQMvKdl0VoSiZVtprd9vTYNdP49iojEPfW+JSKyAZxzD5rZrcCYqGmTzWw2XlsLw6ui81bU/Hq8dgR/NrPNgPOAv5vZLOfcG51srhTvLv2/25m3weN8tKPlyc7gtaz/38C/zOsy+WjgTx2sI1alwFS89itttb2w72nr+x2UsmZXxS2dJgxoM73t67UpiKxfRCRhKSkREYmRmQ1wzq1sM60/kA+saLP4Q0QaqAOPtakS1Mo5N9vMLsRrxLwlXuPxxsi6MyIJTIt38doXfOmcc2usrOt9itfw+jRWNSJvz/N4T36ewnsC/1TUvFl4bUpOY1XvWGvzLnAAsLDt570WLU+EuvOpwfp+B7OAIWaW7pxrSawW4SUmR+J97y2ObvPete3XSLyOA0REEpaSEhGR2H1rZi/hPfVYidd24kK8xuCPtln2UbxqWil4DZFbmdkLeG0mpuFd9B8TWW5yZJGZkd+/N7P3gErn3Cy8BuFTgFfN7CG8O/ND8XqpesQ590EX7ScAzrlyM/sLcIOZpeH1ppUOHApc65xbElmu3sz+g5dY/dc5Vx61jrCZXQz8J7LMf/Eabe8TWXZqO5t+DO/p0Qdmdjte25d+eL1iLXfO/a2DkGdFfp9rZk8Btc65bztYdn1dw/p9Bx8DqcA2eE+BcM6FIk/ZbjdvRPsP8XoC26LNexcSSQ7NrAJoavO57YjXk5iISMJSmxIRkdhdh3dX+k68xOQveD1w7eyc+yl6QefccuBzvF6RZrVZzyd43dw+idfIeQfgF1EXmh8CtwG/j6zj/sg6f8Rra1GL14Xs68C1eFWa5tANnHM34VWj2i8S6/141YWq2iz6YuT3Q22m45x7Eu9iewxeJwCPRf5ud0DDyNOhvfF6oboW77P+B17bnSmdxLoAL0k8Gi8JiPXJTMzW9zuIvO874OA2s/4O3IiXhD2H19XyxW3eWw+cg3ecTAK+aJlnZuPwulZe18bxIiJxxXqmBoCISO9iZn3xqi1d4Jx70O94ulvkjv9xwMaRnr2kDTP7A3CWc27rLlznTcBOzjmNUyIiCU1PSkREupCZ5UZGHv8n3tOE//ocUrcys9FmdhTe05S7lJB06gGgv5l1SQJhZtl4T1Cu74r1iYj4SW1KRES61g7A+3ijqJ/qnKv1OZ7udj+wC/AyXrU26YBzrsbMTgOyu2iVw4HrurotkYiIH1R9S0REREREfKXqWyIiIiIi4islJSIiIiIi4islJSIiIiIi4islJSIiIiIi4islJSIiIiIi4islJSIiIiIi4qv/B8PklY54q01KAAAAAElFTkSuQmCC\n", 691 | "text/plain": [ 692 | "
" 693 | ] 694 | }, 695 | "execution_count": 17, 696 | "metadata": {}, 697 | "output_type": "execute_result" 698 | } 699 | ], 700 | "source": [ 701 | "# Equivalent circuit in terms of cross-resonance gates (https://qiskit.org/textbook/ch-quantum-hardware/cQED-JC-SW.html#6.-The-Cross-Resonance-Entangling-Gate)\n", 702 | "qrs_pe = QuantumRegister(4)\n", 703 | "qc_pe = QuantumCircuit(qrs_pe)\n", 704 | "qc_pe.rzx(theta/2, 1, 3)\n", 705 | "qc_pe.x(1)\n", 706 | "qc_pe.rzx(-theta/2, 1, 3)\n", 707 | "qc_pe.x(1)\n", 708 | "\n", 709 | "# Add the pulse-level calibrations\n", 710 | "pm = PassManager([RZXCalibrationBuilderNoEcho(backend)])\n", 711 | "qc_pulse_efficient = pm.run(qc_pe)\n", 712 | "\n", 713 | "schedule(qc_pulse_efficient, backend).draw() # show pulse schedule" 714 | ] 715 | }, 716 | { 717 | "cell_type": "code", 718 | "execution_count": 18, 719 | "id": "93da1619-2bac-45df-8724-ca33e6616cf1", 720 | "metadata": {}, 721 | "outputs": [ 722 | { 723 | "name": "stdout", 724 | "output_type": "stream", 725 | "text": [ 726 | "Duration of standard CNOT-based circuit:\n", 727 | "3776\n", 728 | "Duration of pulse-efficient circuit:\n", 729 | "1184\n" 730 | ] 731 | } 732 | ], 733 | "source": [ 734 | "# Compare the schedule durations\n", 735 | "print('Duration of standard CNOT-based circuit:')\n", 736 | "print(schedule(qct, backend).duration)\n", 737 | "print('Duration of pulse-efficient circuit:')\n", 738 | "print(schedule(qc_pulse_efficient, backend).duration)" 739 | ] 740 | }, 741 | { 742 | "cell_type": "markdown", 743 | "id": "1b9966af-636f-4a75-8e13-60a053e4c525", 744 | "metadata": {}, 745 | "source": [ 746 | "You've just optimized an $R_{ZX}$ gate using pulse-level control! The shorter circuit time for the pulse-efficient circuit is great news! The shorter the circuit, the less likely the qubit will decohere. This time savings, and fewer pulses to the qubits, will reduce errors. Let's quantify this reduction by measuring the [process fidelity](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) of the two circuits. If we wanted to be thorough, we should do a [randomized benchmarking](https://qiskit.org/textbook/ch-quantum-hardware/randomized-benchmarking.html) as shown in Fig. 1 of paper [\\[3\\]](https://arxiv.org/pdf/2105.01063.pdf)." 747 | ] 748 | }, 749 | { 750 | "cell_type": "code", 751 | "execution_count": 19, 752 | "id": "1122b4a4-aba3-45cf-aa4c-3c8358c3e987", 753 | "metadata": {}, 754 | "outputs": [], 755 | "source": [ 756 | "# Process tomography functions\n", 757 | "from qiskit.ignis.verification.tomography import process_tomography_circuits, ProcessTomographyFitter\n", 758 | "\n", 759 | "# Get exact gate for comparison in process tomography\n", 760 | "from qiskit.circuit.library import RZXGate\n", 761 | "\n", 762 | "# Get the ideal unitary operator to compare to circuit output\n", 763 | "target_unitary = qi.Operator(RZXGate(theta).to_matrix())\n", 764 | "\n", 765 | "# Generate process tomography circuits and run\n", 766 | "qpt_qcs = process_tomography_circuits(qc, [qrs[1], qrs[3]])\n", 767 | "job = execute(qpt_qcs, backend, shots=8192)" 768 | ] 769 | }, 770 | { 771 | "cell_type": "code", 772 | "execution_count": 20, 773 | "id": "ff05476f-831f-4feb-8e20-82436c74074b", 774 | "metadata": {}, 775 | "outputs": [ 776 | { 777 | "name": "stdout", 778 | "output_type": "stream", 779 | "text": [ 780 | "Job Status: job has successfully run\n" 781 | ] 782 | } 783 | ], 784 | "source": [ 785 | "job_monitor(job)" 786 | ] 787 | }, 788 | { 789 | "cell_type": "code", 790 | "execution_count": 21, 791 | "id": "11371910-5166-4470-87f0-a94bb00e6ff9", 792 | "metadata": {}, 793 | "outputs": [ 794 | { 795 | "name": "stdout", 796 | "output_type": "stream", 797 | "text": [ 798 | "Average gate fidelity: F = 0.91322\n" 799 | ] 800 | } 801 | ], 802 | "source": [ 803 | "# Extract tomography data\n", 804 | "qpt_tomo = ProcessTomographyFitter(job.result(), qpt_qcs)\n", 805 | "\n", 806 | "# Tomographic reconstruction\n", 807 | "choi_fit_lstsq = qpt_tomo.fit(method='lstsq')\n", 808 | "print('Average gate fidelity: F = {:.5f}'.format(qi.average_gate_fidelity(choi_fit_lstsq, target=target_unitary)))" 809 | ] 810 | }, 811 | { 812 | "cell_type": "markdown", 813 | "id": "4a738714-545b-4ebe-b381-2fcc610e4f7f", 814 | "metadata": {}, 815 | "source": [ 816 | "Now for the pulse-efficient gate" 817 | ] 818 | }, 819 | { 820 | "cell_type": "code", 821 | "execution_count": 22, 822 | "id": "ec7d0533-fbf3-468e-bd43-469a477e4a4b", 823 | "metadata": {}, 824 | "outputs": [], 825 | "source": [ 826 | "# Generate process tomography circuits and run\n", 827 | "qpt_qcs = process_tomography_circuits(qc_pulse_efficient, [qrs_pe[1], qrs_pe[3]])\n", 828 | "job = execute(qpt_qcs, backend, shots=8192)" 829 | ] 830 | }, 831 | { 832 | "cell_type": "code", 833 | "execution_count": 23, 834 | "id": "e3274b60-f0c2-4a42-96d7-664c3cd4af26", 835 | "metadata": {}, 836 | "outputs": [ 837 | { 838 | "name": "stdout", 839 | "output_type": "stream", 840 | "text": [ 841 | "Job Status: job has successfully run\n" 842 | ] 843 | } 844 | ], 845 | "source": [ 846 | "job_monitor(job)" 847 | ] 848 | }, 849 | { 850 | "cell_type": "code", 851 | "execution_count": 24, 852 | "id": "97fca98c-f492-4643-95da-42d9f24678f9", 853 | "metadata": {}, 854 | "outputs": [ 855 | { 856 | "name": "stdout", 857 | "output_type": "stream", 858 | "text": [ 859 | "Average gate fidelity: F = 0.92471\n" 860 | ] 861 | } 862 | ], 863 | "source": [ 864 | "# Extract tomography data so that counts are indexed by measurement configuration\n", 865 | "qpt_tomo = ProcessTomographyFitter(job.result(), qpt_qcs)\n", 866 | "\n", 867 | "# Tomographic reconstruction\n", 868 | "choi_fit_lstsq = qpt_tomo.fit(method='lstsq')\n", 869 | "print('Average gate fidelity: F = {:.5f}'.format(qi.average_gate_fidelity(choi_fit_lstsq, target=target_unitary)))" 870 | ] 871 | }, 872 | { 873 | "cell_type": "markdown", 874 | "id": "8f387262-d130-4c2c-91af-bdcf8ff9019e", 875 | "metadata": {}, 876 | "source": [ 877 | "This is just one example of how Pulse could be used. Read [tutorials](https://qiskit.org/documentation/tutorials/circuits_advanced/05_pulse_gates.html), papers, and the [Qiskit youtube channel](https://www.youtube.com/c/qiskit) for more ideas." 878 | ] 879 | }, 880 | { 881 | "cell_type": "code", 882 | "execution_count": 27, 883 | "id": "3442d831-379c-420d-8aa5-3d300220d796", 884 | "metadata": {}, 885 | "outputs": [ 886 | { 887 | "data": { 888 | "text/html": [ 889 | "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.18.3
qiskit-aer0.9.1
qiskit-ignis0.6.0
qiskit-ibmq-provider0.18.0
qiskit-aqua0.9.5
qiskit0.32.0
qiskit-nature0.1.3
System information
Python3.8.8 (default, Apr 13 2021, 12:59:45) \n", 890 | "[Clang 10.0.0 ]
OSDarwin
CPUs8
Memory (Gb)64.0
Mon Nov 29 09:01:00 2021 EST
" 891 | ], 892 | "text/plain": [ 893 | "" 894 | ] 895 | }, 896 | "metadata": {}, 897 | "output_type": "display_data" 898 | } 899 | ], 900 | "source": [ 901 | "import qiskit.tools.jupyter\n", 902 | "%qiskit_version_table" 903 | ] 904 | } 905 | ], 906 | "metadata": { 907 | "kernelspec": { 908 | "display_name": "Python 3", 909 | "language": "python", 910 | "name": "python3" 911 | }, 912 | "language_info": { 913 | "codemirror_mode": { 914 | "name": "ipython", 915 | "version": 3 916 | }, 917 | "file_extension": ".py", 918 | "mimetype": "text/x-python", 919 | "name": "python", 920 | "nbconvert_exporter": "python", 921 | "pygments_lexer": "ipython3", 922 | "version": "3.8.8" 923 | } 924 | }, 925 | "nbformat": 4, 926 | "nbformat_minor": 5 927 | } 928 | -------------------------------------------------------------------------------- /qiskit-default-winning-submission.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qiskit-community/open-science-prize-2021/f66f6c0c0dc6e7404ee229774013a852e97eb65e/qiskit-default-winning-submission.zip -------------------------------------------------------------------------------- /qiskit-pulse-winning-submission.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qiskit-community/open-science-prize-2021/f66f6c0c0dc6e7404ee229774013a852e97eb65e/qiskit-pulse-winning-submission.zip --------------------------------------------------------------------------------