From b89377ccbdba1791d0b2be1b7a46614874967913 Mon Sep 17 00:00:00 2001 From: Sakibul Islam Sazzad <66297655+SakibulIslamSazzad@users.noreply.github.com> Date: Sat, 11 Jun 2022 02:56:49 +0600 Subject: [PATCH] Quantum Fundamentals On this notebook fundamentals of quantum computer is described and made a quantum game to check if the inserted circuit is reversible or not! --- Quantum_Circuit_ (2).ipynb | 990 +++++++++++++++++++++++++++++++++++++ 1 file changed, 990 insertions(+) create mode 100644 Quantum_Circuit_ (2).ipynb diff --git a/Quantum_Circuit_ (2).ipynb b/Quantum_Circuit_ (2).ipynb new file mode 100644 index 0000000..58f2ffb --- /dev/null +++ b/Quantum_Circuit_ (2).ipynb @@ -0,0 +1,990 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "fmw96qCwTzBr" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":219: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n" + ] + } + ], + "source": [ + "#Quantum Circuit written by Sakibul Islam Sazzad\n", + "#Graduate Research Fellow\n", + "#Bangladeh Reference Institute for Chemical Measurements\n", + "#https://sites.google.com/view/sakibulislamsazzad/\n", + "\n", + "\n", + "import numpy as np\n", + "# Importing standard Qiskit libraries\n", + "from qiskit import QuantumCircuit, transpile, Aer, IBMQ, assemble, execute\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "#from ibm_quantum_widgets import *" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0kjGBAnITzB3" + }, + "source": [ + "Around 40 years ago Richard Feynman quoted \"Nature isn't classical, damn it....\" Since then researchers were exploring trying to harness the quantum power of nature using quantum simulations. Thats why we need a quantum computer, like existing computer laptop, mobile etc. Only difference is that we need quantum gates to create a quantum computers. These quantum gates will operate on ***qubits***, unit of quantum computing. \n", + "\n", + "Quantum gates are basically unitary operators, the conditions of being unitary operator is $UU^{\\dagger}= U^{\\dagger}U=I$, here $U$ is a unitary matrix and $U^{\\dagger}$ is its transpose conjugate, $I$ is the identity matrix. \n", + "\n", + "**Example:** Lets for an example at this moment we deal with $Pauli Y$ gate, it is famously known as $\\sigma_{y}$ gate. Its matrix representation is like this,\n", + "$\n", + "\\left[\n", + "\\begin{matrix}\n", + "0 & -i \\\\\n", + "i & 0\n", + "\\end{matrix}\n", + "\\right]\n", + "$\n", + "As before mentioned, to check its unitary property we can **transpose** the matrix and convert the **conjugate** of complex number.. Transpose is done by swap rows into columns and vice versa. Hence $\\sigma_{y}^{T} = \\left[\\begin{matrix} \n", + "0 & i\\\\\n", + "-i & 0\n", + "\\end{matrix}\n", + "\\right]$ \n", + "\n", + "Now conjugate of the $\\sigma_{y}^{T}$ will convert it into $\\sigma_{y}^{\\dagger}= \\left[\\begin{matrix}\n", + "0 & -i\\\\\n", + "i & 0\n", + "\\end{matrix}\n", + "\\right]$. Now multiply $\\sigma_{y}\\sigma_{y}^{\\dagger}$, you will find the its equivalent to $I = \\left[\\begin{matrix}\n", + "1 & 0\\\\\n", + "0 & 1\n", + "\\end{matrix}\n", + "\\right]$\n", + "\n", + "Another special property of Qunatum gates are **Reversible**, that means $initialstates\\rightarrow quantumgates \\rightarrow outputstates \\rightarrow quantumgates \\rightarrow initialstates$. We will first prove this **reversible** property by **Hadamard** gate, basically it is known a H-gate also. Using H gates we can show the superposition property of a qubit." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "NjVGD49MTzB7", + "outputId": "e10ab821-3f05-4571-db7e-ad9554353a25" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAACzklEQVR4nO3csWtaURzF8aOpmCFLghTB0sEapFgMaMlqhLaYqaWdMmQIASGEFuKaulkHces/kC1DHo92celQ35Ih2EDESegSEoQ6ZBFSKNFObZG28ATLvZ6ez3gj1x98c1/ME15gNBqNIBSCpgeQ6VFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJ5JbpAUxxW8DllZn3ji0Czx9Of9//NublFfD5i+kppkuXWSKKSUQxiSgmEcUkophEFJOIYhKxLuZwOES9Xsfy8jLm5+exsrICz/OQTCZRLBaNzeVU1nDyruJ73QTr7gBtb2/DdV2Uy2Vks1kcHx9jY2MD/X4fpVLJ9HhWsyrm4eEhDg4O0Gw2kcvlAAD5fB6np6dwXReZTMbwhHaz6jJbrVZRKBR+hvwhkUggFAohnU4bmmw2WHMyLy4u0Ol0sLe399vPzs/PkUqlEA6HDUz2y8n7N/jUqI+tffs6wN0HjwxNNM6qmAAQjUbH1q+vr+F5HtbX133tEwgEfL3uxf5H3Lm/NtGMq0/3sfrs9diaU5lsDwDwvCZePcn7eu0kT8Oz5jIbiUQAAN1ud2y9Vquh1+shm82aGGumWHMy4/E40uk0qtUqlpaWEIvF4DgOGo0GAPiO6fc3+e0Hc99n5nJrcCrTf/6kNSczGAzi6OgIqVQKOzs72NraQiQSwe7uLubm5vThx4eA7Y8o3dzcxNnZGdrt9lT3NXky790GXj6e/r7WnMy/abVa+nvpk9UxB4MBut2ubhb4ZM0HoD9ZWFjAzc2N6TFmhtUnUyajmEQUk4hiElFMIopJRDGJWP1/5r8UW+R7b+vvzYp/uswSUUwiiklEMYkoJhHFJKKYRBSTiGISUUwiiklEMYkoJhHFJKKYRBSTiGISUUwi3wHdC54Fc5QnQAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#At first we will make define a 1 qubit quantum circuit\n", + "# we can follow this code to implement it\n", + "qc = QuantumCircuit(1)\n", + "#we already defined a qubit in 'qc' variable\n", + "#now we can employ an H gate in here\n", + "qc.h(0) \n", + "#note that q.h(0) is written, here 0 means first qubit\n", + "#if you deal with more than 1 qubit we will start with 0, 1 like this\n", + "#now we will draw the circuit\n", + "#we will find that in qubit 0 H-gate is employed\n", + "qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hOGKCEDKTzCA" + }, + "source": [ + "Now we will check the unitary matrix of H-gate by applying **unitary simulation**. This can be done by employing **unitary_simulator**. Remember whenever you will run a simulator, there are 3 steps to be followed.\n", + "1. First get the simulator (Qasm, Unitary, Statevector, Pulse whatever it is)\n", + "2. Then execute the simulator by **execute** command\n", + "3. Get the result\n", + "\n", + "Now we will check the *reversible* property of a quantum gate using both unitary matrix and qasm simulator. At first we will check the unitary matrix of H gate. We will find its matrix\n", + "$\n", + "\\left[\n", + "\\begin{matrix}\n", + "\\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}}\\\\\n", + "\\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}}\n", + "\\end{matrix}\n", + "\\right]\n", + "$\n", + "\n", + "after end of unitary simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "CJeRS4HeTzCD", + "outputId": "26401a95-c813-4d17-b3bb-666dc2a30b11" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Operator([[ 0.707+0.j, 0.707-0.j],\n", + " [ 0.707+0.j, -0.707+0.j]],\n", + " input_dims=(2,), output_dims=(2,))\n" + ] + } + ], + "source": [ + "#wa want to see the matrices of H-gate \n", + "#to do this we need unitary simulation\n", + "#this is done by get unitary property\n", + "\n", + "backend = Aer.get_backend('unitary_simulator')\n", + "job = execute(qc, backend)\n", + "result = job.result()\n", + "\n", + "# Show the results\n", + "print(result.get_unitary(qc, decimals=3))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "HL5iFqQwTzCH", + "outputId": "7b42aadf-5743-4cd8-e2f9-5576150284f5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[AerSimulator('aer_simulator'),\n", + " AerSimulator('aer_simulator_statevector'),\n", + " AerSimulator('aer_simulator_density_matrix'),\n", + " AerSimulator('aer_simulator_stabilizer'),\n", + " AerSimulator('aer_simulator_matrix_product_state'),\n", + " AerSimulator('aer_simulator_extended_stabilizer'),\n", + " AerSimulator('aer_simulator_unitary'),\n", + " AerSimulator('aer_simulator_superop'),\n", + " QasmSimulator('qasm_simulator'),\n", + " StatevectorSimulator('statevector_simulator'),\n", + " UnitarySimulator('unitary_simulator'),\n", + " PulseSimulator('pulse_simulator')]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Aer.backends()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TkMMBlHtTzCJ" + }, + "source": [ + "As before said *reversible* circuit means, applying a quantum logic gate twice into a state will give us the initital state. We started with 0 state now, if I apply H-gate twice we will see that, after end of twice H-gate we are getting 0. We will check that using *qasm_simulator*. To implement *qasm_simulator* we need a measurement, so we will add a **measure** after applying 2 H-gate.\n", + "In qiskit *shots* means how many times we will measure, here we did the measure 1024 times. And we will find the histogram plot for 0 state 1, that means we will always get 1 after applying 2 H-gates." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "a14LXw1STzCL", + "outputId": "a0a851bc-5f36-46bc-a7b4-3691859c38bd" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAABOCAYAAACngR3fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAADDElEQVR4nO3dP0tbcQCF4ROt6OCihCKkdLCKlJQIpnSNgbbo1NJODg4iCCIt6Grd0gzi1i/g5mAI7ZKlQ5PFQVJBcQp0EUWog4tgoaid2hJaJVHD+RnfZ7ya5Ayv95o/kMjZ2dmZAJMW9wDcbgQIKwKEFQHCigBhRYCwIkBYESCsCBBWBAgrAoQVAcKKAGFFgLAiQFgRIKwIEFYECCsChBUBwooAYUWAsCJAWBEgrAgQVgQIKwKE1R33AJd8Wdo79Dx2rEt69fhyt3Xtvsrmi9zaAPcOpW/f3Svqd1N3n4dLMKwIEFYECCsChBUBwooAYUWAsCJAWAUX4OnpqZaWltTf36+Ojg4NDg6qVCppYGBAU1NTtl25zLDWP2ZqPh6K0HcH907I5OSk8vm8FhYWlEwmtba2prGxMR0cHGhubs49D9csqABXVla0vLysYrGoVColSUqn09rY2FA+n9fQ0JB5Ia5bUJfgbDarkZGRP/H91tfXp7a2NiUSCdMyNEowZ8Dd3V1tb29rdnb2n5/t7OwoHo+rvb3dsOyv9U/v9bWwVHXs548j3X/01LSoNiHvDipASerp6ak6fnx8rFKppNHR0ZruJxKJ1PR7r+e/6N7D4bo2Pnkxrycv31Udy2Xquw9JKpWKevs8XfftJN/uejfX+g1wwVyCo9GoJKlSqVQdX1xc1P7+vpLJpGMWGiyYM2Bvb68SiYSy2ay6u7sVi8WUy+VUKBQkqeYAa/3L+/DZ97m6VGpYuczlviPStfsqmy8SzBmwpaVFq6urisfjmp6e1sTEhKLRqGZmZtTa2soTkCYVCf3rWsfHx7W5uamtra1rvV/nGfDBXenNs8vd1rX7KpsvEswZ8Dzlcpn//5pY0AEeHR2pUqnwAnQTC+ZJyP90dnbq5OTEPQMNFPQZEM2PAGFFgLAiQFgRIKwIEFYECKugXwdspFjXzXxs1+5GPW7w7wWjuXEJhhUBwooAYUWAsCJAWBEgrAgQVgQIKwKEFQHCigBhRYCwIkBYESCsCBBWBAgrAoQVAcLqFy2jxxW3vFenAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.h(0)\n", + "qc.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "SoaYBkxQTzCN", + "outputId": "028a48f9-258c-4b6e-8c2f-04dea3047e5b" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_60/2155766716.py:3: DeprecationWarning: The QuantumCircuit.__add__() method is being deprecated.Use the compose() method which is more flexible w.r.t circuit register compatibility.\n", + " qc = qc+meas\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meas = QuantumCircuit(1,1)\n", + "meas.measure(0,0)\n", + "qc = qc+meas\n", + "qc.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "l6d91zDTTzCQ", + "outputId": "043cf34f-02a9-4b08-9c76-8b197f55a4e5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'0': 1024}\n" + ] + } + ], + "source": [ + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "job_sim = execute(qc, backend_sim, shots=1024)\n", + "result_sim = job_sim.result()\n", + "\n", + "counts = result_sim.get_counts(qc)\n", + "print(counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "kUV-QwFDTzCS", + "outputId": "69711306-be6c-4270-a045-df39240fc1d4" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.visualization import plot_histogram\n", + "plot_histogram(counts)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "57Ooyhn6TzCV" + }, + "source": [ + "Now lets be familiar with some other single qubits quantum gates, and we will check their state changeing properties by bloch-sphere. In this tutorial we will check the mostly used quantum gates like **Pauli X, Pauli Z gate, Pauli X gate**.\n", + "\n", + "**Pauli X gate:**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Reversibility Game\n", + "To play this you have to write a circuit, in quantum any circuit resulted in a martix. We are going to check if the initial of the circuit and re-arranging the circuit provide us the same results? " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def reversibility(circ1):\n", + " #here circ1 is the main circuit that you want to put in\n", + " #it could be something like this\n", + " # circ1= QuantumCircuit(num_qubits)\n", + " #make your own circuit\n", + " backend1 = Aer.get_backend('unitary_simulator')\n", + " job1 = execute(circ1, backend)\n", + " result1 = job1.result()\n", + "\n", + " # Show the results\n", + " print(result.get_unitary(qc, decimals=3))\n", + " \n", + " #now inverse the circuit\n", + " circ2 = circ1.inverse()\n", + " \n", + " #now get the results\n", + " backend2 = Aer.get_backend('unitary_simulator')\n", + " job2 = execute(circ2, backend)\n", + " result2 = job2.result()\n", + " \n", + " if result1==result2:\n", + " \n", + " decision1 = print(\"circuit is reversible\")\n", + " else:\n", + " decision2 = print(\"circuit isn't reversible\")\n", + " \n", + " return decision1, decision2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "YmXGyG2iTzCW", + "outputId": "4391adda-f3f7-4657-dd70-d06634d83a71" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAADjUlEQVR4nO3cQUhbdxzA8e//vQSlxMMkB0G2DlGEhiaggzEGVbcdvIyWjlhkC+IEU5fd1na9C6FYux56KoPOjVIHWrtDiT308LLbQGwjMlgOBkQQetgoBoTFvNdD0SLbIJaU//O33wdyeYF/fvDl//LyAs8EQRCgRHBsD6CaR2MKojEF0ZiCaExBNKYgGlMQjSmIxhREYwqiMQXRmIJoTEE0piAaUxCNKYjGFERjCqIxBdGYgmhMQTSmIBpTEI0piMYURGMKojEFidgewJZv/vid0s6Olc9OtbVxo/dU09f938Ys7ezw619/2h6jqfQ0K4jGFERjCqIxBdGYgmhMQTSmIBpTkNDF9H2f2dlZenp6aG1tJZVKUSwW6e3tZXJy0tpcQa1G7eLX1G9/f+h4/cEv1L4YI6hWLU32SuhiTkxMMD09TTabZXl5mZGREUZHR9nY2KC/v9/aXCYaJXL1Mv7DAv6TpwAElQr+nR9xr1zCxGLWZtsXqtt58/PzzM3N4XkeAwMDAAwNDbG6usrS0hJ9fX1W5zPvnsT5coz67E3MrZvsXbuOc/ZTnORpq3PtC9XOzOfzDA8PH4Tc193dTTQaJZlMWprsFefcWcw7b7OXzYHr4oxlbI90IDQxt7a2WF9fJ51O/+O9zc1NEokELS0tFiY7zBiDSZ6G589xPv4IE43aHulAqGICdHR0HDq+u7tLsVhs+BRrjGno5Xnea80ZVCr4937GuZDGv3uP4NmzI6/heV7Dcx5FaGLG43EAyuXyoeMzMzNsb29bvfjZF/xde/k9ef4c7sQ45sMPqF//jsD3bY8GhOgCqKuri2QyST6fp729nc7OThYXFykUCgANx2z0uY6frPx25P8z/Ts/YCIRnMznALhfXWQvm8O//wA3/VnD6wwODvL4DTx/MjQ703EcFhYWSCQSTE1NMT4+TjweJ5fL4bqu9Ysf/8lT/MIj3KtXMJGXe8CcOIH77SX8n+4SVCpW5wMwYX9EaSaToVQqsba21tR1X2dnNsuZt9p5/N77TV83NDvzv6ysrITi+/I4CHXMarVKuVy2frPguAjNBdC/icVi1Ot122McG6HemepoNKYgGlMQjSmIxhREYwqiMQUJ9e/MNynV1ibus0N/b1Y1Tk+zgmhMQTSmIBpTEI0piMYURGMKojEF0ZiCaExBNKYgGlMQjSmIxhREYwqiMQXRmIJoTEFeALS14W1518x6AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circ_x = QuantumCircuit(1)\n", + "circ_x.x(0)\n", + "circ_x.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i21frZwpTzCX" + }, + "source": [ + "It is important to note that, qubit states are initialised to 0 always. We can change the initial state, we will do that later. Now lets focus on role of Pauli X gate. Basically it is analogous to **classical not gate**, a NOT gate flips the bit state. Same thing is done by the **Pauli X/ $\\sigma_{x}$ gate**, it flips the qubit state $|0\\rangle$ to $|1\\rangle$. lets check that using qasm simulator. Remember whenever you want to run qasm simulator always add a measure to the circuit, otherwise it wont count. Can you guess why it cant count without measurement?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "i59-Ws8LTzCY", + "outputId": "bb330de0-6940-41a5-e4f0-aa4db7ca7042" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_60/1525685599.py:3: DeprecationWarning: The QuantumCircuit.__add__() method is being deprecated.Use the compose() method which is more flexible w.r.t circuit register compatibility.\n", + " circ = circ_x+meas\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "meas = QuantumCircuit(1,1)\n", + "meas.measure(0,0)\n", + "circ = circ_x+meas\n", + "circ.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "AmRKrPLUTzCa", + "outputId": "e83064eb-52be-4510-8b91-5ee3a830166e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'1': 1024}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qa_sim = Aer.get_backend('qasm_simulator')\n", + "job_qa = execute(circ, qa_sim, shots =1024)\n", + "result_qa = job_qa.result()\n", + "\n", + "count_qa = result_qa.get_counts(circ)\n", + "print(count_qa)\n", + "\n", + "from qiskit.visualization import plot_histogram\n", + "plot_histogram(count_qa)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bokNGnmwTzCc" + }, + "source": [ + "Now we will check the rotation of **Pauli X** gate from state $|0\\rangle$ to $|1\\rangle$ in bloch shpere. At first we will check how does $|0\\rangle$ state looks in bloch sphere" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "d9WJ5WJ_TzCe", + "outputId": "21eb4021-4227-4856-cd75-8cf020a0d911" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.visualization import plot_bloch_vector\n", + "%matplotlib inline\n", + "\n", + "plot_bloch_vector([0,0,1], title= \"0 State\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F_C9CMWDTzCf" + }, + "source": [ + "So after applying X gate to this $|0\\rangle$ state, it will flip to $|1\\rangle$ state, basically Pauli X gate is $\\pi$ rotation around X axis. So lets check how does it will look in bloch shpere of $|1\\rangle$ state. Remember we are just doing bruce-force to show you $|0\\rangle$ state and $|1\\rangle$ state. We havent yet applied bloch sphere to our quantum circuit. We will do that just after it" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "B5igNp2MTzCg", + "outputId": "343b4372-fe6c-4bc1-841a-70df1407c50d" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.visualization import plot_bloch_vector\n", + "%matplotlib inline\n", + "\n", + "plot_bloch_vector([0,0,-1], title = \"|1> state\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0FdzAbQiTzCi" + }, + "source": [ + "Now we will apply Bloch Sphere in our quantum circuit, to do this we have to import *plot_state_qsphere*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "vA0Q9ZeTTzCj" + }, + "outputs": [], + "source": [ + "from qiskit.visualization import plot_state_qsphere\n", + "\n", + "back_x = Aer.get_backend('statevector_simulator')\n", + "result_x = execute(circ_x, back_x).result()\n", + "state_x = result_x.get_statevector(circ_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "SIqDP-5fTzCj", + "outputId": "93ba2fa2-f14a-4435-dab6-bbd365a4b4ff" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_state_qsphere(state_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kaYp2sJVTzCl" + }, + "source": [ + "Have you noticed that we used used *statevector_simulator* to check the Bloch Sphere. And you are carefully check the color code of phase you will find that it is in phase 0. Reason behind is simple, **Pauli X** gate only change the bit state, that's why it stays in 0. But **Pauli Z** gate do the phase changes. Cool, now we have learnt all the necessary *Aer.backend()* simulalor. So lets check about **Pauli Z** gate and we will learn that it changes phase." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v6sirkRVTzCl" + }, + "source": [ + "**Pauli Z gate**" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "OxgdBlU9TzCm", + "outputId": "e195eb3a-e8ae-43dd-d7fa-4dc85cfdc215" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAADXUlEQVR4nO3cv0sbYRzH8c+dShQMWBUU3MQfmLQJmEK3alCKtNDSFgcHySDo1B8otBAILS1kSLUO/QccSqVUMnRwsnixIFTEIoZCbxTBQWmHCIpyuU4KaSy92Mjz+O3nBbdcSO4Lb+655AJnuK7rgkQwVQ9A5cOYgjCmIIwpCGMKwpiCMKYgjCkIYwrCmIIwpiCMKQhjCsKYgjCmIIwpCGMKwpiCMKYgjCkIYwrCmIIwpiCMKQhjCsKYgjCmIJWqB1Bl4vs3rOdySo4d9vsx1Rko++f+tzHXczks/fyheoyy4jIrCGMKwpiCMKYgjCkIYwrCmIIwpiDaxczn85icnER7ezuqq6sRDoeRyWTQ2dmJ0dFRdXNtZHF0+17xdusOjm7cRH4jq2y2Y9rdARoZGUE6nUYikUAkEsHy8jKGhoaws7OD8fFxZXOZVy7D/Jgu2OceHsKZeALU1cEIlv/2XKm0ijk7O4uZmRlYloWenh4AQDQaxdraGtLpNLq7uxVPWMiZmoZ7eIjK+FMYpvpFTquYyWQSAwMDJyGPtbW1oaqqCqFQSNFkxZy37+B+XUflm2kYNTWqxwGg0TVza2sL2WwWg4ODRa9tbm4iGAzC5/MpmKxYfukz8u8/oOJ5AkZTk+pxTmgVEwCam5sL9u/v7yOTyXheYg3D8LRZlnWmOfO2DefVa1Q8fggz0HWmz7Asy/OcpdAmZmNjIwDAtu2C/alUCtvb24hEIirGKuDu7sJ59hLm/bsw+6KqxymizTWztbUVoVAIyWQS9fX1aGlpwdzcHObn5wHAc0yvz3XsX/1S0v+Z7sEBnGcvYAS6YMaGPb/vNL29vVg4h+dPGjo91dK2bYyNjWFlZQUNDQ2IxWLw+/2Ix+PI5XKoKeMXjVJj5hc+wUlNAT4fcMryV/Hogeez9fqleixcveb52F5pc2YCQEdHBxYXFwv2DQ8PIxAIlDXkWZj9fTD7+5TO8DfaXDP/ZHV1VYvr5UWgdcy9vT3Ytq3dzQJdabXM/q62thaO46ge48LQ+syk0jCmIIwpCGMKwpiCMKYgjCmI1r8zz1PY7xd3bK1utNO/4TIrCGMKwpiCMKYgjCkIYwrCmIIwpiCMKQhjCsKYgjCmIIwpCGMKwpiCMKYgjCkIYwryCwDU1hL377lGAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circ_z = QuantumCircuit(1)\n", + "circ_z.z(0)\n", + "circ_z.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t4weYKiXTzCn" + }, + "source": [ + "Matrix of Pauli Z is $\\left[\n", + "\\begin{matrix}\n", + "1 & 0\\\\\n", + "0 & -1\n", + "\\end{matrix}\n", + "\\right]$. Do you know how to read qubit states from matrix? Lets learn it, check about first column $\\left[\n", + "\\begin{matrix}\n", + "1\\\\\n", + "0\n", + "\\end{matrix}\n", + "\\right]$, see this is $|0\\rangle$ state. This means **Pauli Z** gate has no effect on $|0|rangle$ state. Now if you look at second column, it is $\\left[\\begin{matrix}\n", + "0\\\\\n", + "-1\n", + "\\end{matrix}\n", + "\\right]$, see **Pauli Z** gate has changed the $|1\\rangle$ state to $-|1\\rangle$ state. That means **Pauli Z** gate changes phase of $|1\\rangle$ state only. Lets check that in bloch sphere. But before that we have to *initialize* qubit state to $|1\\rangle$" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "lSATdWtVTzCn", + "outputId": "1e2561dd-dc17-4841-a1f5-b5461d07596a" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circ_1 = QuantumCircuit(1)\n", + "initial_state = [0,1]\n", + "circ_1.initialize(initial_state, 0)\n", + "circ_1.z(0)\n", + "circ_1.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "-VAlTxaoTzCo", + "outputId": "6fb16c15-a306-4981-b7b6-afb23f68496f" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "backend = Aer.get_backend('statevector_simulator')\n", + "result = execute(circ_1, backend).result()\n", + "z_phase = result.get_statevector(circ_1)\n", + "\n", + "plot_state_qsphere(z_phase)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5HV19EkcTzCp" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "name": "Quantum Circuit .ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "045946c4e33a41cf81e120455d862c7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "0de24505b0e1400bb78bc3e402317fd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "21ffc679ec5d470ca394cacfd53f39d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_51f6bbb9f0f64ef6b954a5a111294597" + ], + "layout": "IPY_MODEL_d8bf5130d9e84c1a9bea3b26dee55e5f" + } + }, + "2810221f0607433c9547377918aea134": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3b6cb5e14dcf4c069c34ccfec62c6a5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3e3eb67c62e34a2dbbf40625d12f0e8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "43842e44b42b4c45aa8e37a6d17a1bbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "48d0dd3ca81f477e923ee91b0e9677cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_955c32ebc464407f843f145864db1b7c", + "style": "IPY_MODEL_3e3eb67c62e34a2dbbf40625d12f0e8c", + "value": "

Circuit Properties

" + } + }, + "51f6bbb9f0f64ef6b954a5a111294597": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_d156421d13fd43419f405223a8f59c00", + "style": "IPY_MODEL_5dbf43f26c6442c68352373697972ee1" + } + }, + "5dbf43f26c6442c68352373697972ee1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "701ba07a90fd4c22aa18f13fe64063d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_045946c4e33a41cf81e120455d862c7a", + "style": "IPY_MODEL_82f8325b680d469689af339887408c22", + "value": "
Status
" + } + }, + "768693d6f7ad479ebb025808ce293d7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "82f8325b680d469689af339887408c22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "8e5e5239cc5e45b881391d7277f26f01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_eac10f7372bb46d8af03b1b9d7dadeec", + "IPY_MODEL_9fd346fa52e8445ab6e054ebfedd55fb", + "IPY_MODEL_701ba07a90fd4c22aa18f13fe64063d3", + "IPY_MODEL_98ba8deeb8064dd488905617a89320c3", + "IPY_MODEL_d991f94b4146432682e5d72674990906" + ], + "layout": "IPY_MODEL_9bbf7a2d149c4c5e861142f0569f2430" + } + }, + "955c32ebc464407f843f145864db1b7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "98ba8deeb8064dd488905617a89320c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a2ba021dbe7345879492cff1454b803f", + "style": "IPY_MODEL_2810221f0607433c9547377918aea134", + "value": "
Queue
" + } + }, + "9bbf7a2d149c4c5e861142f0569f2430": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "9c1b1e3edad44733b2e7d09490a8dbc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "9fd346fa52e8445ab6e054ebfedd55fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_43842e44b42b4c45aa8e37a6d17a1bbe", + "style": "IPY_MODEL_3b6cb5e14dcf4c069c34ccfec62c6a5a", + "value": "
Backend
" + } + }, + "a2ba021dbe7345879492cff1454b803f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "d156421d13fd43419f405223a8f59c00": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "d8bf5130d9e84c1a9bea3b26dee55e5f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "d991f94b4146432682e5d72674990906": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9c1b1e3edad44733b2e7d09490a8dbc7", + "style": "IPY_MODEL_0de24505b0e1400bb78bc3e402317fd6", + "value": "
Message
" + } + }, + "eac10f7372bb46d8af03b1b9d7dadeec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ed710bb3b38d412fba9cbc80c0b488a5", + "style": "IPY_MODEL_768693d6f7ad479ebb025808ce293d7a", + "value": "
Job ID
" + } + }, + "ed710bb3b38d412fba9cbc80c0b488a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}