├── .DS_Store ├── Chapter03 ├── .DS_Store └── Chapter 3 - Quantum Labs notebook.ipynb ├── Chapter04 ├── .DS_Store └── Chapter 4 - Understanding Quantum Computation Basics.ipynb ├── Chapter05 ├── .DS_Store └── Chapter 5 - Understanding Qubits.ipynb ├── Chapter06 ├── .DS_Store └── Chapter 6 - Understanding Qubit Gates.ipynb ├── Chapter07 ├── .DS_Store └── Chapter 7 - Introduction to Qiskit.ipynb ├── Chapter08 └── Chapter 8 - Terra.ipynb ├── Chapter09 └── Chapter 9 - Monitoring and Optimizing quantum circuits.ipynb ├── Chapter10 └── Chapter 10 - Aer.ipynb ├── Chapter11 └── Chapter 11 - Ignis.ipynb ├── Chapter12 └── Chapter 12 - Aqua.ipynb ├── Chapter13 └── Chapter 13 - Quantum Algorithms.ipynb ├── Chapter14 └── Chapter 14 - Applying Quantum Algorithms.ipynb ├── LICENSE └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/.DS_Store -------------------------------------------------------------------------------- /Chapter03/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/Chapter03/.DS_Store -------------------------------------------------------------------------------- /Chapter03/Chapter 3 - Quantum Labs notebook.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 286, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "/opt/conda/lib/python3.7/site-packages/qiskit/providers/ibmq/ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n", 13 | " warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n", 14 | "ibmqfactory.load_account:WARNING:2020-09-11 01:13:31,204: Credentials are already in use. The existing account in the session will be replaced.\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "%matplotlib inline\n", 20 | "# Importing standard Qiskit libraries and configuring account\n", 21 | "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n", 22 | "from qiskit.compiler import transpile, assemble\n", 23 | "from qiskit.tools.jupyter import *\n", 24 | "from qiskit.visualization import *\n", 25 | "# Loading your IBM Q account(s)\n", 26 | "provider = IBMQ.load_account()" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "# Chapter 3 - Quantum Labs notebook" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 287, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "data": { 43 | "text/plain": [ 44 | "" 45 | ] 46 | }, 47 | "execution_count": 287, 48 | "metadata": {}, 49 | "output_type": "execute_result" 50 | } 51 | ], 52 | "source": [ 53 | "qc = QuantumCircuit(2,2)\n", 54 | "qc.h(0)\n", 55 | "qc.cx(0, 1)\n" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 289, 61 | "metadata": {}, 62 | "outputs": [ 63 | { 64 | "data": { 65 | "text/plain": [ 66 | "" 67 | ] 68 | }, 69 | "execution_count": 289, 70 | "metadata": {}, 71 | "output_type": "execute_result" 72 | } 73 | ], 74 | "source": [ 75 | "qc.measure(range(2), range(2))" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 290, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAACoCAYAAABe3gMyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAUCklEQVR4nO3df1RVZb7H8Tc/BQRBBkcR0ELxB4wIQi70miDOmHabO075i8ouXkxT56aTd40zq9FppsmlaWtsbl3TMm1N93oLZagcyy6TYIpZpKSlRpmGmGMimqICAuf+wcCI/DrqOWefBz+vtfbysM/ez/luPHzO8zxnn308bDabDRERg3haXYCIyPVScImIcRRcImIcBZeIGEfBJSLGUXCJiHEUXCJiHAWXiBhHwSUixlFwiYhxFFwiYhwFl4gYR8ElIsZRcImIcRRcImIcBZeIGEfBJSLGUXCJiHEUXCJiHAWXiBhHwSUixlFwiYhxFFwiYhwFl4gYR8ElIsZRcImIcbytLuBWlFMEJ85a89gR3eHeZGse2woLFiyguLjYksdOSEhg1apVljx2Z6fgssCJs3DkW6uruDUUFxdTUFBgdRniYBoqiohxFFwiYhwFl4gYR8ElIsZRcImIcRRcImIcnQ4hco2AgADi4uIICQmhtraWI0eOUFpa2ub2iYmJhIeHs3XrVhdWeWtTcIkAwcHBPPTQQ8yYMYP4+Hi8vLya3V9eXs6WLVt4/vnnKSoqalqfmJhIXl4egYGBjB49mj179ri69FuSgkucqqwCPi2DmloIC4Jht4Gfj9VVNZeZmckf/vAHQkJCAKitrWX//v2cOnWKLl26EBsbS1hYGJmZmWRmZpKbm8sjjzxC7969ycvLIzQ0lNzcXPbu3WvtgdxC3HqOq76+npUrVxITE4Ofnx9Dhw6loKCAgQMHMmvWLKvLc5lNv0/jw9zf273eHVRWwfN5sPJteOcAvHcIXv8QFm+GHZ9bXV2DLl268Prrr7N+/XpCQkIoKCjgvvvuIygoiKFDhzJu3DhSU1Pp0aMHgwYNYsWKFZw/f56JEydy+PBh8vPzm0JrypQpXLlyxepDumW4dXBlZWXx5JNPMnv2bN5++22mTJlCRkYGX331FUlJSVaXJ22oqYX/+it8earlfVfqGj6ruavE9XVdzdvbm+zsbCZPnsy5c+d48MEHSUtLIycnh6qqqhbbf/755/ziF78gLi6OwsJCQkJC6NatGzt27FBoWcBth4obN25kw4YN5Ofnk5qaCsCYMWPYu3cvOTk5DBs2zOIKpS17j8E359rfZssnMLwf+Hi1v52zLFq0iB//+MeUl5eTnp7OgQMH7NqvsffVKDo6moCAAL777jtnlSqtcNse19KlSxk/fnxTaDXq378/Pj4+xMfHA3Ds2DFSU1MZMGAAQ4YM4f3337eiXLnK7iPg0cE2l2vgszKXlNNCbGwsS5YsAWDq1Kl2h1bjRHxoaChvvPEGH3zwAZGRkaxYscKZ5Uor3DK4ysrK+PTTT5k8eXKL+0pLS4mLi6NLly4AzJ49m6lTp1JSUsKaNWuYNm0aNTU1DqnDw8PDKUtBQf511/LhG0+xelZIs+Wbkp3X3U5BQb7Tjqtx+eyLE9jsqOXf5ix0ei2tXRli4cKF+Pr68uKLL/Lee+/Z9Xu7OrRyc3OZPHkymZmZ1NbWMmPGDMLDw1v5XRc4/fg622Ivtw0ugF69ejVbf/nyZQoKCpqGieXl5ezcuZOsrCwARo4cSe/evdm+fbtrC3aB4T95nDlrzzVbeg8YZXVZraq59B22+vqOt7vs+uFVSEgIGRkZACxfvtyufa4NrcY5rc8//5w///nPeHt7M3PmTGeWLddwy+AKCwsDoKSk+Qzu008/zcmTJ5sm5ktLS+nZs2dT7wvg9ttv5+uvv3ZIHTabzSlLamqaQ+q7EampaU47rsbl/gmxeHi2/9Ty9IAP3n7J6bVcO9UwYsQI/P392blzJ0eOHOnw99VWaDX605/+BMDYsWNb+V2nOv34OttiL7ecnI+OjiY+Pp6lS5cSGhpKREQEmzZtajozWe8oureR/aHgEFRdoc0h48j+EOjn0rKAfzx3Pvzwww637Si0rm4nMTERDw+P6/rjkxvnlj0uT09PsrOziYuLY86cOcyYMYOwsDDmzZuHl5dX08R8nz59OHXqFNXV1U37Hj16lL59+1pVugDd/GF2Ovj5Nl/fOIMxJAomWvTa07t3b4AOe1v2hBbAqVOnuHDhAt26dSMwMNApNUtLHjaDXiKmT5/OJ598wv79+5vWjRs3jokTJzJ37lwKCwuZNGkSx44dw9fXt52WrPWf/2fdpZv7fR/+/UeueaxL1fDhUcj9uOHnxL4NPa3+PeE65mFvSlpaWrMJeh8fHwICAqiurm71fK1GP/zhD3nrrbd45513OjxPKzQ0lOrqai5evNhsfWpqKvn5+Td9DNKSWw4V21JUVERKSkqzdS+88AKZmZmsWrUKX19fNm7c6NahdSsJ6AJpg/4RXP/qBu8lXLlyxa5zrvLy8hg1ahT79+/v8OTSiooKR5UndjImuCorKykpKWHu3LnN1kdHR7Njxw6LqpLO7OOPP7a6BGmDMcEVGBhIXV2d1WWIiBtwy8l5EZH2KLhExDgKLhExjoJLRIyj4BIR4yi4RMQ4xpwO0ZlEdL81H9sKCQkJ173PV6UnAYjuE97stiseW+xj1Ed+xEwL/rvh31UPWFuHvX65fC0AyxbNanZb3IeGiiJiHAWXiBhHwSUixlFwiYhxFFwiYhwFl4gYR8ElIsZRcImIcRRcImIcBZeIGEfBJSLGUXCJiHEUXCJiHF3WRsTNLFiwgOLiYkseOyEhgVWrVlny2NdDwSXiZoqLi5t9+7a0pKGiiBhHwSUixlFwiVN9d/kft49XwBV9Gbk4gOa4xOFOnIWdJfDZCTh/VXA98zZ4ejRc9354NNwRDX4+1tUp5lJwicNUVsGmj6C4tO1t6m0NPa/jFbD1E/hpMtxxO3h4uK5OMZ+CSxziWDm8VNAQXva6fAX+ZzccPAEPjgRvL+fVJ52L5rjkppWegdV/vb7QulpxKax/H+rqHVuXtC84ONjqEm6YelxyU6quNIROdW3b2zR+LVnj15S15rMT8NfPYNwQx9Z3K0hKSmLChAkkJSVx22234eXlxZkzZyguLmbXrl28+eab1NTUNNsnPT2dzZs38+CDD/KXv/zFospvnIJLbsqWYjh70TFtbTsAQ6IgPMQx7XV2EyZM4IknnmD48OGt3p+WlsaCBQs4ffo0zz//PMuWLaO6upr09HS2bNmCv78/48ePNzK43HqoWF9fz8qVK4mJicHPz4+hQ4dSUFDAwIEDmTVLX9BptQtVsPtLx7VXZ4PthxzXXmfVtWtX1q9fz9atWxk+fDgVFRU899xzPPDAAyQlJTF06FDGjx/Pr3/9a/bt20ePHj144okn2LdvH7Nnz24KrbVr1/Loo49afTg3xK17XFlZWeTk5LB48WKSkpIoLCwkIyOD06dP89hjj1ld3i1vzxHHz0vtPQY/GQZduzi23c4iKCiIbdu2MWLECC5fvsySJUt47rnnqKpqPsG4f/9+tm3bxlNPPcXo0aN54YUXGDx4MKtXr8bDw4O1a9fyyCOPYOoX2bttcG3cuJENGzaQn59PamoqAGPGjGHv3r3k5OQwbNgwiyuUkr85vs3aejh2GuIiHd92Z/Daa68xYsQIjh07xoQJEzh8+HCH++zYsYPHHnuMt956C29vb2pqali5cqWxoQVuPFRcunQp48ePbwqtRv3798fHx4f4+HgAlixZwoABA/D09GTTpk1WlHpLstmgrMI5bZc6qV3TPfzww0yYMIHy8nLS09PtCi1omIjPycnB29ubo0eP4uvry7p16/Aw+eQ5mxs6fvy4DbCtW7euxX3Tpk2zJSQkNP28a9cu25EjR2ypqam27Oxsh9YBaGlj8e4SYJv/qq3ZcqOubWds1lpLj23RsjW2RcvWtLht5RIQEGCrqKiw2Ww225QpU+zeLz093Xbp0iWbzWazrVmzxhYaGmr75ptvbDZbw9+S1cd17WIvt+xxlZWVAdCrV69m6y9fvkxBQUGzYeLIkSOJjo52aX0CHjjx1drknoCT3H///XTv3p3CwkJef/11u/a5+t3DxjmtiooKfvvb3wIwd+5cZ5bsVG45xxUWFgZASUkJd999d9P6p59+mpMnT5KUlOSSOmwGzwE4W70Nfvka1Fz1oem2ztOy5zyuq82fO5O8F2feXIE34ZfL1wIN//9X33aVtLS0FtfjysjIAGD16tV2tdFaaDUew6uvvsqKFSu48847iYiI4MSJE037paamkp+f75gDcSK3DK7o6Gji4+NZunQpoaGhREREsGnTJrZu3QrgsuCStnl6QEQoHD3t+Lajvuf4Nk3m4eHR9JzPy8vrcPv2Qgvg4sWL7N69m3HjxpGcnNwsuEzhlkNFT09PsrOziYuLY86cOcyYMYOwsDDmzZuHl5dX08S8WKvf9x3fpgdwe5jj2zVZREQEwcHBnDp1ir/9rf23cjsKrUaNl4aOi4tzRslO55Y9LoABAwawffv2ZuumT59ObGws/v7+FlUlV0vp1/AxHUcOouIiITjAgQ12ApcuXeI3v/kNlZWV7W4XFBREdnZ2h6EF8M4771BVVcWuXbucUbLTuW1wtaaoqIiUlJRm6xYvXsz69es5ffo0Bw4cYMGCBRQUFNCvXz+Lqrx1hAVBfBR8ctxxbY4Z7Li2OouKigp+97vfdbjdhQsXyMjI4J577mH+/Pntzstt3769RcfAJG45VGxNZWUlJSUlLU48ffLJJykrK6O6upozZ85QVlam0HKhe+8AfwddDHBkjHOGn7eSd999l0cffbTTv7FkTI8rMDCQujpd99fdBPvDAyPh5R0N7zS2xp53EyO7w78kOrY26byM6XGJ+/pBJDw0Crxu8NnU53vwSLou4yz2M6bHJe4toQ/07NZwRdPjdn5kx9MDxsbCXUN09VO5PgoucZjwEFhwF+w/3vBlGUe+bX07P5+GL8oYFQM9g11aonQSCi5xKC9PSOzbsFyqgRMVUF7ZcPkbfx/o3b2hZ+apSQq5CQoucZoAX4jpBTFWFyKdjl73RMQ4Ci4RMY6GiiJuJiEh4Yb2+6r0JADRfcKb3XbFY7uagkvEzaxateqG9mu8BM+yRbOa3e6MNFQUEeMouETEOAouETGOgktEjKPgEhHjKLhExDgKLhExjoJLRIyj4BIR4yi4RMQ4Ci4RMY6CS0SMo+ASEeMouETEOAouETGOgssFjh8/ztixYxk8eDBxcXH86le/srokcaL8/Hzi4uLo378/M2fONOKLjOfPn09kZCTe3mZcok/B5QLe3t4sX76cQ4cOsW/fPnbu3Mkbb7xhdVniBPX19cycOZPs7Gy+/PJLzp8/z6uvvmp1WR2aPHkyRUVFVpdhNwWXC4SHh5OcnAyAr68viYmJlJaWWlyVOMNHH31E7969iY2NBSArK4vNmzdbXFXHRo0aRa9evawuw25m9As7kYqKCnJzc3n33XetLkX+rra2jpez3+ZyVXWz9c+u39zq7TEpCcQP7tdqW2VlZURFRTX93KdPH44fP+7gihvsKT7IB/sOtVjfWt0h3boy/d678PTwcEotrqYelwvV1NQwadIk5s+fz6BBg6wuR/7O29uLuJjbOPntGU5+e6Zp/bW3T357hurqGgbH9G2zLZvN5tRarxY/qB/nL1y0q+6Ewf07TWiBgstl6urquP/++0lISGDhwoVWlyPXSEmMpUdoSIfb3T0mBZ92JrCjoqKa9bBKS0uJjIx0RIkt+Pt14Ud3Jne4Xd+Inm32EE2l4HKRWbNmERQUxDPPPGN1KdIKLy9P7klPaXeb26PCiRtwW7vbJCcnU1ZWxsGDBwFYt24d9957r6PKbOGOoYPo1SO03W3uGTsCj07U2wIFl0vs2rWLl19+maKiIhITE0lISOCPf/wj4NqhhbRvYL8+DLg9qtX7PLAvALy8vHjppZeYNGkS/fr1IzAwkOnTpzuh2r8/nqcn96SPaPP+YT+IISr8+x22M3v2bCIjI6mrqyMyMpJ58+Y5skyH87DpL8dSb+YVUldXx8Rxozrdq6KJTpWf5dmXN1F/zZ9FcvxAJk1Itaiqjr2yeRuHvvy62TofH2/+4+GpBAd1tagq51GPy0Lnzleyp7hhSKHQcg89w7qTMiy22bouvj7cNfoOiyqyzz+PScHLs/mfc1pKQqcMLegEwXXgwAHuu+8+wsLC8PPzIyYmhscff9zqsuyS/0Ex2BqeYOI+xv5TEv5+XZp+HjMikaCuARZW1LGw0GBGJMU1/Rwc1JXRd8RbWJFzGT1U/Pjjjxk9ejRRUVEsWrSIvn37cvToUQoLC1m3bt1Nt9/4NeYi4hrLFs2yazujT0BduHAhXbt2Zc+ePQQHBzetz8rKsrAqEXE2Y3tcly5dIigoiJ/97Gc8++yzVpdzXc6dr2TF2v8lechAfnrXnVaXI234tvwsPb4XYtT8Y119PRXnztt1TprJjO1xnT17lvr6eqed3AfOHyruKT7EnuKWH9kQuVXZO1Q0dnK+e/fueHp6cuLECatLEREXM3aoCDBmzBgOHjzIF198Qbdu3awuxy657+7ko08O8x+zptI9OMjqckSMZGyPC2DlypVUVlaSkpLChg0b2L59O6+88gozZ860urRWnTtfyUf7D5McP1ChJXITjJ3jAkhKSmL37t0sXryYn//851RVVREVFcW0adOsLq1VZ86dJ6hrgM7bErlJRg8VTVRfX4+np9EdXRHLKbhExDh66RcR4yi4RMQ4Ci4RMY6CS0SMo+ASEeMouETEOAouETGOgktEjKPgEhHjKLhExDgKLhExjoJLRIyj4BIR4yi4RMQ4Ci4RMY6CS0SMo+ASEeMouETEOAouETGOgktEjKPgEhHjKLhExDgKLhExjoJLRIyj4BIR4yi4RMQ4Ci4RMc7/A6Kc/1aRhW/tAAAAAElFTkSuQmCC\n", 86 | "text/plain": [ 87 | "
" 88 | ] 89 | }, 90 | "execution_count": 290, 91 | "metadata": {}, 92 | "output_type": "execute_result" 93 | } 94 | ], 95 | "source": [ 96 | "qc.draw()" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 291, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "backend = Aer.get_backend('qasm_simulator')" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 292, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "job_simulator = execute(qc, backend, shots=1024)" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 293, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "result_simulator = job_simulator.result()" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 294, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "{'00': 491, '11': 533}\n" 136 | ] 137 | } 138 | ], 139 | "source": [ 140 | "counts = result_simulator.get_counts(qc)\n", 141 | "print(counts)\n" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 295, 147 | "metadata": {}, 148 | "outputs": [ 149 | { 150 | "data": { 151 | "image/png": "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\n", 152 | "text/plain": [ 153 | "
" 154 | ] 155 | }, 156 | "execution_count": 295, 157 | "metadata": {}, 158 | "output_type": "execute_result" 159 | } 160 | ], 161 | "source": [ 162 | "from qiskit.visualization import plot_histogram\n", 163 | "plot_histogram(counts)\n" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "# Executing a circuit on a quantum computer" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 296, 176 | "metadata": {}, 177 | "outputs": [ 178 | { 179 | "data": { 180 | "text/plain": [ 181 | "[,\n", 182 | " ,\n", 183 | " ,\n", 184 | " ,\n", 185 | " ,\n", 186 | " ,\n", 187 | " ,\n", 188 | " ,\n", 189 | " ,\n", 190 | " ,\n", 191 | " ]" 192 | ] 193 | }, 194 | "execution_count": 296, 195 | "metadata": {}, 196 | "output_type": "execute_result" 197 | } 198 | ], 199 | "source": [ 200 | "provider.backends()" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 297, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [ 209 | "backend = provider.get_backend('ibmq_vigo')" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 299, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "name": "stdout", 219 | "output_type": "stream", 220 | "text": [ 221 | "{'00': 493, '01': 15, '10': 14, '11': 502}\n" 222 | ] 223 | }, 224 | { 225 | "data": { 226 | "image/png": "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\n", 227 | "text/plain": [ 228 | "
" 229 | ] 230 | }, 231 | "execution_count": 299, 232 | "metadata": {}, 233 | "output_type": "execute_result" 234 | } 235 | ], 236 | "source": [ 237 | "# Repeating steps 2-5 from above:\n", 238 | "job_simulator = execute(qc, backend, shots=1024)\n", 239 | "result_simulator = job_simulator.result()\n", 240 | "counts = result_simulator.get_counts(qc)\n", 241 | "print(counts)\n", 242 | "plot_histogram(counts)" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": {}, 249 | "outputs": [], 250 | "source": [] 251 | } 252 | ], 253 | "metadata": { 254 | "kernelspec": { 255 | "display_name": "Python 3", 256 | "language": "python", 257 | "name": "python3" 258 | }, 259 | "language_info": { 260 | "codemirror_mode": { 261 | "name": "ipython", 262 | "version": 3 263 | }, 264 | "file_extension": ".py", 265 | "mimetype": "text/x-python", 266 | "name": "python", 267 | "nbconvert_exporter": "python", 268 | "pygments_lexer": "ipython3", 269 | "version": "3.7.8" 270 | } 271 | }, 272 | "nbformat": 4, 273 | "nbformat_minor": 4 274 | } 275 | -------------------------------------------------------------------------------- /Chapter04/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/Chapter04/.DS_Store -------------------------------------------------------------------------------- /Chapter05/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/Chapter05/.DS_Store -------------------------------------------------------------------------------- /Chapter06/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/Chapter06/.DS_Store -------------------------------------------------------------------------------- /Chapter07/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Learn-Quantum-Computing-with-Python-and-IBM-Quantum-Experience/5c39c64032ac2735439ea4825c60d4ec5bbb62bd/Chapter07/.DS_Store -------------------------------------------------------------------------------- /Chapter07/Chapter 7 - Introduction to Qiskit.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 169, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "/opt/conda/lib/python3.7/site-packages/qiskit/providers/ibmq/ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n", 13 | " warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n", 14 | "ibmqfactory.load_account:WARNING:2020-09-11 00:34:47,918: Credentials are already in use. The existing account in the session will be replaced.\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "%matplotlib inline\n", 20 | "# Importing standard Qiskit libraries and configuring account\n", 21 | "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n", 22 | "from qiskit.compiler import transpile, assemble\n", 23 | "from qiskit.tools.jupyter import *\n", 24 | "from qiskit.visualization import *\n", 25 | "# Loading your IBM Q account(s)\n", 26 | "provider = IBMQ.load_account()" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "# Chapter 7 - Introduction to Qiskit" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 171, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "from qiskit import QuantumCircuit, QuantumRegister\n", 43 | "from qiskit import Aer, execute\n", 44 | "from qiskit.providers.aer import QasmSimulator, StatevectorSimulator\n" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 172, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "name": "stdout", 54 | "output_type": "stream", 55 | "text": [ 56 | "[[ 0.70710678+0.00000000e+00j 0.70710678-8.65956056e-17j]\n", 57 | " [ 0.70710678+0.00000000e+00j -0.70710678+8.65956056e-17j]]\n" 58 | ] 59 | } 60 | ], 61 | "source": [ 62 | "# Create a quantum circuit with 1 qubit, add an H gate\n", 63 | "qc = QuantumCircuit(1)\n", 64 | "qc.h(0)\n", 65 | "# Set backend to unitary simulator\n", 66 | "simulator = Aer.get_backend('unitary_simulator')\n", 67 | "# Execute on unitary simulator\n", 68 | "result = execute(qc, simulator).result()\n", 69 | "# Obtain results and print it out on console\n", 70 | "unitaryState = result.get_unitary(qc)\n", 71 | "print(unitaryState)\n" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "# Setup IBMQ Account info on local machine " 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "from qiskit import IBMQ\n", 88 | "IBMQ.save_account(‘PASTE-API-TOKEN-HERE’)\n" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 177, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "name": "stderr", 98 | "output_type": "stream", 99 | "text": [ 100 | "ibmqfactory.load_account:WARNING:2020-09-11 00:39:28,370: Credentials are already in use. The existing account in the session will be replaced.\n" 101 | ] 102 | }, 103 | { 104 | "name": "stdout", 105 | "output_type": "stream", 106 | "text": [ 107 | "Job Status: job has successfully run\n" 108 | ] 109 | } 110 | ], 111 | "source": [ 112 | "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute\n", 113 | "from qiskit.tools.monitor import job_monitor\n", 114 | "\n", 115 | "#You only need to load your account ONCE for each notebook. \n", 116 | "IBMQ.load_account()\n", 117 | "\n", 118 | "q = QuantumRegister(1)\n", 119 | "c = ClassicalRegister(1)\n", 120 | "qc = QuantumCircuit(q,c)\n", 121 | "qc.h(0)\n", 122 | "qc.measure([0],[0])\n", 123 | "# Specify a backend from the list available to you, \n", 124 | "# In this example we will use ibmq_’valencia’\n", 125 | "backend = provider.get_backend('ibmq_valencia')\n", 126 | "job_object = execute(qc, backend)\n", 127 | "job_monitor(job_object)\n" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 178, 133 | "metadata": {}, 134 | "outputs": [ 135 | { 136 | "data": { 137 | "image/png": "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\n", 138 | "text/plain": [ 139 | "
" 140 | ] 141 | }, 142 | "execution_count": 178, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "from qiskit.visualization import plot_histogram\n", 149 | "result = job_object.result()\n", 150 | "counts = result.get_counts(qc)\n", 151 | "plot_histogram(counts)\n" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 179, 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/html": [ 162 | "

Version Information

Qiskit SoftwareVersion
Qiskit0.20.1
Terra0.15.2
Aer0.6.1
Ignis0.4.0
Aqua0.7.5
IBM Q Provider0.8.0
System information
Python3.7.8 | packaged by conda-forge | (default, Jul 31 2020, 02:25:08) \n", 163 | "[GCC 7.5.0]
OSLinux
CPUs8
Memory (Gb)31.40900421142578
Fri Sep 11 00:42:26 2020 UTC
" 164 | ], 165 | "text/plain": [ 166 | "" 167 | ] 168 | }, 169 | "metadata": {}, 170 | "output_type": "display_data" 171 | } 172 | ], 173 | "source": [ 174 | "import qiskit.tools.jupyter\n", 175 | "%qiskit_version_table" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": null, 181 | "metadata": {}, 182 | "outputs": [], 183 | "source": [] 184 | } 185 | ], 186 | "metadata": { 187 | "kernelspec": { 188 | "display_name": "Python 3", 189 | "language": "python", 190 | "name": "python3" 191 | }, 192 | "language_info": { 193 | "codemirror_mode": { 194 | "name": "ipython", 195 | "version": 3 196 | }, 197 | "file_extension": ".py", 198 | "mimetype": "text/x-python", 199 | "name": "python", 200 | "nbconvert_exporter": "python", 201 | "pygments_lexer": "ipython3", 202 | "version": "3.7.8" 203 | } 204 | }, 205 | "nbformat": 4, 206 | "nbformat_minor": 4 207 | } 208 | -------------------------------------------------------------------------------- /Chapter12/Chapter 12 - Aqua.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "/opt/conda/lib/python3.7/site-packages/qiskit/providers/ibmq/ibmqfactory.py:192: UserWarning: Timestamps in IBMQ backend properties, jobs, and job results are all now in local time instead of UTC.\n", 13 | " warnings.warn('Timestamps in IBMQ backend properties, jobs, and job results '\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "%matplotlib inline\n", 19 | "# Importing standard Qiskit libraries and configuring account\n", 20 | "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n", 21 | "from qiskit.compiler import transpile, assemble\n", 22 | "from qiskit.tools.jupyter import *\n", 23 | "from qiskit.visualization import *\n", 24 | "# Loading your IBM Q account(s)\n", 25 | "provider = IBMQ.load_account()" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "# Chapter 12 - Qiskit Aqua" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 2, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "from qiskit.aqua.components.initial_states import Custom\n", 42 | "init_state_0 = Custom(num_qubits=3, state='zero')\n", 43 | "init_state_uniform = Custom(num_qubits=3, state='uniform')\n", 44 | "init_state_random = Custom(num_qubits=3, state='random')\n" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 3, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "data": { 54 | "image/png": "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\n", 55 | "text/plain": [ 56 | "
" 57 | ] 58 | }, 59 | "execution_count": 3, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "qc0 = init_state_0.construct_circuit(mode='circuit')\n", 66 | "qc0.draw()\n" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "image/png": "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\n", 77 | "text/plain": [ 78 | "
" 79 | ] 80 | }, 81 | "execution_count": 4, 82 | "metadata": {}, 83 | "output_type": "execute_result" 84 | } 85 | ], 86 | "source": [ 87 | "qc1 = init_state_uniform.construct_circuit(mode='circuit')\n", 88 | "qc1.draw()\n" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 5, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "data": { 98 | "image/png": "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\n", 99 | "text/plain": [ 100 | "
" 101 | ] 102 | }, 103 | "execution_count": 5, 104 | "metadata": {}, 105 | "output_type": "execute_result" 106 | } 107 | ], 108 | "source": [ 109 | "qc2 = init_state_random.construct_circuit(mode='circuit')\n", 110 | "qc2.draw()\n" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 6, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAANMAAAB7CAYAAADuSLVaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKzklEQVR4nO3df0zU9x3H8efdCQf+qBZRUVAUAVtooZbZKg4tXTupTWbbhLascUpZNerWbc4lXZw1Gw3JjGtNtrl2qy1t09FVwlqTWpNaEce0y6yujlp3rb/wFBWxiFhEubv9cYoiIiqfu+8dvB4JiXy+n/vcG3Ov+3zuc/e9r83n8/kQkR6zW12ASG+hMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkYojCJGKIwiRiiMIkY0s/qAvoiz/uf4jvSaMl920YNwTEry5L77u0UJgv4jjTi23fc6jLEMC3zRAxRmEQMUZhEDFGYRAxRmEJYyp+f5e3d1dfdLtZSmEQMUZhEDFGYRAzRm7ZhbG/jMZ7Z8Ao+nw8fPn6X+wOy4pKsLquTs+fhfBv0d4KjFz99h/Sf5vV6WblyJSkpKURFRZGZmUlVVRUTJkxg3rx5VpcXcBF2B22etk7t570eIuwOhjj7s3bWz6gsWM7qB3/Iksq3LKiya18cgT9uhOfehWUVsLQc3vsUmlqsriwwQnpmKioqoqKigmXLlpGVlcXWrVspKCigvr6exYsXW11ewCUOHsZXjcc6tDWfO8vRM40kDR7O0OhB7e3OfhE4bKHz3Lj5C3hvB9hsl9rOnofNe2DnQXj2uzB0oHX1BULo/O9foaysjNLSUtatW8eSJUvIzc1l6dKlTJkyhba2Nu6++26rSwy42enTWLNrE9XuPXi8Xr4+28ziTW9yR+wY7hoxtr2fx+tl8cdv8It7v2ddsZc5dNIfJACfr/PxphZ4e2twawqGkJ2ZSkpKyMvLY/r06R3ak5OTiYiIICMjA4ADBw4wZ84c6urqcDqdrF69mpycHCtKNu77ad+mpe0cz258ndqmEwyMjCIn4Xb+/ugS+tkdAPh8Pp7Z8Aozx09kxrhMiyv2q3aBDbhKjuBC+756OPI1jLo1iIUFmM3nu9pzh7XcbjejR49mzZo1PP300x2OFRQUsGfPHnbu3AnAjBkzmDVrFgsXLmTr1q3k5+ezf/9+IiMje1yH7fI1ikEfPfErpo9OMzLWTza+zvABg1k65bHr6l91aDcP/u0FI/fdlcKX9nPLsLHd9tv8xo/57KM/BLQWE643IiG5zHO73QDExcV1aG9paaGqqqp9iXfixAmqq6spKioCIDs7m1GjRlFZWRncgi1SVbubV3dtovLg5zzwTjH5779kdUkA2C7Mmqb6hYuQXObFxsYC4HK5mDlzZnv7ihUrqKurIyvLf3JbbW0tI0aMwOl0tvcZN24cBw8eNFJHoCbttj99bOR8pulj0jiz+MZ28O6bfh++d4p7fN/X8toW+O+hrpd5F5W/uYrxw1cFtJZgCskwJSUlkZGRQUlJCTExMcTHx1NeXs769esB2sMkoWlqCuw61PVxGzD8FkgaFrSSgiIkl3l2u521a9eSnp7OggULKCwsJDY2lkWLFuFwONo3H8aMGcOxY8dobW1tv+3+/ftJTEy0qnQBUuMgO+Xqx2w26OeAp7I7bpv3BiE5MwGkpqZ2eu0ze/Zs0tLSiI6OBvzLwalTp7JmzZr2DYjDhw+Tm5trRclygc0G+ZNgxC1Q+QU0fnPp2O0j4eG7IL4X7eJdFLJhuprt27czefLkDm0vv/wyc+fOZdWqVURGRlJWVmZkJ89qSyrf4tOj+5g4Yiwv3j/H6nJumM0G02+DnFRYXOZvW/4I3DrA0rICKiSXeVfT3NyMy+Xq9GZtUlISW7ZsweVyUVNT0+l9qXC089h+ms+dpbJgOec8bWyv22t1STfNftkjrDcHCcJoZho4cCAej8fqMoLiX0e+4juJdwJwf+KdfFL3Jd8aOb5Tv6ra3eS//yIZwxI5cKqejOGJVDz682CXKxeEzczUlzS2nuEWp/914WBnNI1nv7lqv5zRtzFp5Hg2PrmMnNG38fsHCoNZplxBYQpBg539aWr1f7S6qbWFIVH9r9pvX+Nxxg0eDoD79EniB8UErUbpTGEKQZNHpVBZWwPApoM13DsymTavh2NnTnXot7vBTdrQBDxeL/bets8chhSmEDRxxDii+kWQW/ZrHHY7k0Ymc+BUPcur3+3Qb/cJN2mxCbR6znP8mybqmr+2qGKBMNqA6Guu3A7fVV/LE7dnd2h7bvIj7f/eOfe3wShLrkFhChOPpd5jdQnSDS3zRAzRzGQB26ghffK+ezuFyQK6PlLvpGWeiCEKk4ghCpOIIQqTiCEKk4ghCpOIIQqTiCEKk4ghCpOIIQqTiCEKk4ghCpOIIQqTiCEKk4ghCpOIIQqTiCEKk4ghIXkZTgl/x5vg88NwqAF2XLj2XPIIGDUExsbCHQkQ2cvO81aYxKgDJ2D9Z+A6eu1+0ZEwJRlm3AHOiODUFmgKkxjh8cIH//Ffj+lGHlAxA/wXPhs/PFCVBY/CJD3W5oHSaqhx39ztHXYozPEv/cKZNiCkx8r/ffNBAv+s9vo/oLbBXE1WUJikRz4/DJ90cy22VU/5f67F44W/bvPPcuEqpMPk9XpZuXIlKSkpREVFkZmZSVVVFRMmTGDevHlWl9fneX1Qsd3ceEdPwT+/NDdesIV0mIqKiiguLmb+/Pl8+OGHPP744xQUFLBv3z6ysvRFjlbbcwQams2OWe2CcH0VH7I7/WVlZZSWlrJ58+b269Tm5uayY8cOKioqOl3bVoJvxwHzY9afhkMnYcxQ82MHWsjOTCUlJeTl5XW64HNycjIRERFkZGQA8Pzzz5Oamordbqe8vNyKUvus2pOBGfdQmG5EhGSY3G43NTU15OfndzpWW1tLeno6TqcTgLy8PDZs2MC0adOCXWaf1uaB+qbAjF13qvs+oSgkl3lut3+fNS4urkN7S0sLVVVVPPTQQ+1t2dkdLwBmkk2XtuxSRNRAFr56ukNbdzt2XR3/6dsdf3/lL6+Rf09RD6oz63rfig3JmSk2NhYAl8vVoX3FihXU1dVp8yEEeM63Atf/QLsRbedajI8ZDCE5MyUlJZGRkUFJSQkxMTHEx8dTXl7O+vXrAYIWJn045NpeWAcnTl+ava+cYS66OCN1dfxKv/nlInJKF/WwuuALyZnJbrezdu1a0tPTWbBgAYWFhcTGxrJo0SIcDkf75oNYa3RMgMYNw508CNGZCSA1NZXKysoObbNnzyYtLY3o6GiLqpLLTUyEnQfNjjl0IIwJUEgDLSRnpq5s37690xJv2bJlJCQksG3bNubPn09CQgJ793bz+RYxIj0ehvQ3O2Z2MtjD6lF5SdiU3dzcjMvl6vRmbXFxMW63m9bWVhoaGnC73YwfP96iKvsWhx0eMfjyddggyJlgbrxg0ykY0mNvVl86m/Zm2W3wowcgKYzPawqbmUlC15OTITWu+35dsdv8JwiGc5BAM5MYct7j/wT5tq9u7HaDoqBgMqTFB6auYFKYxKj/1cEHn3V/ol+EAyYlwcOZMMAZnNoCTWGSgKhtuPTtRCea/Sf/RUde+naiuxKhf6TVVZqlMIkYog0IEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUMUJhFDFCYRQxQmEUP+D4cF+GS3HykPAAAAAElFTkSuQmCC\n", 121 | "text/plain": [ 122 | "
" 123 | ] 124 | }, 125 | "execution_count": 6, 126 | "metadata": {}, 127 | "output_type": "execute_result" 128 | } 129 | ], 130 | "source": [ 131 | "# Create the quantum circuit\n", 132 | "num_qubits = 2\n", 133 | "qc = QuantumCircuit(num_qubits)\n", 134 | "qc.h(0)\n", 135 | "qc.cx(0,1)\n", 136 | "# Construct the Custom class based on the built quantum circuit\n", 137 | "q_component = Custom(num_qubits=num_qubits, circuit=qc)\n", 138 | "q_component.construct_circuit().draw()\n" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 7, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [ 147 | "# Import and create the PyTorchDiscriminator class\n", 148 | "from qiskit.aqua.components.neural_networks import PyTorchDiscriminator\n", 149 | "# Set the number data input and output dimension to 2.\n", 150 | "py_torch_disc = PyTorchDiscriminator(n_features = 2, n_out=2)\n" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [ 159 | "# Load the discriminator model, implements the torch.load(dir) \n", 160 | "discriminator_model = '/discriminator_model_directory'\n", 161 | "py_torch_disc.load_model(discriminator_model)\n" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 8, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [ 170 | "# Parameters are defined in the Qiskit API as follows: \n", 171 | "###\n", 172 | "# data (tuple) – real_batch: torch.Tensor, Training data batch. generated_batch: numpy array, Generated data batch.\n", 173 | "# weights (tuple) – real problem, generated problem\n", 174 | "# penalty (bool) – Indicate whether or not penalty function is applied to the loss function.\n", 175 | "# quantum_instance (QuantumInstance) – Quantum Instance (depreciated)\n", 176 | "# shots (int) – Number of shots for hardware or qasm execution. Not used for classical network (only quantum ones)\n", 177 | "###\n", 178 | "result_dict = PyTorchDiscriminator.train(data, weights, penalty, quantum_instance=quantum_instance, shots=None)\n" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 9, 184 | "metadata": {}, 185 | "outputs": [ 186 | { 187 | "data": { 188 | "text/plain": [ 189 | "" 190 | ] 191 | }, 192 | "execution_count": 9, 193 | "metadata": {}, 194 | "output_type": "execute_result" 195 | } 196 | ], 197 | "source": [ 198 | "# Import the CircuitStateFn class\n", 199 | "from qiskit.aqua.operators.state_fns import CircuitStateFn\n", 200 | "# Create the quantum circuit\n", 201 | "qc = QuantumCircuit(2)\n", 202 | "qc.h(0)\n", 203 | "qc.cx(0,1)\n" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 10, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "name": "stdout", 213 | "output_type": "stream", 214 | "text": [ 215 | "CircuitStateFn(\n", 216 | " ┌───┐ \n", 217 | "q_0: ┤ H ├──■──\n", 218 | " └───┘┌─┴─┐\n", 219 | "q_1: ─────┤ X ├\n", 220 | " └───┘\n", 221 | ")\n" 222 | ] 223 | } 224 | ], 225 | "source": [ 226 | "# Create the CircuitStateFn class with the quantum circuit\n", 227 | "csf = CircuitStateFn(primitive=qc, coeff=1, is_measurement=False)\n", 228 | "print(csf)\n" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 11, 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "name": "stdout", 238 | "output_type": "stream", 239 | "text": [ 240 | "True\n" 241 | ] 242 | } 243 | ], 244 | "source": [ 245 | "# Create a second quantum circuit with same width and operators\n", 246 | "qc2 = QuantumCircuit(2)\n", 247 | "qc2.h(0)\n", 248 | "qc2.cx(0,1)\n", 249 | "\n", 250 | "# Create the second circuit state function\n", 251 | "csf2 = CircuitStateFn(primitive=qc2, coeff=1, is_measurement=False)\n", 252 | "\n", 253 | "# Compare both circuit state functions using the equals operator\n", 254 | "print(csf.equals(csf2))\n" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": 12, 260 | "metadata": {}, 261 | "outputs": [ 262 | { 263 | "name": "stdout", 264 | "output_type": "stream", 265 | "text": [ 266 | "CircuitStateFn(\n", 267 | " ┌───┐ \n", 268 | "q_0: ┤ H ├──■──\n", 269 | " └───┘┌─┴─┐\n", 270 | "q_1: ─────┤ X ├\n", 271 | " └───┘\n", 272 | ") * 2\n" 273 | ] 274 | } 275 | ], 276 | "source": [ 277 | "# Add the two circuit state functions together\n", 278 | "added_csf = csf.add(csf2)\n", 279 | "print(added_csf)\n" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 13, 285 | "metadata": {}, 286 | "outputs": [ 287 | { 288 | "name": "stdout", 289 | "output_type": "stream", 290 | "text": [ 291 | "SummedOp([\n", 292 | " CircuitStateFn(\n", 293 | " ┌───┐ \n", 294 | " q_0: ┤ H ├──■──\n", 295 | " └───┘┌─┴─┐\n", 296 | " q_1: ─────┤ X ├\n", 297 | " └───┘\n", 298 | " ) * 2,\n", 299 | " CircuitStateFn(\n", 300 | " ┌───┐┌───┐\n", 301 | " q_0: ┤ H ├┤ X ├\n", 302 | " └───┘└─┬─┘\n", 303 | " q_1: ───────■──\n", 304 | " \n", 305 | " )\n", 306 | "])\n" 307 | ] 308 | } 309 | ], 310 | "source": [ 311 | "# Create a quantum circuit\n", 312 | "qc3 = QuantumCircuit(2) \n", 313 | "qc3.h(0)\n", 314 | "qc3.cx(1,0) \n", 315 | "# Create a circuit state function from the quantum circuit\n", 316 | "csf3 = CircuitStateFn(primitive=qc3, coeff=1, is_measurement=False)\n", 317 | "print(added_csf.add(csf3))\n" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 14, 323 | "metadata": {}, 324 | "outputs": [ 325 | { 326 | "name": "stdout", 327 | "output_type": "stream", 328 | "text": [ 329 | "Binary result: 110.\n" 330 | ] 331 | } 332 | ], 333 | "source": [ 334 | "# Import the utils module\n", 335 | "from qiskit.aqua import utils \n", 336 | "# convert the number 6 from decimal to binary\n", 337 | "binary_value = utils.decimal_to_binary(6, max_num_digits=0)\n", 338 | "print('Binary result: ', binary_value)\n" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": 15, 344 | "metadata": {}, 345 | "outputs": [ 346 | { 347 | "name": "stdout", 348 | "output_type": "stream", 349 | "text": [ 350 | "Random Unitary result: \n", 351 | " [[ 0.62908478+0.34714688j -0.2728722 -0.46236552j -0.06999293+0.43657905j]\n", 352 | " [ 0.62861687+0.17592649j 0.22322343+0.20435486j -0.0264057 -0.69397683j]\n", 353 | " [ 0.23669704+0.04008236j 0.56588394+0.54767203j 0.03572391+0.56650016j]]\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "#Random Unitary matrix\n", 359 | "random_unitary = utils.random_unitary(N=3)\n", 360 | "print('Random Unitary result: \\n', random_unitary)\n" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 16, 366 | "metadata": {}, 367 | "outputs": [], 368 | "source": [ 369 | "# Create an array of random quantum circuits\n", 370 | "from qiskit.circuit.random import random_circuit\n", 371 | "quantum_circuits = []\n", 372 | "# Append a group of random circuits\n", 373 | "for x in range(2):\n", 374 | " quantum_circuits.append(random_circuit(3, 5, measure=True))\n" 375 | ] 376 | }, 377 | { 378 | "cell_type": "code", 379 | "execution_count": 17, 380 | "metadata": {}, 381 | "outputs": [ 382 | { 383 | "name": "stdout", 384 | "output_type": "stream", 385 | "text": [ 386 | "Submitting 2 circuits.\n", 387 | "============================================================================\n", 388 | "0-th circuit: 3 qubits, 3 classical bits and 11 operations with depth 6\n", 389 | "op_counts: OrderedDict([('measure', 3), ('cswap', 2), ('cz', 1), ('ry', 1), ('id', 1), ('t', 1), ('h', 1), ('ccx', 1)])\n", 390 | "1-th circuit: 3 qubits, 3 classical bits and 9 operations with depth 6\n", 391 | "op_counts: OrderedDict([('measure', 3), ('cswap', 2), ('ccx', 2), ('crz', 1), ('u1', 1)])\n", 392 | "Average: 3.00 qubits, 3.00 classical bits and 10.00 operations with depth 6.00\n", 393 | "============================================================================\n", 394 | "\n" 395 | ] 396 | } 397 | ], 398 | "source": [ 399 | "# Obtain and print a summary of all the quantum circuits\n", 400 | "circuits_summary = utils.summarize_circuits(quantum_circuits)\n", 401 | "print(circuits_summary)\n" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 18, 407 | "metadata": {}, 408 | "outputs": [ 409 | { 410 | "name": "stdout", 411 | "output_type": "stream", 412 | "text": [ 413 | "Full coupling map: [[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n" 414 | ] 415 | } 416 | ], 417 | "source": [ 418 | "# Fully entangled coupling map\n", 419 | "full_coupling_map = utils.get_entangler_map(map_type=\"full\", num_qubits=5)\n", 420 | "print('Full coupling map: ', full_coupling_map) \n" 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": 19, 426 | "metadata": {}, 427 | "outputs": [ 428 | { 429 | "name": "stdout", 430 | "output_type": "stream", 431 | "text": [ 432 | "Full coupling map: [[0, 1], [1, 2], [2, 3], [3, 4]]\n" 433 | ] 434 | } 435 | ], 436 | "source": [ 437 | "# Linearly entangled coupling map\n", 438 | "lin_coupling_map = utils.get_entangler_map(map_type=\"linear\", num_qubits=5)\n", 439 | "print('Full coupling map: ', lin_coupling_map)\n" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": 20, 445 | "metadata": {}, 446 | "outputs": [ 447 | { 448 | "name": "stdout", 449 | "output_type": "stream", 450 | "text": [ 451 | "[[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]\n" 452 | ] 453 | } 454 | ], 455 | "source": [ 456 | "# Validate entangled coupling maps\n", 457 | "result = utils.validate_entangler_map(entangler_map=full_coupling_map, num_qubits=5, allow_double_entanglement=True)\n", 458 | "print(result)\n" 459 | ] 460 | }, 461 | { 462 | "cell_type": "code", 463 | "execution_count": 21, 464 | "metadata": {}, 465 | "outputs": [ 466 | { 467 | "name": "stdout", 468 | "output_type": "stream", 469 | "text": [ 470 | "[[ 8.66025404e-01 3.92523115e-17]\n", 471 | " [-8.66025404e-01 3.92523115e-17]]\n" 472 | ] 473 | } 474 | ], 475 | "source": [ 476 | "# Import NumPy to create the array\n", 477 | "import numpy as np\n", 478 | "\n", 479 | "# Generate a 2x3 (NxD) array\n", 480 | "dim_map = np.array( [[ 0,1,0], [ 1,0,1]])\n", 481 | "# Reduce the D from 3 to 2, resulting in a 2x2 dimensional array\n", 482 | "reduced_dim = utils.reduce_dim_to_via_pca(x=dim_map, dim=2)\n", 483 | "print(reduced_dim)\n" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 22, 489 | "metadata": {}, 490 | "outputs": [], 491 | "source": [ 492 | "# Import the necessary modules and classes\n", 493 | "from qiskit import BasicAer\n", 494 | "from qiskit.aqua import QuantumInstance\n", 495 | "from qiskit.aqua.algorithms import Grover, DeutschJozsa, BernsteinVazirani, Simon\n", 496 | "from qiskit.aqua.components.oracles import LogicalExpressionOracle, TruthTableOracle, CustomCircuitOracle\n", 497 | "\n", 498 | "# State the SAT problem into a logical expression\n", 499 | "# A = Sophia, B = Angelina, C = Leo, D = Lex\n", 500 | "expression = '((A ^ B) & (C & D) & ~(A & C))'\n" 501 | ] 502 | }, 503 | { 504 | "cell_type": "code", 505 | "execution_count": 23, 506 | "metadata": {}, 507 | "outputs": [], 508 | "source": [ 509 | "# Create an Oracle based on the Logical Expression\n", 510 | "oracle = LogicalExpressionOracle(expression)\n" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": 24, 516 | "metadata": {}, 517 | "outputs": [ 518 | { 519 | "data": { 520 | "image/png": "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\n", 521 | "text/plain": [ 522 | "
" 523 | ] 524 | }, 525 | "execution_count": 24, 526 | "metadata": {}, 527 | "output_type": "execute_result" 528 | } 529 | ], 530 | "source": [ 531 | "# Construct the circuit from the oracle\n", 532 | "quantum_circuit = oracle.construct_circuit()\n", 533 | "quantum_circuit.draw()\n" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": 25, 539 | "metadata": {}, 540 | "outputs": [], 541 | "source": [ 542 | "# Generate a quantum instance from a simulator\n", 543 | "quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=1024)\n" 544 | ] 545 | }, 546 | { 547 | "cell_type": "code", 548 | "execution_count": 26, 549 | "metadata": {}, 550 | "outputs": [], 551 | "source": [ 552 | "# Create the Grover algorithm with the Logical Expression Oracle\n", 553 | "grover = Grover(oracle)\n" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": 27, 559 | "metadata": {}, 560 | "outputs": [ 561 | { 562 | "name": "stdout", 563 | "output_type": "stream", 564 | "text": [ 565 | "Top result: 1110\n" 566 | ] 567 | }, 568 | { 569 | "data": { 570 | "image/png": "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\n", 571 | "text/plain": [ 572 | "
" 573 | ] 574 | }, 575 | "execution_count": 27, 576 | "metadata": {}, 577 | "output_type": "execute_result" 578 | } 579 | ], 580 | "source": [ 581 | "# Run the Grover algorithm \n", 582 | "result = grover.run(quantum_instance)\n", 583 | "\n", 584 | "# Print the top measured result\n", 585 | "print('Top result:', result['top_measurement'])\n", 586 | "# Plot all measured results\n", 587 | "plot_histogram(result['measurement'])\n" 588 | ] 589 | }, 590 | { 591 | "cell_type": "code", 592 | "execution_count": 28, 593 | "metadata": {}, 594 | "outputs": [], 595 | "source": [ 596 | "# Create the Truth Table expression for constant\n", 597 | "truth_table = '1111'\n", 598 | "\n", 599 | "# Create the Truth Table Oracle from the expression\n", 600 | "constant_oracle = TruthTableOracle(truth_table)\n" 601 | ] 602 | }, 603 | { 604 | "cell_type": "code", 605 | "execution_count": 29, 606 | "metadata": {}, 607 | "outputs": [ 608 | { 609 | "data": { 610 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAA08AAADWCAYAAAAJv7kMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAu3UlEQVR4nO3de3wU9b3/8ffs5oJAuMk1QERALgmQgEAVhAQBlWKFIqDH1rsFLJwjVqtorUq1LdQL/Fov4AVb8aGWi1i0yjnSQhA5R7lFBEG5hPsdAiQQQpLd3x8rgQC7O0tmd2Y2r+fjkQfJ7Hdn33wz2e98dr4zY/j9fr8AAAAAACF57A4AAAAAAG5A8QQAAAAAJlA8AQAAAIAJFE8AAAAAYALFEwAAAACYQPEEAAAAACZQPAEAAACACRRPAAAAAGACxRMAAAAAmEDxBAAAAAAmUDwBAAAAgAkUTwAAAABgAsUTAAAAAJhA8QQAAAAAJlA8AQAAAIAJFE8AAAAAYALFEwAAAACYQPEEAAAAACZQPAEAAACACQl2BwDssGHDhrBtXnrpJY0bNy5kmw4dOlgVCQAARIjxHLHGkScgiJdfftnuCAAAoIoYz2EliicAAAAAMIHiCQAAAABMoHgCgpgzZ47dEQAAQBUxnsNKFE8AAAAAYALFExDE8OHD7Y4AAACqiPEcVuJS5Tb4YIW0qyD2r9u8vjSse+xfF4B1HvruW31dWGjLa2empOiF9um2vLYd3NrXduWubtuH5M6+tmsfRKp++yHjx49XXl5ezF83KytLU6dOjfnrVhcUTzbYVSBt3m93CgBu9HVhoZYUHLY7RrXg1r52a243cmNfsw8SO3l5ecrNzbU7BizGtD0giLFjx9odAQAAVBHjOaxE8QQEEe5u5AAAwPkYz2EliicgiL59+9odAQAAVBHjOaxE8QQEceDAAbsjAACAKmI8h5UongAAAADABIonIIj09Op1yV0AAOIR4zmsRPEEBDF37ly7IwAAgCqK5/HcMAwlJHDnoViit4EgnnzySf3ud7+zOwYAAKgCN4znHo9H/fr101VXXaXMzEzVrVtXpaWl2rRpk1auXKkFCxacd+6WYRh65ZVX1KhRI916660qKyuzKX314tjiqX///jpy5IhWrlxZafmhQ4fUtm1bjR49WpMmTbIpHaqD2bNnO/7N9lx+v2QYdqeoHujr2KGvEYrfH/iXbQTBOHk8T0pK0gMPPKCxY8fqsssuC9ru1KlTmjNnjn73u9/pu+++qyicxowZo+LiYnXu3FmrV6+OYfLqy7HFU5cuXTR9+nT5fD55PGdmF06cOFFJSUl6/PHHbUwXW3OezVFapwHqOfQJU8tRvZSdknatkXbmScVHJY9XatRWSrtSqtvM7nTx5VRxoJ93rZFKCiVvktSkvZTWTardyO50F+YvLVXZfz4oT9dMeUf/omJ5+bwP5Zs7TwnTXpZRu7aNCS+spEjasVra/Y106oSUUENqli617CbVrGd3ugtzY1+7MbMk+XzS3nXSjjypaL8kQ2qQFtg+Gra2O92FubWv2QeJnqysLL399tvq3LmzJGnTpk2aP3++Vq1apYMHDyo5OVnp6enq06ePrr/+et12220aNmyYnnzySbVp00ajR49WcXGxbrrpJgqnGHJ08VRcXKwtW7aobdu2kqSNGzdq2rRp+vOf/6w6derYnBCwX2mxtPLvUtHBM8t8ZdK+76R9G6T066XUzvbliycnj0kr3g/8e1r5qcDO/Z51UpchUqM29uULxkhMVMKEX6vsP8fL6NlDnq5Z8ufnyzfjb/L+/neO3FkrOhjYrkuLzywrOyntWBXo767DpXrN7csXjBv72o2ZfeXSmn9IB7dIMiT5A1+HtkmHtkqtfiS17WNvxgtxY18jenJycvTxxx+rVq1a2rhxox544AEtWLBA/tOHUn8wf/58TZo0SWlpaZo4caLuuusu/elPf5KkisJp4cKFdvwXqi3HXjCiS5cukqR169ZVLHv00Ud1xRVX6Be/CHxis3XrVmVnZ6tdu3bq3LmzPv/8c1uyIj7l5ubaHSGsb/+ncuFU4Yf33m//Wyrk9haWWPORdLLwwo/5fdKa+cEft5vR6jJ57rlT5c9Pkf/wYZVNek6eIT+Rp4vzKmu/T8r7QCo9eeHHy8sCj5edim0us9zU16e5LfOWZT8UTlLFe93Z32/9Utr3faxTmeO2vo4XThvPMzIy9NFHH6lWrVqaOXOmMjMz9emnn55XOJ1t+/btuueee/Tpp59WLJs/fz6Fkw0cWzxlZGTI6/VWFE9Lly7VvHnz9Pzzz8vr9UqSRo8erVtuuUXff/+9pk+frltvvVWnTjl0RIXrnF24O1HxUenAxvDtdnIkv8qO7pGO7VHlHbVz+MsD0/mcyjN0iIy0liobPVbyeuW583a7I13QwS0/HN0L1td+qaxE2rs+lqki45a+PptbMpeXBqbOhmRIO1aGaWMjt/R1PHHSeJ6QkKC//vWvql27tt59913deeedKi4uDvu80+c4DRo0SCUlJSovL9eIESPUu3fvGKTG2Rw7ba9GjRpq166d1q5dK0l6+OGHNXDgQA0aNEiSdPDgQS1dulTz58+XJPXq1UupqalatGiRrr/+eksyGFE6+/Tm3yxSi445ET3nq3/8Xis/eb7SstKTRUrrNMD0OnJzF+u/rusX0evGqwcffDBsmylTpoRtN2XKFKsiRWxQz3v1qxFvhG339ee7lH59ixgkil8/G/CE7rr+mZBt/H6/Fvx9ucZd86OoZvE+N0mezC4RP88wDBldOsu/cpU8t46UkZgY8ToWL14so8dVET8vEv/505d141Wj5fF4g7Yp95XpzSkf6+m//TSqWdza1xeT2+7MZmW06q2pY5eGbuSXjuySaiTVVElp+J3SqnBjX9u1DyJFZz/EbeP5fffdp+7du2vr1q0aPXp0yKNNp517cYibbrpJ2dnZeuKJJ/TKK68oMzOzUvvc3Nyo7cPGMzO/C8nBxZMUmLq3bt06vf/++1q+fLny8vIqHtu+fbuaNGmi5OTkimWXX365tm3bZkPS6Os55DcXPFkT1VeCN8lUu0ST7RBcgjdJfr8/5GBkGIYSE5KDPm43f36+fO++L88tI+R75115+vSW0bix3bHOk/hDX4diyHD0du2Wvj6bWzJH8ntP8CZFvXi6GG7p67OxD2KdcePGSQqcilJUVBS2/YUKp4ULF2rJkiW699571aVLF/Xp04dTV2LI8cXThx9+qMcee0z33HNPxdVIYsVsBRqpv3wmbd4flVWHlJ2doznPRuf/5DYbNmwI22bKlCkaNWpUyDYvvviiVZEiVrAjcFJ9SIbUqmOjqG3L1cXeDdLaj8M0MqRe/TPlfzG6fT1gxZdaUnA4ouf4T5UGzq0YNlTeu++Uv6BA5c+9KO/kP8jwmJ+9nZOTo4VR3pa2rZA2Lg7dxuPxasTtP9bjb9LXFxJpbidkNutkobR0evh2SbWkwhNHon75cjf2tV37IFJ09kOcPJ7n5ORUOt+qa9euysjI0J49e/TBBx+EfX6wwkkKXLr8jTfe0G9/+1vdcccdlYqn7OxsLV682PL/DwIce86TJGVmZqqkpEQHDx7UM89UnjKTlpamffv2qaSkpGJZfn5+yGvkA5GYOHGi3RFCqtdCqllfgatNBeOXWmTFKFAca9xWSqwRppGD+9o34y0ZCQny3P4zSZL3l2Pk37tPvrnzbE52vmYZkmFiZGqeGb6NHdzU16e5KXONlMCtGEK+7ynwt+jEWUtu6ut44pTxvGfPnpKkhQsXhr2hbajC6bTTF4/o0aNHdALjghxdPA0ePFh+v1+FhYVq2rRppccaNmyo3r17680335QkLVu2TLt27VK/fpzTA2uMHDnS7gghGYbU8bofdhCC7CQ0bC01viKmseKSJ0HqcF3oNqmdpbqpsckTCd/qPPk+WSDvhEdkJAQmGxg1a8r76MPyvf2O/Pn5NiesLOkSqV2Yt/HLr/rhgwOHcVtfS+7MfEW2lJCsoO97tRoG7r3mNG7s63jhlPH89AyqcPdkMlM4Sao4nSUjI6PSPVERXY6ethfOtGnTdNddd2nq1KlKSkrSe++9p6Qk586Dv1jDn1gc0XJYo2PHjlq/3sGX9JJUv6XUbaT0/b+lwrOmYXgSpBaZUtu+5j7FR3hN2kmenwamlJ0oOLM8ITlwQ+LLr3bmJ92erlnyzD9/eoinU4Y8Hznz0+6WXQP9uunzwM2IT0uqKbW6KvC4E7mxr92YuWZ9qcdt0oaFUsH2M8sNT+Cm1e37/1BcOYwb+1qKj30Qp4znX375pZKTk7VixYqQ7caPHx+2cJIC93l67bXXVF5eLq/XK5/PF43YOIeri6fWrVtryZIldscAbFW/hfSjO6Rj+6SvZgaW9f2llBB/nyPYrlGbwNG8o3ukFe8GlvUZI3kjv1gWwmiWLjXtELhq2ulz+64ZLYW4CB+qkVoNpCtHBj7IWBaYgKJrRkvJtezNBYQyc+ZMzZw5M2y7119/XYMGDdKf/vSnsPdxGj16tFXxYJKriycAZ9RpcuZ7CqfoMQyp3lnT8yicosfwBI6unkbhhHOdPX2TwgnxoqioSNddF2auOGzDhB4giJycHLsjAACAKmI8h5UonoAgXn31VbsjAACAKmI8h5UonoAg7r//frsjAACAKmI8h5UonoAguMEcAADux3gOK1E8AQAAAIAJFE8AAAAAYALFExCEE26oBwAAqobxHFaieAKCmDVrlt0RAABAFTGew0rcJNcGzeuHbxNPr+tWTz31lEaOHGl3DKCSzJSUavnadnBrX9uVu7ptH5I7+9rOfQG7Xtuu8TwrKyvi52zZvkeS1DqtWaXvo/26MI/iyQbDutudAIBbvdA+3e4I1YZb+9qtud3IjX3NPkjsTJ06NeLnTJj8miRp0qOjKn0P52DaHgAAAACYQPEEBPHKK6/YHQEAAFQR4zmsRPEEBJGRkWF3BAAAUEWM57ASxRMQRHZ2tt0RAABAFTGew0oUTwAAAABgAsUTAAAAAJhA8QQE0aNHD7sjAACAKmI8h5UonoAgli9fbncEAABQRYznsBLFEwAAAACYQPEEAAAAACZQPAFBzJkzx+4IAACgihjPYSWKJwAAAAAwgeIJCGL48OF2RwAAAFXEeA4rJdgdoDr6YIW0qyD2r9u8vjSse+xfF/Hvoe++1deFhba8dmZKil5on27La9uBvo4d+hrh2LWNVGX7sGsfRGI/xA3Gjx+vvLw8W147KytLU6dOteW1I0HxZINdBdLm/XanAKzzdWGhlhQctjtGtUBfxw59jXDcuI2wD4JQ8vLylJuba3cMR2PaHhDE2LFj7Y4AAACqiPEcVqJ4AoIYN26c3REAAEAVMZ7DShRPQBB9+/a1OwIAAKgixnNYieIJCOLAgQN2RwAAAFXEeA4rUTwBAAAAgAkUT0AQ6elcJhgAALdjPIeVKJ6AIObOnWt3BAAAUEWM59FlGIbatm2ra6+9VgMGDFC3bt2UlJQUtH1iYqJ+9atfKSHBnXdMongCgnjyySftjgAAAKqI8Tw6cnJyNGvWLBUUFGjjxo3617/+pc8++0wrV65UUVGRli1bprvvvluXXHJJxXMSExP1/vvv64UXXtD06dNtTH/xHFs89e/fX1deeeV5yw8dOqT69etrwoQJNqRCdTJ79my7I5hWdkratebMz8f22Zcl3pUWSztWn/n5+CH7ssS7kiJp24ozPxcftS8LnMdXLu3bcObnw9skv9++PHAuN43nbtC6dWstXrxYixYt0ogRI1S3bl3t3r1bixYt0sKFC/Xtt9/K6/Xq6quv1owZM7R582b95Cc/qSichg0bpoKCAr388st2/1cuimOLpy5dumj9+vXy+XyVlk+cOFFJSUl6/PHHbUoWe3OezdFXHz5rejmql51fS5+/Kq3/nzPLvpoprXhPKjluX65Q/KWlKh0zTuXTX6+0vHzehyr9+Z3yFxXZlCw4v1/K/z9pyTTpu3+dWf6/b0l586SyEvuyheLKvvZJ3y+SPp8ubVx8ZvkXr0vrPpXKy2yLFpIb+9qtDm6RPp8mffPxmWWrZgf+HosO2pcrFLduH+yD4GxDhw7VmjVrlJ2drf379+vpp5/WZZddpubNm+vaa6/VwIEDlZGRobp16+qOO+7QypUr1axZM82fP1/r16+vKJwGDBigVatW2f3fuSiOLp6Ki4u1ZcuWimUbN27UtGnTNHHiRNWpU8fGdIAz7P5G2vCZVF56/mNHdkurZgWOSjmNkZiohAm/lu/jT+RbnSdJ8ufnyzfjb/I+8rCM2rXtDXgBW7+SNi+V/OXnP3Zws7T6A+mcz3ocwY19/d0iaftKSRc4irBnnbT2n848wuDGvnajgh2BDyxKi89/7ESBtPJ96eSx2OcKh+0DbnfTTTdp9uzZqlWrlt577z117NhREydO1Pbt289rW1RUpJkzZ6pHjx761a9+pfLycrVp00YlJSWuLpwkhxdPkrRu3bqKZY8++qiuuOIK/eIXv5AUmMParl07eTwezZkzx5aciF+5ubl2RwjJVy5tXBKigT8wpWzvtzGLFBGj1WXy3HOnyp+fIv/hwyqb9Jw8Q34iT5fOdkc7T+lJKX9Z6DZHdwWKKCdyU18XH5F2rg7d5sBG6djemMSJmJv62q02fR7iQX/g73Xb8pjFiQjbhz2cPp67QcuWLTVz5kwlJCToj3/8o2677TYdPnw47PMSEhJ0zTXXyOv1yu/3Kzk5WZ07u3t7d2zxlJGRIa/XW1E8LV26VPPmzdPzzz8vr9crSbrhhhu0YMEC7hyNqDi7cHeig/kX/uT1XDvXhG9jF8/QITLSWqps9FjJ65XnztvtjnRB+zYEitWQjMCRQKdyS1/vNvNnR19XW8cPS0d364JHJc+2e60zjwRLbB92cPp47gbTp09XnTp19MEHH5g+debcc5yeeuopSdLUqVPVpEmTaMaNKsdeI7BGjRpq166d1q5dK0l6+OGHNXDgQA0aNKiiTa9evaKawTCMqKz35t8sUouOORE956t//F4rP3m+0rLSk0VK6zTA9Dpycxfrv67rF9HrxqsHH3wwbJspU6aEbTdlyhSrIkVsSK+xGvfTl8K2251/SIbRMKpZvM9NkiezS8TPMwxDRpfO8q9cJc+tI2UkJka8jsWLF8vocVXEz4vE3Tc8q/+49vHQ7wl+afmyb9T15sj7IRLx3tcPjXhTA6+8Q15v8OHJV16uD2d/pvTrBwVtY4V472s36npFf/1p1MKw7cpLpXq1G6iwuCCqeS5mG7F7+7BrH0SKzn5IPIznZ3t0UuAKdIZhVPreTl27dtWgQYN05MgR3X///aaec27hdHqq3tVXX61Bgwbp/vvv19NPP13pObm5ubb+X/0m54M7tniSAlP31q1bp/fff1/Lly9XXl6e3ZFs03PIb9Rz6BOVls15NseeMHCE4yfDX3rM7/ebamcXf36+fO++L88tI+R75115+vSW0bix3bHOc/zk0bBv6D5fuYpOHIlNoIvgrr4OPSnCL7+OO/jSe27pazcy+3sv95Xp5ClnXjHHjdsH+yDV25gxYyRJM2bM0P79+8O2D1Y4SdKkSZM0aNAgjRo1Ss8884zKy8NN63AexxdPH374oR577DHdc889MZ8jabYCjdRfPpM2h9/2LJednaM5zzrwLGsbbNiwIWybKVOmaNSoUSHbvPjii1ZFiljpycBV9kJNJzMMQ1cPbi3/H6P7ex+w4kstKQg/9/ls/lOlgfn+w4bKe/ed8hcUqPy5F+Wd/AcZHvMzinNycrQwylcPOHFEWvZG6DYej1fDf9FHD75CX1fFkd3SindDt/F6EvRfT96iZ9+5JapZ4r2v3cjvD1x1MeQFIQypafsEnYrBJTAj3UacsH3YtQ8iRWc/JB7G87NNmPyapMA+6Nnfx0pOTs5554j1799fkjRz5sywzw9VOEnSkiVLtHXrVrVq1UodO3asmGEmSdnZ2Vq8eLE1/5Eocuw5T5KUmZmpkpISHTx4UM8884zdcVDNTJw40e4IISXWkFpkhWhgSN5EqUVmrBJFxjfjLRkJCfLc/jNJkveXY+Tfu0++ufNsTna+mvWkJu1DNDCkpJpSs/RYJYqMm/q6bjOpbvMQDQypZn2pYduYRYqIm/rajQxDavWj8O0u6xH9LBeD7cMeTh/PnaxevXpq06aNiouL9c03oU82DVc4nfbVV19J0gXv5+oGji6eBg8eLL/fr8LCQjVt2tTuOKhmRo4caXeEsNr2lRqf3qk/Z1aZN1HqerNUIyXmscLyrc6T75MF8k54REZC4AC4UbOmvI8+LN/b78ifn29zwvOlXy/VT/vhh3P6OukSqdsIKSE55rHCcltfG4aUOURKOX0u8Tl9fUldqetwKYIP6WPGbX3tVs27SK2CnO5jeKROg6V6qbHNZAbbh33cMJ47VbNmzSRJW7duDTnFzmzhJEmbNm2SJKWmOvAP1QRHT9sL57e//a3eeustHThwQN98843Gjx+v3NxctWnTxu5olhr+xOKIlsMaHTt21Pr16+2OEZLHK3W+UTqSJe1aI+39Ie4V2VJqJynxElvjBeXpmiXP/A/OX94pQ56PnPkJrDcpUCAdypd2fRO4XLYkdRggNU2XEpLszReMG/s6qabU4zbpwGZpz9rADVElKX1Q4AhgiGtJ2MqNfe1GhiG1vUZq0i5wk/BdXweWt7pKatFFquHQ20C6dfuIh30QN4znTrVhwwalpKQoISH0G29SUpKaNGli6ga4v//97zV58mSdOHHC6rgx4cDP7sx75plntHPnTpWUlOjQoUPauXNn3BVOQDiGIdVvGfi09bTLeji3cHIzw5Aatg4cGTmtRZZzCyc383gDO8dZw84sS81wbuGE2EtpLHUceObnttc4t3AC3Mrv96uoqEhHjhwJ2e748eO64YYb1Ldv37A3wD1x4oSOHTumsrIyC5PGjquLJwAAAAD2KyoqqnQBiHhF8QQEkZOTY3cEAABQRYznsBLFExDEq6++ancEAABQRYznsBLFExCE2btoAwAA52I8h5UonoAg3HCjNgAAEBrjOaxE8QQAAAAAJlA8AQAAAIAJFE9AENxQDwAA92M8h5W43aANmtevXq/rVrNmzdLIkSPtjuEKmSkp1fK17UBfxw59jXDs+j1V5XXt3Bew67UZz83Lysq6qOdt2b5HktQ6rVml72Px2rFG8WSDYd3tTgAznnrqKd5sTXqhfbrdEaoN+jp26GuE48ZtpDrugzCemzd16tSLet6Eya9JkiY9OqrS9/GIaXsAAAAAYALFEwAAAACYQPEEBPHKK6/YHQEAAFQR4zmsRPEEBJGRkWF3BAAAUEWM57ASxRMQRHZ2tt0RAABAFTGew0oUTwAAAABgAsUTEESPHj3sjgAAAKqI8RxWongCgli+fLndEQAAQBUxnsNKFE8AAAAAYALFEwAAAACYQPEEBDFnzhy7IwAAgCpiPIeVKJ4AAAAAwASKJyCI4cOH2x0BAABUEeM5rJRgd4Dq6KHvvtXXhYUxf93MlBS90D79op77wQppV4HFgUxqXl8a1t2e1wYAAABOo3iywdeFhVpScNjuGBHZVSBt3m93CgAAAMA+TNsDghg7dqzdEQAAQBUxnsNKFE9AEOPGjbM7AgAAqCLGc1iJ4gkIom/fvnZHMK28TDq278zPJwslv9++PPGsvFQ6tvfMz6eO25cl3pWVSEf3nPm5tNi+LHAen08qOnjm5xNHeN/DhblpPIfzcc4TEMSBAwfsjhBS2Slp77fS7rVS4X7J7zvz2NLpUlJNqWEbqUWWVKeJbTHjQmmxtHudtGfdDztrZ+2gLXlVSk6RGrcN9HWtS+1KGR9KiqRd30h710snzjk1NPdl6ZK6UpP2UvPMwPeoXnzl0v6N0q410tHdkq/szGPL3pASkqUGlwX+Fuu3lAzDtqhwEKeP53AXiifAZfx+ad8GacO/pLKTwdudOiHt/ibw1egKqcMAKblW7HLGA79f2pknbVoSOOIUTEmhtGN14Cu1k9SuX2AnDub5yqVty6Utyyp/EHCu4qPS1q+krcultCulNr0lb2LscsI+h7dL6/87sA0EU1Yi7f8+8FU3VUq/QarVIHYZAcQ/iicgiPT0i7usezT5yqVvFwQ+lY/EgY3SkR1S5lCpXouoRIs7Zaekb+ZLh7ZG9rzda6VD26Suw6TajaISLe6cOiHlzZOO7QnftoJf2r5COrRFyrqZo1DxzO+Xtnwh5f9fZM87ulv68m9S+iCpaYfoZIM7OHE8h3txzhMQxNy5c+2OUInfJ33zceSF02mlJ6VVc6Qju63NFY/KS6W8DyIvnE4rKZRW/l06fsjSWHGp9KS0alaEhdNZjh8O9PXJ2N86DzGy6fPIC6fTfOXS2iq8byI+OG08h7tRPAFBPPnkk3ZHqGTbisARpFAGPBz4CsZXFjiaUhpiuh+kTUulIztDtwnX16UnpTXzK5+TgfNt+KzySf8XEq6vTx6T1v6TiwXEowObpG1fhW4TbvuQAkfsT9h0o3fYz2njOdzNscWT3+/XtGnT1K1bN9WsWVNpaWkaP368ioqK7I6GamL27Nl2R6hw/LC0+Qtr1lVSJG3MtWZd8ejIbmnHSmvWdfzQxX9iXh3s3yjt+86adR3ZGTg/DfGj9KS0/jNr1nV6yjMFdvXkpPEc7ufI4snn8+lnP/uZHn74YY0YMUL//Oc/9fjjj+uvf/2r7r33XrvjxZS/tFSlY8apfPrrlZaXz/tQpT+/U36HFpNzns3RVx8+a3o5Qtu+QvKXW7e+3WuZ5hTM1i+tXd/2VYHzp3C+rRYXllu/Cn2xCbjL7rXW3grgyK7wR5QBIBxHFk8vv/yy/v73v+vTTz/VY489pn79+mnMmDF66KGHNGvWLB05csTuiDFjJCYqYcKv5fv4E/lW50mS/Pn58s34m7yPPCyjdm17AyLqykqkPd9avFJ/4FK/qOzkMengZmvXWX6K8y0u5Njeyvcms0JJoXRwi7XrhD38fmnX19avl6OTAKrKkcXTCy+8oBtvvFF9+vSptLxt27aSpJ07d2rr1q3Kzs5Wu3bt1LlzZ33++ed2RI0Jo9Vl8txzp8qfnyL/4cMqm/ScPEN+Ik+XznZHi2u5uc6Y23Z0T3TOmynYbv063e5wlPrk8LborNfNotUn0fodIrZKCqNzjtLh7Uzdq46cMp4jPjiueNq8ebO2bdumwYMHn/fYjh07JEmpqakaPXq0brnlFn3//feaPn26br31Vp06Fb9zYzxDh8hIa6my0WMlr1eeO2+3O1LcW7dund0RJFn/6fxp595YF1JhtPo6Sut1s2ht19FaL2IrWr/H0uLAEWZUL04ZzxEfHHefp9N3gU5NTT3vsc8++0xZWVny+XxaunSp5s+fL0nq1auXUlNTtWjRIl1//fWWZTGidGty73OT5MnsEnEWo0tn+VeukufWkTISI78r5OLFi2X0uCri50nSzb9ZpBYdcyJ6zlf/+L1WfvJ8pWWlJ4uU1mlAROvJzV2s/7quX0TPCefBBx8M22bKlClh202ZMsWqSEGNG/oXDek9rtKycFeWCvb4wrN+HeWlUp3a9VVUfKRqAePIk3fMUZ/ON1daZkVfHz14UoZxSRXTxZepY79QRqtelZZdTF8vrPwWow3f5Kvnba2rmA52G9JrrMb99KVKy6z4W5SkKzOv1vptXMklXrhpPDfj0UnTJQX2+87+3uncmvtsfpOHpR1XPLVq1UqStGnTpkrLP/nkEy1cuFBvv/22tm/friZNmig5Obni8csvv1zbtsXv3Bh/fr58774vzy0j5HvnXXn69JbRuLHdsULqOeQ36jn0iUrL5jybY08YF4vmm48hd72xRVvU+sNlA0gsRGu7ZpuOE1H8m/EYjpt0A8BFHFc8NW3aVDfeeKP+8Ic/qE6dOmrdurWWLFmiyZMna/To0br99tu1atWqmGQxW4FGasCKL7Wk4LD5HKdKA+c5DRsq7913yl9QoPLnXpR38h9keMwPAjk5OVp4kf+nv3wmbd5/UU+tsuzsHM151trfxYYNG8K2mTJlikaNGhWyzYsvvmhVpKA2fyHl/2/lZed+knra6U9egz1+NsMrHSk8LI+3avniyfr/Of9CGlb0dUq95Ki9n7hV3rzzL85hRV+369iKvo4DezcEbm57Niu2D0n6cuUXqtXg4rPBWdw0npsxYfJrkgL7oGd/73RuzX0xHPnxy9tvv60hQ4boiSee0ODBg/XRRx/ppZde0rRp0yRJaWlp2rdvn0pKSiqek5+fr8suu8yuyFHlm/GWjIQEeW7/mSTJ+8sx8u/dJ9/ceTYni28TJ060O4IkqU6T6Kw3paEonM6REq2+jtJ63SwlSgfO6ev4EK3tw5sk1awfnXXDuZwyniM+OLJ4ql+/vl5//XXt3r1bx48f1/Lly3X33XdXPN6wYUP17t1bb775piRp2bJl2rVrl/r1s/a8GCfwrc6T75MF8k54REZC4EChUbOmvI8+LN/b78ifn29zwvg1cuRIuyNIkuqmStGYZVKvhfXrdLt6zd21Xjer3zI662W7jg8160tJtaxfb73mzKKtjpwyniM+OG7anlnTpk3TXXfdpalTpyopKUnvvfeekpKS7I5lOU/XLHnmf3D+8k4Z8nzk3CNPw59YHNFyJ+rYsaPWr7f/Bj1JNaVGbaX931u73uaRXbOkWqjdMLBzdWSXdes0vFJqhnXrixf1W0qX1JOsvF5JQg2p8RXWrQ/2MQypeWcp3+LrOjTPtHZ9cAenjOeID64tnk6fCwVUB5d1t7Z4athaqnWpdeuLJ2k9rC2eUjOi8wm62xlGYLvesNC6dbbsKnkjvxApHKpFlrR9ZeDKoFao2SDw3gcAVeHIaXsAKqubKrXsZs26vElSh8iuFl+tNG4rNW5nzbqSa0tt+1qzrnjUPNO6aXa1LpUu/5E164IzJNeWrsi2bn3pN0gRXGMJAC7ItUeegGjLycmxO0IlbftIR3dLx/YGb2PmalPp10s16liXKx51GCAVHZBOFARvE66vDa+U8WMpsYa12eKJYUgZg6Tl70qnjgdvF66vvUlSp8GShxEt7jTPlA5vD33k3cz7Xps+Ur3zbx+JasJp4zncjc9ggCBeffVVuyNU4k2Uug4PHIW6GIYnsDPfpL21ueJRUk2p28iLn9roSZCyhkoN0iyNFZcuqStdOVJKTrm45yfWkLqNiN7V2WAvwwgUxlV532rdS2rV07pMcB+njedwN4onIIj777/f7gjnSawhXXmLdPnVkV2Br3YjqefPpWbp0csWb2qkSD1/FjiPJhL1WkhX3Sldenl0csWjWpdKV90hNY1w+2zYWrrqLqlus6jEgkN4vFKnG6UOAyM7py05JfCBU+teXGGvunPieA73YpIDEMTixYvtjnBBHq/UprfUtKO082tpz1qprOTCbes2l1pmBc7h4Z5OkfMmSe37S6mdpZ150t71wU9eb9AqcIJ7ozbsqF2MxEukTj8O9OHOPGn/d5Kv/Px2hiE1bBto1yCNvq4uDENqkRn4+9q1JvBVUnThtrUaBt73mqZLCfF3EV5cBKeO53AniifApWo1kNr3k9plB87NKdwfKKIMT+AS0CmNOd/GKimNpY7XBQqp44elov2BIsrwBK7gldKYnTSr1EsNfPmuk4oOBr58ZYFzyGpfGjiKyhX1qq/k2oEjSZdfLZ08Kh3bJ5UWSzKkGrWllKZSMle3BBBFFE+AyxmewLQnLj0efR6vlNIo8IXo8iRIdZoGvoBzGUbgQ6JL6tmdBEB1wzlPQBDcUA8AAPdjPIeVKJ6AIGbNmmV3BAAAUEWM57AS0/ZskJlykdfktfF1m9e3MIhLXvupp57SyJEj7XlxAABgCcZzWIniyQYvtHff9aKHdbc7AQAAAGAvpu0BAAAAgAkUT0AQr7zyit0RAABAFTGew0oUT0AQGRkZdkcAAABVxHgOK1E8AUFkZ2fbHQEAAFQR4zmsRPEEAAAAACZQPAEAAACACVyqHNVShw4dwrZ56qmnTLUDAAD2YDxHrHHkCQji6aeftjsCAACoIsZzWIniCQAAAABMoHgCAAAAABMongAAAADABIonAAAAADCB4gkAAAAATKB4AgAAAAATKJ6ibMeOHerfv786duyojIwMPfbYY3ZHAgAAQBxavHixMjIy1LZtW913330qLy+3O1JYDzzwgFq0aKGEBHfcfpbiKcoSEhI0efJkrV+/XqtXr9bSpUv1j3/8w+5YAAAAiCM+n0/33XefZs+erU2bNunYsWN655137I4V1ogRI7RixQq7Y5hG8RRlzZo1U/fu3SVJSUlJ6tq1q7Zv325zKgAAAMST5cuXKzU1Venp6ZKke++9V3PnzrU5VXjXXHONmjZtancM0yieYujw4cP68MMPNXDgQLujAAAAII7s3LlTLVu2rPg5LS1NO3bssDFRfHLH5MI4cOrUKQ0fPlwPPPCAOnToYHccAAAA2OxUaZnemv2pTpacqrT8/70194Lf9+/dTZ3aXX7Bdfn9/uiEvIAvVq7VijXfnbf8Qrkb1EvRz4cOlGEYMcsXTRx5ioHy8nLddtttysrK0kMPPWR3HAAAADhAUmKCOrRJ0579h7Rn/6GK5ed+v2f/IZWWlalDm7Sg62rZsmWlI03bt29XixYtopI7K72tCo4WmsrdNeOKuCmcJIqnmBg1apRSUlL0wgsv2B0FAAAADtL7yk66tF6dsO1uvPZqJXi9QR/v3r27du7cqW+//VaS9Oabb2rYsGGW5TxbrUtqaMA1V4Zt1zotVRlXtIpKBrtQPEXZF198oRkzZmjFihXq2rWrsrKy9Oc//9nuWAAAAHCAhASvftzvqpBtrmjVQu1btwzZxuv16o033tDw4cPVpk0b1a5dW7fffruVUSu5umuGGjWoG/RxQ9KN/a8Oe9Rp9OjRatGihcrLy9WiRQuNHTvW4qTWMvyxnCCJ8/j9/rg6lAkAAIDI+P1+vf7+P7Vl++7zHjMMQ+PvvllNGjWwIVloGzZv11/nLLjgYz0zO2jYDX1jnCj6OPJko+MnTmrqjDnatHWX3VEAAABgE8Mwgh6l+VFWR0cWTpLUvnVLtbv8/POqkpMSNbBPdxsSRZ+ji6enn35ahmFo7dq1Gjx4sGrXrq1mzZrpueeekyR9+umn6tatm2rWrKmuXbtq6dKlNieOzOfL12j/wQKl1LrE7igAAACwUWrjS9WjS/tKy2okJ2ngNc4tQgzD0OB+V8lzTtF3ba9uSqlV06ZU0eXo4um0ESNG6Nprr624R9IjjzyiCRMm6Ne//rUeeeQRzZ49W36/X0OGDFFhYaHdcU05fuKklq1ap84dWjv20wQAAADEznV9eig5KbHi5wG9r1StmjVsTBRek0YN9KOuHSt+blAvRb2v7GRjouhy9DlPTz/9tCZOnKhXX31VY8aMkSSVlJSoSZMmOnHihL7//nu1atVKkvTvf/9b/fv315w5c3TzzTdb8voTJr9myXoAAAAAONekR0eZaueKm+T++Mc/rvg+OTlZrVu3Vnl5eUXhJKnixrPcSRkAAABANLiieGrQoPK0tqSkJNWoUeO8ZZJ08uRJy17XbAUaqQW5Xyn3//I0/p7hTNkDAABAJfsOFqjxpfVcdUXm8nKfCo4WqmGIy5fHA1cUT3aJ9rS9KTPmRHX9AAAAAMIze9DEFReMAAAAAAC7ceQpBKun7R0/cVKTp7+nDq1b6rYhAyxdNwAAAIDo4shTDH2+fI1KT5Wqf69udkcBAAAAECFHX6o83nywYIlKTpXqP27qb3cUAAAAABGieIoxn88nj4cDfgAAAIDbUDwBAAAAgAkcAgEAAAAAEyieAAAAAMAEiicAAAAAMIHiCQAAAABMoHgCAAAAABMongAAAADABIonAAAAADCB4gkAAAAATKB4AgAAAAATKJ4AAAAAwASKJwAAAAAwgeIJAAAAAEygeAIAAAAAEyieAAAAAMAEiicAAAAAMIHiCQAAAABMoHgCAAAAABMongAAAADABIonAAAAADCB4gkAAAAATKB4AgAAAAATKJ4AAAAAwASKJwAAAAAwgeIJAAAAAEygeAIAAAAAEyieAAAAAMAEiicAAAAAMOH/A+XeITK8mLz2AAAAAElFTkSuQmCC\n", 611 | "text/plain": [ 612 | "
" 613 | ] 614 | }, 615 | "execution_count": 29, 616 | "metadata": {}, 617 | "output_type": "execute_result" 618 | } 619 | ], 620 | "source": [ 621 | "# Create Deutsch-Jozsa algorithm\n", 622 | "dj = DeutschJozsa(oracle=constant_oracle, quantum_instance=quantum_instance)\n", 623 | "# Construct the circuit and draw the result\n", 624 | "dj_circuit = dj.construct_circuit(measurement=True)\n", 625 | "dj_circuit.draw()\n" 626 | ] 627 | }, 628 | { 629 | "cell_type": "code", 630 | "execution_count": 30, 631 | "metadata": {}, 632 | "outputs": [ 633 | { 634 | "name": "stdout", 635 | "output_type": "stream", 636 | "text": [ 637 | "{'measurement': {'00': 1024}, 'result': 'constant'}\n" 638 | ] 639 | } 640 | ], 641 | "source": [ 642 | "# Run the algorithm on the quantum instance\n", 643 | "results = dj.run(quantum_instance)\n", 644 | "# Print the results that determines constant or balanced\n", 645 | "print(results)\n" 646 | ] 647 | }, 648 | { 649 | "cell_type": "code", 650 | "execution_count": 31, 651 | "metadata": {}, 652 | "outputs": [], 653 | "source": [ 654 | "# Create the expression for secret value s: \n", 655 | "# (This ties x1=01, x2=10 XOR with s=11)\n", 656 | "s = '0110'\n", 657 | "\n", 658 | "# Create the Truth Table Oracle from the expression\n", 659 | "oracle_simon = TruthTableOracle(s) \n" 660 | ] 661 | }, 662 | { 663 | "cell_type": "code", 664 | "execution_count": 32, 665 | "metadata": {}, 666 | "outputs": [ 667 | { 668 | "data": { 669 | "image/png": "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\n", 670 | "text/plain": [ 671 | "
" 672 | ] 673 | }, 674 | "execution_count": 32, 675 | "metadata": {}, 676 | "output_type": "execute_result" 677 | } 678 | ], 679 | "source": [ 680 | "# Create Simon algorithm\n", 681 | "simon = Simon(oracle=oracle_simon, quantum_instance=quantum_instance)\n", 682 | "simon_circuit = simon.construct_circuit(measurement=True)\n", 683 | "simon_circuit.draw()\n" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": 33, 689 | "metadata": {}, 690 | "outputs": [ 691 | { 692 | "name": "stdout", 693 | "output_type": "stream", 694 | "text": [ 695 | "Secret string s = 11\n" 696 | ] 697 | } 698 | ], 699 | "source": [ 700 | "# Run the Simon algorithm to determine s, \n", 701 | "# where x1 XOR s = x2\n", 702 | "results = simon.run(quantum_instance)\n", 703 | "print('Secret string s = ', results['result'])\n" 704 | ] 705 | }, 706 | { 707 | "cell_type": "code", 708 | "execution_count": null, 709 | "metadata": {}, 710 | "outputs": [], 711 | "source": [] 712 | } 713 | ], 714 | "metadata": { 715 | "kernelspec": { 716 | "display_name": "Python 3", 717 | "language": "python", 718 | "name": "python3" 719 | }, 720 | "language_info": { 721 | "codemirror_mode": { 722 | "name": "ipython", 723 | "version": 3 724 | }, 725 | "file_extension": ".py", 726 | "mimetype": "text/x-python", 727 | "name": "python", 728 | "nbconvert_exporter": "python", 729 | "pygments_lexer": "ipython3", 730 | "version": "3.7.8" 731 | } 732 | }, 733 | "nbformat": 4, 734 | "nbformat_minor": 4 735 | } 736 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Packt 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # Learn Quantum Computing with Python and IBM Quantum Experience 5 | 6 | Learn Quantum Computing with Python and IBM Quantum Experience 7 | 8 | This is the code repository for [Learn Quantum Computing with Python and IBM Quantum Experience](https://www.packtpub.com/programming/learn-quantum-computing-with-python-and-ibm-q-experience?utm_source=github&utm_medium=repository&utm_campaign=9781838981006), published by Packt. 9 | 10 | **A hands-on introduction to quantum computing and writing your own quantum programs with Python** 11 | 12 | ## What is this book about? 13 | IBM Quantum Experience is a platform that enables developers to learn the basics of quantum computing by allowing them to run experiments on a quantum computing simulator and a real device. This book will explain the basic principles of quantum mechanics, the principles involved in quantum computing, and the implementation of quantum algorithms and experiments on IBM's quantum processors. 14 | 15 | This book covers the following exciting features: 16 | Explore quantum computational principles such as superposition and quantum entanglement 17 | Become familiar with the contents and layout of the IBM Quantum Experience 18 | Understand quantum gates and how they operate on qubits 19 | Discover the quantum information science kit and its elements such as Terra and Aer 20 | Get to grips with quantum algorithms such as Bell State, Deutsch-Jozsa, Grover’s algorithm, and Shor's algorithm 21 | How to create and visualize a quantum circuit 22 | 23 | If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1838981004) today! 24 | 25 | https://www.packtpub.com/ 27 | 28 | ## Instructions and Navigations 29 | All of the code is organized into folders. For example, Chapter02. 30 | 31 | The code will look like the following: 32 | ``` 33 | param_t1 = t1*1.2 34 | param_a = 1.0 35 | param_b = 0.0 36 | ``` 37 | 38 | **Following is what you need for this book:** 39 | This book is for Python developers who are looking to learn quantum computing and put their knowledge to use in practical situations with the help of IBM Quantum Experience. Some background in computer science and high-school-level physics and math is required. 40 | 41 | With the following software and hardware list you can run all code files present in the book (Chapter 1-14). 42 | ### Software and Hardware List 43 | | Chapter | Software required | OS required | 44 | | -------- | ------------------------------------ | ----------------------------------- | 45 | | 1 | Latest browser | Windows, Mac OS X, and Linux (Any) | 46 | 47 | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://static.packt-cdn.com/downloads/9781838981006_ColorImages.pdf). 48 | 49 | ## Errata 50 | The block of code available on page 65 is incorrect and should be as follows: 51 | ``` 52 | from qiskit.visualization import plot_bloch_multivector 53 | qc = QuantumCircuit(1) 54 | ... 55 | ... 56 | ... 57 | #Display the Bloch sphere 58 | plot_bloch_multivector(stateVectorResult) 59 | ``` 60 | * Page 9 (paragraph 2, line 1): **As described in the shaded bar area, where the error rate range is illustrated by Singlequbit 61 | U3 error rate,** _should be_ **As described in the shaded bar area, where the error rate range is illustrated by Singlequbit 62 | U2 error rate,** 63 | 64 | ### Code in Action 65 | Please visit the following link to check the CiA videos: 66 | https://bit.ly/35o5M80 67 | 68 | ### Related products 69 | * Dancing with Qubits [[Packt]](https://www.packtpub.com/product/dancing-with-qubits/9781838827366?utm_source=github&utm_medium=repository&utm_campaign=9781838827366) [[Amazon]](https://www.amazon.com/dp/1838827366) 70 | 71 | * Quantum Computing and Blockchain in Business [[Packt]](https://www.packtpub.com/product/quantum-computing-and-blockchain-in-business/9781838647766?utm_source=github&utm_medium=repository&utm_campaign=9781838647766) [[Amazon]](https://www.amazon.com/dp/1838647767) 72 | 73 | ## Get to Know the Author 74 | **Robert Loredo** is the IBM Quantum Global Technical Ambassador lead with over 20 years' experience in software architecture and engineering. He is also a Qiskit Advocate and Master Inventor who holds over 160 patents and has presented various workshops, lectures, and articles covering quantum computing, artificial intelligence, and bioinformatics world-wide. As an adjunct professor, he has taught cloud computing and software engineering at the Florida International University School of Computer Science. He holds both a bachelor's and a master's degree in Computer and Electrical Engineering from the University of Miami and is currently pursuing his PhD in Computer Science, specializing in Machine Learning and Neuroscience, at Florida International University. 75 | 76 | 77 | ### Download a free PDF 78 | 79 | If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.
Simply click on the link to claim your free PDF. 80 |

https://packt.link/free-ebook/9781838981006

--------------------------------------------------------------------------------