├── .gitignore ├── CONTRIBUTING.md ├── LICENSE ├── Qiskit Workshop.pdf ├── README.md ├── qiskit_workshop.ipynb ├── quantumteleport.py └── src ├── .DS_Store ├── badges ├── .DS_Store ├── begApplBadge.svg └── begTheoryBadge.svg ├── logos ├── .DS_Store ├── QCC.logo.png ├── epfl.png ├── harvard.png └── mit.png └── repoSim.gif /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Mac specific files 10 | .DS_Store 11 | **/.DS_Store 12 | 13 | # Distribution / packaging 14 | .Python 15 | build/ 16 | develop-eggs/ 17 | dist/ 18 | downloads/ 19 | eggs/ 20 | .eggs/ 21 | lib/ 22 | lib64/ 23 | parts/ 24 | sdist/ 25 | var/ 26 | wheels/ 27 | pip-wheel-metadata/ 28 | share/python-wheels/ 29 | *.egg-info/ 30 | .installed.cfg 31 | *.egg 32 | MANIFEST 33 | 34 | # PyInstaller 35 | # Usually these files are written by a python script from a template 36 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 37 | *.manifest 38 | *.spec 39 | 40 | # Installer logs 41 | pip-log.txt 42 | pip-delete-this-directory.txt 43 | 44 | # Unit test / coverage reports 45 | htmlcov/ 46 | .tox/ 47 | .nox/ 48 | .coverage 49 | .coverage.* 50 | .cache 51 | nosetests.xml 52 | coverage.xml 53 | *.cover 54 | *.py,cover 55 | .hypothesis/ 56 | .pytest_cache/ 57 | cover/ 58 | 59 | # Translations 60 | *.mo 61 | *.pot 62 | 63 | # Django stuff: 64 | *.log 65 | local_settings.py 66 | db.sqlite3 67 | db.sqlite3-journal 68 | 69 | # Flask stuff: 70 | instance/ 71 | .webassets-cache 72 | 73 | # Scrapy stuff: 74 | .scrapy 75 | 76 | # Sphinx documentation 77 | docs/_build/ 78 | 79 | # PyBuilder 80 | .pybuilder/ 81 | target/ 82 | 83 | # Jupyter Notebook 84 | .ipynb_checkpoints 85 | 86 | # IPython 87 | profile_default/ 88 | ipython_config.py 89 | 90 | # pyenv 91 | # For a library or package, you might want to ignore these files since the code is 92 | # intended to run in multiple environments; otherwise, check them in: 93 | # .python-version 94 | 95 | # pipenv 96 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 97 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 98 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 99 | # install all needed dependencies. 100 | #Pipfile.lock 101 | 102 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 103 | __pypackages__/ 104 | 105 | # Celery stuff 106 | celerybeat-schedule 107 | celerybeat.pid 108 | 109 | # SageMath parsed files 110 | *.sage.py 111 | 112 | # Environments 113 | .env 114 | .venv 115 | env/ 116 | venv/ 117 | ENV/ 118 | env.bak/ 119 | venv.bak/ 120 | 121 | # Spyder project settings 122 | .spyderproject 123 | .spyproject 124 | 125 | # Rope project settings 126 | .ropeproject 127 | 128 | # mkdocs documentation 129 | /site 130 | 131 | # mypy 132 | .mypy_cache/ 133 | .dmypy.json 134 | dmypy.json 135 | 136 | # Pyre type checker 137 | .pyre/ 138 | 139 | # pytype static type analyzer 140 | .pytype/ 141 | 142 | # Cython debug symbols 143 | cython_debug/ 144 | 145 | # static files generated from Django application using `collectstatic` 146 | media 147 | static 148 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | ## General rules 4 | First of all, please do not attempt to define a new section(marked by a ##) in the readme. To keep this repo nice and well organized, it is important that we limit the number of headers. 5 | 6 | ## Adding to a table 7 | The raw markdown table format we use the below: 8 | 9 | ``` 10 | | Left-aligned | Right-aligned | 11 | | :--- | ---: | 12 | | git status | git status | 13 | | git diff | git diff | 14 | ``` 15 | 16 | When you want to make an entry, on the left column, please use the format: 17 | 18 | ``` 19 | [Display name](insert link) ![badge](https://img.shields.io/badge/commitmentTime-difficulty-color.svg) 20 | ``` 21 | 22 | Note that we use badges provided by Shields.io though please refrain yourself to the badge format used in the repo and not anything new! 23 | 24 | Finaly, on the left column, please add the prerequisites to follow whatever source you have added. 25 | 26 | 27 | ## Pull Request Process 28 | 1. Create a pull request 29 | 2. Maintainers will review your request and most likely accept :) 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Quantum-Computing-Cooperation 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 | -------------------------------------------------------------------------------- /Qiskit Workshop.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/Qiskit Workshop.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![Contributors][contributors-shield]][contributors-url] 2 | [![Forks][forks-shield]][forks-url] 3 | [![Stargazers][stars-shield]][stars-url] 4 | [![Issues][issues-shield]][issues-url] 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | # Quantum Computing Cooperation - Tutorials 13 | > A set of Quantum computing sources for you to explore quantum computing as much as you want. 14 | 15 | **for Computer Scientists | Physicists | Mathematicians | Anyone else interested** 16 | 17 | 18 | ## What is this repo all about? 19 | This repository contains anything and everything relating to quantum computing and offers something for all levels. The difficulty and commitment of each source is indicated by badges that look like ![badge](https://img.shields.io/badge/20_Hours_-Difficult-black.svg). Similarly, the background needed or that would at least help is indicated by ![badge](https://img.shields.io/badge/Math101-gray.svg) Our goal is to grow this source as much as possible and spread the love for quantum computing as students from EPFL,Harvard and MIT :) 20 | 21 | 22 | ## Contents 23 | 1. [Books](#books) 24 | 2. [Repos](#repos) 25 | 3. [Online Lectures](#onlineLectures) 26 | 4. [Websites/Blogs](#websites) 27 | 28 | 29 | 30 | 31 | ## Books 32 | 33 | | [Adding books guideline](#guide) | Prerequisites | 34 | | :--- | :---: | 35 | | [Quantum Computing, a gentle introduction](http://mmrc.amss.cas.cn/tlb/201702/W020170224608150244118.pdf) ![badge](https://img.shields.io/badge/6_Hours_-Beginner-green.svg) | ![badge](https://img.shields.io/badge/LinearAlgebra-gray.svg) | 36 | | [Quantum Computation using Qiskit](https://qiskit.org/textbook/preface.html) ![badge](https://img.shields.io/badge/4_Hours_-Beginner-green.svg) | ![badge](https://img.shields.io/badge/LinearAlgebra-gray.svg) | 37 | 38 | 39 | ## Repos 40 | | [Adding repos guideline](#guide) | Prerequisities | 41 | | :--- | :---: | 42 | | [Quantum Computing, a gentle introduction](https://github.com/qosf/qml-mooc) ![badge](https://img.shields.io/badge/3_Hours_-Intermediate-red.svg)| ![badge](https://img.shields.io/badge/LinearAlgebra-gray.svg) ![badge](https://img.shields.io/badge/MachineLearning-gray.svg)| 43 | | [A board game to learn quantum computing](https://github.com/Entanglion/entanglion) ![badge](https://img.shields.io/badge/2_Hours_-Beginner-green.svg)| ![badge](https://img.shields.io/badge/PopularScienceLevelQuantumComputing-gray.svg) | 44 | | [Multiplayer webgame to learn quantum computing(under development)](https://github.com/epfl-qca/entanglion) ![badge](https://img.shields.io/badge/2_Hours_-Beginner-green.svg)| ![badge](https://img.shields.io/badge/PopularScienceLevelQuantumComputing-gray.svg) | 45 | | [The slides used by EPFL quantum computing research club](https://drive.google.com/open?id=1jlWLwve9aKnMeIsnT5OoHkDYUY7DM6Oh) ![badge](https://img.shields.io/badge/2_Hours_-AllLevels-gray.svg)| ![badge](https://img.shields.io/badge/Love_for_quantum-gray.svg) | 46 | 47 | 48 | 49 | 50 | 51 | ## Online Lectures 52 | | [Adding repos guideline](#guide) | Prerequisities | 53 | | :--- | :---: | 54 | | [Basics of quantum gates and the math needed](https://github.com/qosf/qml-mooc) ![badge](https://img.shields.io/badge/3_Hours_-Beginner-green.svg)| ![badge](https://img.shields.io/badge/LinearAlgebra-gray.svg) ![badge](https://img.shields.io/badge/BooleanLogic-gray.svg) ![badge](https://img.shields.io/badge/ClassicalLogicGates-gray.svg) | 55 | | [Live streams by the Qiskit team](https://github.com/qosf/qml-mooc) ![badge](https://img.shields.io/badge/2_Hours_-Intermediate-red.svg)| ![badge](https://img.shields.io/badge/LinearAlgebra-gray.svg) ![badge](https://img.shields.io/badge/Familiarity_with_quantum_programming-gray.svg) | 56 | 57 | 58 | 59 | 60 | ## Websites/Blogs 61 | | [Adding repos guideline](#guide) | Prerequisities | 62 | | :--- | :---: | 63 | | [A claim that we have a fundemental theory for physics](https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/) ![badge](https://img.shields.io/badge/3_Hours_-Beginner-green.svg)| ![badge](https://img.shields.io/badge/A_taste_for_physics-yellow.svg) | 64 | | [A thorough interactive quantum computing course for the novice](https://quantum.country/qcvc) ![badge](https://img.shields.io/badge/3_Hours_-Beginner-green.svg)| ![badge](https://img.shields.io/badge/Linear_algebra-gray.svg) ![badge](https://img.shields.io/badge/Complex_numbers-gray.svg) | 65 | | [IBM's annoucement board, including new internship ooportunities](https://www.ibm.com/blogs/research/category/quantcomp/) ![badge](https://img.shields.io/badge/Weekly_read-Anyone-orange.svg)| ![badge](https://img.shields.io/badge/An_interest_for_quantum-gray.svg) | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | ## Contribution guidelines 80 | [Contributing guidlines](https://github.com/Quantum-Computing-Cooperation/Tutorials/blob/master/CONTRIBUTING.md) 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | [contributors-shield]: https://img.shields.io/github/contributors/Quantum-Computing-Cooperation/Tutorials.svg?style=flat-square 90 | [contributors-url]: https://github.com/Quantum-Computing-Cooperation/Tutorials/graphs/contributors 91 | [forks-shield]: https://img.shields.io/github/forks/Quantum-Computing-Cooperation/Tutorials.svg?style=flat-square 92 | [forks-url]: https://github.com/Quantum-Computing-Cooperation/Tutorials/network/members 93 | [issues-shield]: https://img.shields.io/github/issues/Quantum-Computing-Cooperation/Tutorials.svg?style=flat-square 94 | [stars-shield]: https://img.shields.io/github/stars/Quantum-Computing-Cooperation/Tutorials.svg?style=flat-square 95 | [stars-url]: https://github.com/Quantum-Computing-Cooperation/Tutorials/stargazers 96 | [issues-url]: https://github.com/Quantum-Computing-Cooperation/Tutorials/issues 97 | [license-shield]: https://img.shields.io/github/license/Quantum-Computing-Cooperation/Tutorials.svg?style=flat-square 98 | [licence-url]: https://github.com/Quantum-Computing-Cooperation/Tutorials/blob/master/LICENSE 99 | 100 | -------------------------------------------------------------------------------- /qiskit_workshop.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": "![alt text](https://www.epfl.ch/campus/associations/list/qc/wp-content/uploads/2019/09/QCA-logo-768x188.png \"EPFL Quantum Computing Association\")\n\n# Qiskit Workshop 23rd October 2019\n\n## An introduction to Quantum Computing and programming on a quantum computer\n\nWelcome to this workshop to learn about quantum computing and programming on quantum computers. This *Jupyter Notebook* will guide you during the whole session. This presentation is brought to you by the *EPFL Quantum Computing Association*, you can find every information about it on our website www.epflquantum.ch\n\nThe goal is for you to get a bit more familiar with some concepts in quantum computing in order to be able to create programs that can run on quantum machines. The session focuses on two aspects: first an introduction to quantum computing, followed by a hands-on introduction to *Qiskit*, the *Python* package provided by *IBM* to create and run \"quantum\" programs . \n\nNow let's have a look at what you will do:\n\n## Content\n\n- **Part 1: What is quantum computing?**\n - Qubits\n - Superposition\n - Measurement\n - Entanglement\n\n- **Part 2: The circuit model of quantum computation**\n - Gates\n - Controlled Gates\n - Measurements\n\n- **Part 3: Discovering Qiskit**\n - Installation\n - Qiskit structure\n - Creating a circuit\n - How to run them on a real quantum computer\n \n- **Part 4: Simple programs**\n - Create a superposition\n - Create entanglement\n - Quantum teleportation and further" 7 | }, 8 | { 9 | "cell_type": "markdown", 10 | "metadata": {}, 11 | "source": "## Part 1: What is quantum computing?\n\n### Qubits\n\nLet's start with the notion of a bit. A bit is the smallest unit of information, a `0` or a `1`. We can encode any type of information using a sequence of bits, that is a sequence of `0`s and `1`s.\n\nNow what does it happen when we let them follow the rules of quantum mechanics? Well you get qubits! We'll start to explore how qubits can allow us to do things in a different way. After reading the next few sections, you should already be able to start thinking about interesting things to try out with qubits.\n\n### Superposition\n\nIn the quantum world, bits can not only be `0` or `1`, but a superposition of them. In this case, we use the quantum mechanics notation and we say that a qubit can be a superposition of $|0⟩$ or $|1⟩$. This can be mathematically represented as $\\alpha |0⟩ + \\beta |1⟩$, so a superposition is a linear combination of our classical bits. An interpretation of this is that with probabiliy $|\\alpha|^2$ it is $|0⟩$ and with probability $|\\beta|^2$ it is $|1⟩$.\n\n### Measurement\n\nNow the thing is, since a qubit can be in a complex state like a superposition, how can this be used and understood by us who are using classical computers? The problem is that we don't know if the qubit is a `0` or a `1`, so we need to do something with it to get a classical bit out of it. That's when measurements comes into play. What they do is to reveal something about the qubit, in our case whether it is a `0` or a `1`.\n\n\n### Entanglement\n\nA very curious phoenomenon that can arise when dealing with systems with multiple qubits is *entanglement*. What this means is that somehow, two (or more) qubits cannot be described independently of the state of the others, even when they are separated by a large distance. They are somehow correlated.\n\nLet's take a famous example. Imagine someone prepares a system with two qubits in the state $\\frac{|00⟩ + |11⟩}{\\sqrt{2}}$, so that if we measure, either we end up in `00` or in `11`.\nAfter preparation of the state, one qubit is given to Alice and the other one to Bob. We say that the pair is entangled because if now Alice measure her qubit and gets `0`, then she knows for sure, *whithout looking at Bob's qubit*, that he will also get `0` if he measure his qubit. This happens simply because as explained at the beginning, the two qubits are either `00` or `11`." 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": "## Part 2: The circuit model of quantum computation\n\n### Quantum computation and circuits\n\nOne of the most widely used model of computation is the circuit model. In the classical world, those are the boolean circuits, where a bit is represented by a wire carrying the information. We can then compute things by applying gates (AND, OR, ...) to the bits. A depiction of such a circuit could be for example:\n\n![alt text](https://sub.allaboutcircuits.com/images/04287.png \"Hadamard Gate\")\n\nIn the quantum world, you can just do the same! So you represent qubits as wires carrying the information, and then you can apply gates to those qubits. The difference is that since we can have superposition of qubits, we have access to a lot more exotic types of gates.\n\n### Gates\n\nAs mentioned above, there exists many quantum gates. Here we will focus on those that Qiskit provides to its users, and more specifically in this workshop we will discover three main gates,the $X$ gate (also referred to as NOT gate), the $H$ gate (also referred to as the Hadamard gate), and the controlled-$X$ gate. They will allow us to build our first circuits, and show us the strange things that can happen in the quantum world.\n\nFor example the $X$ gate acts as follows:\n\n$X|0⟩ = |1⟩$, $X|1⟩ = |0⟩$\n\nThe $H$ gate is used to create a superposition of `0` and `1` as follows:\n\n$H|0⟩ = \\frac{|0⟩ + |1⟩}{\\sqrt{2}}$, $H|1⟩ = \\frac{|0⟩ - |1⟩}{\\sqrt{2}}$\n\nThe way we represent the gates is usually in a circuit, and they are represented as boxes acting on wires, which represent the qubits. An example for the $H$ gate is below, acting on qubits $|0⟩$ and $|1⟩$:\n\n![alt text](https://www.researchgate.net/profile/Daniel_Ciocirlan/publication/263046229/figure/fig3/AS:296567878766594@1447718700257/the-Hadamard-gate.png \"Hadamard Gate\")\n\n### Controlled Gates\n\nThere also exist more complex gates, that don't just take as input one qubit, but multiple of them. A good example is what we call the *controlled gates*. \n\nControlled gates act on two or more qubits, where one or more qubits act as a control for some operation. For example, the controlled-$X$ gate acts on 2 qubits, and performs the $X$ operation on the second qubit only when the first qubit is $|1⟩$ , and otherwise leaves it unchanged.\n\nIt is represented this way in a circuit:\n\n![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/6/6d/Qcircuit_CX.svg/225px-Qcircuit_CX.svg.png \"Controlled X gate\")\n\nSo only if the first qubit is $|1⟩$ will the $X$ gate be applied on the second qubit.\n\nAnother way of representing the same gate, which is how it is displayed in Qiskit, is as follows:\n\n![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4e/CNOT_gate.svg/225px-CNOT_gate.svg.png \"Controlled X gate\")\n\n### Measurements\n\nFinally, we have the measurements, which can be thought of as a special kind of gate, which get the information of a qubit to a classical bit.\n\nIt is generally represented like this:\n\n![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/2/2b/Qcircuit_measure-arrow.svg/225px-Qcircuit_measure-arrow.svg.png \"Measurement\")\n\nThe two lines on the right hand side represents a classical bit, the single line on the left hand side represents a qubit.\n\n\n### Recap\n\nA good summary of what we have seen about the circuits is displayed below.\n\n![alt text](https://miro.medium.com/max/2400/1*t2quxKpPFUxOF2OgE8a2ew.jpeg \"Circuit\")\n\nNow, you know all the basics of quantum computing to start playing with Qiskit! We will first start to see how Qiskit implements all the concepts we've just seen, and then we will go through some simple example programs." 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": "## Part 3: Discovering Qiskit\n\n![alt text](https://repository-images.githubusercontent.com/161550823/42869700-c4cc-11e9-9e6c-497e53a7d861 \"Qiskit\")\n\n\"Qiskit is an open-source quantum computing software development framework for leveraging today's quantum processors in research, education, and business\" (see https://qiskit.org/)\n\n### Qiskit structure\n\nQiskit is a package that actually is made of four smaller packages, each one taking care of some part of th whole software stack. The packages are:\n
\n
\n- **Qiskit Terra**\n\n Contains a set of tools for composing quantum programs at the level of circuits and pulses, optimizing them for the constraints of a particular physical quantum processor, and managing the batched execution of experiments on remote-access backends. \n \n \n- **Qiskit Aer**\n\n Provides a high performance simulator framework which let you execute circuits compiled in Qiskit Terra, and use tools for constructing highly configurable noise models for performing realistic noisy simulations of the errors that occur during execution on real devices.\n \n\n- **Qiskit Aqua**\n\n Contains a library of cross-domain quantum algorithms upon which applications for near-term quantum computing can be built.\n \n\n- **Qiskit Ignis**\n\n It is a framework for understanding and mitigating noise in quantum circuits and systems.\n \nToday, we will focus *Qiskit Terra* in order to build circuits, and we will use *Qiskit Aer* to simulate them.\n\n\nBefore we start, let's first import everything we will need from the package. In Python, you need to do: \n" 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 1, 26 | "metadata": { 27 | "trusted": true 28 | }, 29 | "outputs": [], 30 | "source": "from qiskit import *\nfrom qiskit.visualization import plot_histogram" 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": "### Bits and qubits\n\nTo create bits and qubits in Qiskit, you will need to use registers. This is basically what is used to store them. Depending on if you want to use classical or quantum bits, you will need to specify it, like: " 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 2, 40 | "metadata": { 41 | "trusted": true 42 | }, 43 | "outputs": [], 44 | "source": "# Classical register, containing 2 bits\nclassical_reg = ClassicalRegister(2)\n\n# Quantum register, containing 2 qubits\nquantum_reg = QuantumRegister(2)" 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": "### Creating a circuit\n\nAs explained before, in order to compute things, we will need to create circuits. In Qiskit, this is done by creating an object called a `QuantumCircuit`, and specifying the registers (both classical and quantum) used in the circuit." 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 3, 54 | "metadata": { 55 | "trusted": true 56 | }, 57 | "outputs": [], 58 | "source": "# Create a circuit using the registers we defined before\ncircuit = QuantumCircuit(quantum_reg, classical_reg)\n\n# Alternative way of creating a circuit without creating registers explicitly as before\n# circuit = QuantumCircuit(2, 2)" 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": "You can draw a circuit simply by using:" 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 4, 68 | "metadata": { 69 | "trusted": true 70 | }, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "image/png": "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\n", 75 | "text/plain": "
" 76 | }, 77 | "execution_count": 4, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | } 81 | ], 82 | "source": "circuit.draw()" 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": "Here, since there are no gates, it might seem like it doesn't bring much. However, as the circuit becomes more and more complex, it is a very useful way to check that your circuit corresponds to what you intend to build." 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": "### Applying transformations (gates) to our qubits\n\nIn order for our circuit to become a little more interesting, we will need to add gates to it in order to perform transformation on our qubits.\n\nThe syntax to use when you want to apply gate `x` to qubit `y` in the circuit `circuit` is as follows:\n\n`circuit.x(y)`\n\nIf the gate takes multiple qubits as input, just specify all the qubits to be inputted to the gate. The syntax to use when you want to apply gate `x` to qubits `y`, `z`, ... in the circuit `circuit` is as follows:\n\n`circuit.x(y, z, ...)` \n\nSo if we want to apply a $X$ (NOT-gate) on the first qubit of our circuit, we just need to write: " 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 5, 97 | "metadata": { 98 | "trusted": true 99 | }, 100 | "outputs": [ 101 | { 102 | "data": { 103 | "image/png": "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\n", 104 | "text/plain": "
" 105 | }, 106 | "execution_count": 5, 107 | "metadata": {}, 108 | "output_type": "execute_result" 109 | } 110 | ], 111 | "source": "# Apply a X gate to the first qubit (qubit at index 0 in our quantum register)\ncircuit.x(quantum_reg[0])\n\n# Alternative way to apply a X gate to the first qubit (index 0)\n# circuit.x(0)\n\n# Draw the circuit\ncircuit.draw()" 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": "Great, with all the gates, we are now able to build more complex circuits! But remember, we don't have a direct access to the content of a quantum state. Indeed, for that, we need to \"transform\" the information from a qubit to a classical bit. For that, we need to measure our qubits." 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": "### Measurements\n\nTo tell Qiskit that you want to measure qubits, you need to specify a qubit and a classical bit (that will contain the result of the measurement). A syntax similar to applying gates is used. So if you want to measure qubit `x` to the classical bit `y` will do: `circuit.measure(x, y)`\n\nLet's see it in action:" 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 6, 126 | "metadata": { 127 | "trusted": true 128 | }, 129 | "outputs": [ 130 | { 131 | "data": { 132 | "image/png": "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\n", 133 | "text/plain": "
" 134 | }, 135 | "execution_count": 6, 136 | "metadata": {}, 137 | "output_type": "execute_result" 138 | } 139 | ], 140 | "source": "# Measure first qubit (qubit with index 0 in the quantum register)\n# to first classical bit (bit with index 0 in classical register)\ncircuit.measure(quantum_reg[0], classical_reg[0])\n\n# Measure second qubit (qubit with index 1 in the quantum register)\n# to second classical bit (bit with index 1 in classical register)\ncircuit.measure(quantum_reg[1], classical_reg[1])\n\n# Draw the circuit\ncircuit.draw()" 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": "If you want to measure all qubits in a quantum register, you can simply specify the register, and also the classical register that will hold the result of the measurement. In our case, this would translate to: \n\n`circuit.measure(quantum_reg, classical_reg)`" 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": "### Execute your program!\n\nTo test and get the output of your circuit, you have two possibilities:\n- Simulate it using Qiskit\n- Run it on one of IBM's quantum computer\n\nWhat's the big difference? \n\nIf you simulate a circuit, you will get the output of an *ideal* quantum computer. With Qiskit, you can specify how you want the simulation to behave (how much noise you want to introduce, ...).\n\nWhen you run on a real quantum computer, what will be output is the result of real quantum experiments. Noise may come from the way it is built, but you have no control over that. However, it is great when you want to see how a circuit would behave in real life.\n\n#### How to simulate with Qiskit simulator\n\nIf you want to simulate your program, you just need to execute you just need to execute your circuit and specify a simulator to use:" 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 7, 155 | "metadata": { 156 | "trusted": true 157 | }, 158 | "outputs": [], 159 | "source": "# Use what is called the QASM simulator\nsimulator = qiskit.BasicAer.get_backend('qasm_simulator')\n\n# Execute the circuit using the simulator\njob = execute(circuit, backend=simulator)" 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": "After that, we want to get results. Now results will be given together with probabilities of the result happening. Why? \n\nAs explained at the beginning, when a qubit is in a superposition, it has some probability to be `0` and some probability to be `1`. But after measurement, it has to collapse to some classical bit. So since we have this uncertainty, what the simulator does is to run the circuit many times, and then it will display all the answers he got, and how frequently they appeared.\n\nThe code you should use to get those results is:" 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 8, 169 | "metadata": { 170 | "trusted": true 171 | }, 172 | "outputs": [ 173 | { 174 | "data": { 175 | "image/png": "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\n", 176 | "text/plain": "
" 177 | }, 178 | "execution_count": 8, 179 | "metadata": {}, 180 | "output_type": "execute_result" 181 | } 182 | ], 183 | "source": "# Get the result of the execution\nresult = job.result()\n\n# Get the counts, the frequency of each answer\ncounts = result.get_counts(circuit)\n\n# Display the results\nplot_histogram(counts)" 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": "In the case above, we see that 100% of the executions, that is, all executions, returned answer `01`.\n\nThis happened because in our circuit there was no superposition. At the beginning, both qubits where in state $|0⟩$. Then the $X$ gate was applied on the first qubit so it changed to a $|1⟩$. After that we simply measured, so the first qubit ended up in a classical state `1`, while the second one ended up in classical state `0`.\n\nNote that on the plot, it says `01` because in Qiskit we have to read the result from right to left. The rightmost bit corresponds to the first qubit, a `1`, and the second one to a `0`.\n\n#### Running your circuit on IBM's quantum computers\n\nThe same syntax is almost the same, instead that here, instead of using a simulator, we will indicate on which quantum computer we want to run our program. It works as follows:" 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 9, 193 | "metadata": { 194 | "trusted": true 195 | }, 196 | "outputs": [ 197 | { 198 | "data": { 199 | "text/plain": "[,\n ,\n ,\n ,\n ]" 200 | }, 201 | "execution_count": 9, 202 | "metadata": {}, 203 | "output_type": "execute_result" 204 | } 205 | ], 206 | "source": "# Load your account\nqiskit.IBMQ.load_account()\n\n# After loading credentials we ask IBMQ what are the quantum\n# computers (backends) that we can use to run our circuits\naccount_provider = qiskit.IBMQ.get_provider()\naccount_provider.backends()" 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 10, 211 | "metadata": { 212 | "trusted": true 213 | }, 214 | "outputs": [], 215 | "source": "# We choose a quantum computer, here te one called ibmqx2\nquantum_computer = account_provider.get_backend('ibmqx2')\n\n# We execute the job just as before, but this time to be run on the ibmqx2\njob = execute(circuit, backend=quantum_computer)" 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": "Great, almost there! Now the thing when using real quantum computers, is that we are not the only one asking to run a program. So you will be put into a queue, and when your turn will come, the circuit will be run and you will get the results.\n\nIn order to know what is going on with your program while waiting, you can ask Qiskit to display information, such as where you are in the queue, or whether the program has been successfully run. For that, we use something called `job_monitor`." 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 11, 225 | "metadata": { 226 | "trusted": true 227 | }, 228 | "outputs": [ 229 | { 230 | "name": "stdout", 231 | "output_type": "stream", 232 | "text": "Job Status: job has successfully run\n" 233 | } 234 | ], 235 | "source": "from qiskit.tools.monitor import job_monitor\n\n# Monitor the status of our job\njob_monitor(job)" 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": "Finally we can get the results in the exact same way as we did before:" 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 12, 245 | "metadata": { 246 | "trusted": true 247 | }, 248 | "outputs": [ 249 | { 250 | "data": { 251 | "image/png": "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\n", 252 | "text/plain": "
" 253 | }, 254 | "execution_count": 12, 255 | "metadata": {}, 256 | "output_type": "execute_result" 257 | } 258 | ], 259 | "source": "# Get the result of the execution\nresult = job.result()\n\n# Get the counts, the frequency of each answer\ncounts = result.get_counts(circuit)\n\n# Display the results\nplot_histogram(counts)" 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": "Interestingly here, even though we didn't have superposition in our circuit, we end up with multiple answers when running on a quantum computer. Why is that so?\n\nAs you can imagine, the quantum computer, even though it works, is not perfect like our simulator. In reality, there is noise that will affect our computations. In this case, we see that more than 90% of the time, the right answer `01` was found, but sometimes there were some imperfections and noise and other results were given as output.\n\nSo from now on, you have the choice: either you can use the simulator to run your experiments, or you can decide to use one of IBM's quantum computers." 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": "## Part 4: Simple example programs\n\nNow that you know the basics of Qiskit, you can start playing with it. We suggest you some simple circuits below to discover some quantum effects we talked about at the beginning, but you are free to experiment by yourself!\n\n### Create a superposition\n\nNow let's say that for the second qubit, we want to create a superposition of `0` and `1`. You can simply apply a $H$ (Hadamard) gate to perform this operation.\n" 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 13, 274 | "metadata": { 275 | "trusted": true 276 | }, 277 | "outputs": [ 278 | { 279 | "data": { 280 | "image/png": "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\n", 281 | "text/plain": "
" 282 | }, 283 | "execution_count": 13, 284 | "metadata": {}, 285 | "output_type": "execute_result" 286 | } 287 | ], 288 | "source": "# Create a circuit with one qubit and one bit\ncircuit = QuantumCircuit(1, 1)\n\n# Apply a H gate to the qubit (qubit at index in the quantum register)\ncircuit.h(0)\n\n# Measure the qubit to the classical bit\ncircuit.measure(0, 0)\n\n# Draw the circuit\ncircuit.draw()" 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": "Now the qubit should be in the state $\\frac{|0⟩ + |1⟩}{\\sqrt{2}}$, so there is 50% chance to be in state `0` and 50% chance to be in state `1`. Let's see the results (using the simulator): " 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 14, 298 | "metadata": { 299 | "trusted": true 300 | }, 301 | "outputs": [ 302 | { 303 | "data": { 304 | "image/png": "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\n", 305 | "text/plain": "
" 306 | }, 307 | "execution_count": 14, 308 | "metadata": {}, 309 | "output_type": "execute_result" 310 | } 311 | ], 312 | "source": "# Execute the circuit using the simulator\njob = execute(circuit, backend=simulator)\n\n# Get the result of the execution\nresult = job.result()\n\n# Get the counts, the frequency of each answer\ncounts = result.get_counts(circuit)\n\n# Display the results\nplot_histogram(counts)" 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": "And just as expected, about 50% of the time it ends up in state `0`, and 50% of the time in state `1`." 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "metadata": {}, 322 | "source": "### Create entanglement\n\nAfter applying the $H$ gate, the first bit is in state $\\frac{|0⟩ + |1⟩}{\\sqrt{2}}$ while the second one in state $|0⟩$, so we can write the state of both as $\\frac{|00⟩ + |10⟩}{\\sqrt{2}}$. How can we end up to state $\\frac{|00⟩ + |11⟩}{\\sqrt{2}}$?\n\nOne way of doing this is to see that we would want $|00⟩$ to stay $|00⟩$, and $|10⟩$ to become $|11⟩$. This says that altogether, we want that if the first qubit is `1`, \"invert\" the state of the second qubit. But this is exactly what a controlled-$X$ gate does! So we just need to add that gate after the $H$ gate, as follows:" 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": 24, 327 | "metadata": { 328 | "trusted": true 329 | }, 330 | "outputs": [ 331 | { 332 | "data": { 333 | "image/png": "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\n", 334 | "text/plain": "
" 335 | }, 336 | "execution_count": 24, 337 | "metadata": {}, 338 | "output_type": "execute_result" 339 | } 340 | ], 341 | "source": "# Create a circuit with 2 qubits and 2 bits\ncircuit = QuantumCircuit(2, 2)\n\n# Apply an H gate to the first qubit\ncircuit.h(0)\n\n# Apply a controlled-X gate to the second qubit, with first one as control\ncircuit.cx(0, 1)\n\n# Measure the qubits\ncircuit.measure(0, 0)\ncircuit.measure(1, 1)\n\n# Draw the circuit\ncircuit.draw()" 342 | }, 343 | { 344 | "cell_type": "markdown", 345 | "metadata": {}, 346 | "source": "Note that here, we should imagine that we only measure one qubit to see if there is entanglement indeed. That is, if we measure the first qubit and get `0` then we should get `0` for the second qubit too. Just as if we measure `1`, we should get `1` for the second qubit. But since we want to see the state of the second qubit too, we need to measure it to check whether the entanglement happened.\n\nNow let's run everything and see if indeed we get the answer as claimed:" 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 25, 351 | "metadata": { 352 | "trusted": true 353 | }, 354 | "outputs": [ 355 | { 356 | "data": { 357 | "image/png": "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\n", 358 | "text/plain": "
" 359 | }, 360 | "execution_count": 25, 361 | "metadata": {}, 362 | "output_type": "execute_result" 363 | } 364 | ], 365 | "source": "# Execute the circuit using the simulator\njob = execute(circuit, backend=simulator)\n\n# Get the result of the execution\nresult = job.result()\n\n# Get the counts, the frequency of each answer\ncounts = result.get_counts(circuit)\n\n# Display the results\nplot_histogram(counts)" 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": "And we can see that as we expected, either both qubits collapse to a classical state `00` or `11`." 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": "### Quantum teleportation and further\n\nNow that you know a bit more and played with Qiskit, you can go deeper and check out https://www.youtube.com/watch?v=mMwovHK2NrE, a tutorial on how to do Quantum Teleporation in Qiskit, explained by the Qiskit team. There is also much more on their channel, so it's a great way to continue to learn to program with Qiskit.\n\nThank you for following this workshop, and we wish you a lot of fun learning about quantum computing and all its possibilities!" 376 | } 377 | ], 378 | "metadata": { 379 | "kernelspec": { 380 | "display_name": "Python 3", 381 | "language": "python", 382 | "name": "python3" 383 | }, 384 | "language_info": { 385 | "codemirror_mode": { 386 | "name": "ipython", 387 | "version": 3 388 | }, 389 | "file_extension": ".py", 390 | "mimetype": "text/x-python", 391 | "name": "python", 392 | "nbconvert_exporter": "python", 393 | "pygments_lexer": "ipython3", 394 | "version": "3.7.3" 395 | } 396 | }, 397 | "nbformat": 4, 398 | "nbformat_minor": 2 399 | } -------------------------------------------------------------------------------- /quantumteleport.py: -------------------------------------------------------------------------------- 1 | import qiskit as qk 2 | from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit 3 | from qiskit import execute, Aer 4 | from qiskit import IBMQ 5 | from qiskit.visualization import plot_histogram 6 | import matplotlib 7 | 8 | secret_unitary = "hz" 9 | # simple function that applies a series of unitary gates from a given string 10 | def apply_secret_unitary(secret_unitary, qubit, quantum_circuit, dagger): 11 | functionmap = { 12 | 'x':quantum_circuit.x, 13 | 'y':quantum_circuit.y, 14 | 'z':quantum_circuit.z, 15 | 'h':quantum_circuit.h, 16 | 't':quantum_circuit.t, 17 | } 18 | if dagger: functionmap['t'] = quantum_circuit.tdg 19 | 20 | if dagger: 21 | [functionmap[unitary](qubit) for unitary in secret_unitary] 22 | else: 23 | [functionmap[unitary](qubit) for unitary in secret_unitary[::-1]] 24 | 25 | # Create the quantum circuit with 3 qubits and 3 classical bits 26 | qc = QuantumCircuit(3, 3) 27 | print("Original Circuit:") 28 | print(qc) 29 | 30 | ''' Qubit ordering as follows (classical registers will just contain measured values of the corresponding qubits): 31 | q[0]: qubit to be teleported (Alice's first qubit. It was given to her after the application of a secret unitary 32 | which she doesn't know) 33 | q[1]: Alice's second qubit 34 | q[2]: Bob's qubit, which will be the destination for the teleportation 35 | ''' 36 | 37 | # Apply the secret unitary that we are using to generate the state to teleport. You can change it to any unitary 38 | apply_secret_unitary(secret_unitary, qc.qubits[0], qc, dagger = 0) 39 | qc.barrier() 40 | # Next, generate the entangled pair between Alice and Bob (Remember: Hadamard followed by CX generates a Bell pair) 41 | qc.h(1) 42 | qc.cx(1, 2) 43 | qc.barrier() 44 | 45 | print("Bell circuit:") 46 | print(qc) 47 | # Next, apply the teleportation protocol. 48 | qc.cx(0, 1) 49 | qc.h(0) 50 | qc.measure(0, 0) 51 | qc.measure(1, 1) 52 | qc.cx(1, 2) 53 | qc.cz(0, 2) 54 | qc.barrier() 55 | 56 | print("Teleportation protocol:") 57 | print(qc) 58 | ''' 59 | In principle, if the teleportation protocol worked, we have q[2] = secret_unitary|0> 60 | As a result, we should be able to recover q[2] = |0> by applying the reverse of secret_unitary 61 | since for a unitary u, u^dagger u = I. 62 | ''' 63 | apply_secret_unitary(secret_unitary, qc.qubits[2], qc, dagger=1) 64 | qc.measure(2, 2) 65 | 66 | print("Final Circuit:") 67 | print(qc) 68 | backend = Aer.get_backend('qasm_simulator') 69 | job_sim = execute(qc, backend, shots=1024) 70 | sim_result = job_sim.result() 71 | 72 | measurement_result = sim_result.get_counts(qc) 73 | print(measurement_result) 74 | plot_histogram(measurement_result) 75 | 76 | 77 | -------------------------------------------------------------------------------- /src/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/.DS_Store -------------------------------------------------------------------------------- /src/badges/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/badges/.DS_Store -------------------------------------------------------------------------------- /src/badges/begApplBadge.svg: -------------------------------------------------------------------------------- 1 | beginnerbeginnerApplicationApplication -------------------------------------------------------------------------------- /src/badges/begTheoryBadge.svg: -------------------------------------------------------------------------------- 1 | beginnerbeginnertheorytheory -------------------------------------------------------------------------------- /src/logos/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/logos/.DS_Store -------------------------------------------------------------------------------- /src/logos/QCC.logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/logos/QCC.logo.png -------------------------------------------------------------------------------- /src/logos/epfl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/logos/epfl.png -------------------------------------------------------------------------------- /src/logos/harvard.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/logos/harvard.png -------------------------------------------------------------------------------- /src/logos/mit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/logos/mit.png -------------------------------------------------------------------------------- /src/repoSim.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Quantum-Computing-Cooperation/Tutorials/9b44a4410dedba9d15bc8fd6a6bcd6621441e4fb/src/repoSim.gif --------------------------------------------------------------------------------