GHZ-Game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The GHZ-Game\n",
    "\n",
    "\n",
    "### Solve \"unsolvable\" problems using Quantum Computers\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Usage instructions for the user interface\n",
    "\n",
    "* \"Shift Enter\" executes the interactive cells (might need to click the cell, first)\n",
    "* Execute all the interactive cells (\"In [1]:\", etc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "First we need to install some prerequisits. You do not have to understand them for now (just click on the cells and press \"Shift Enter\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#import prerequisites\n",
    "from ipywidgets import interact\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.visualization import plot_histogram, plot_bloch_multivector, plot_bloch_vector, plot_state_qsphere\n",
    "from GHZGame.ghzGame import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# create the quantum circuit with the chosen coin moves\n",
    "q = QuantumRegister(3) # create a quantum register with one qubit\n",
    "# create a classical register that will hold the results of the measurement\n",
    "c = ClassicalRegister(3) \n",
    "qc = QuantumCircuit(q, c) # creates the quantum circuit\n",
    "backend = BasicProvider().get_backend('basic_simulator') # define the backend, here a Quantum simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's play a game!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We form two teams of three players. Your team is called \"Team Einstein\" and your team members are Alice and Bob (and you, of course). The other team is called \"Team Schrödinger\" and - as the name indicates - will be able to exploit quantum mechanics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The rules for this game are as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- Each player thinks of a color (red or blue) and a shape (star or rectangle)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- The game master than asks either all players for a color or one for a color and two for a shape. In total, four different kinds of questions can be asked:\n",
    "\n",
    "\n",
    "1. Color, color, color\n",
    "2. Color, shape, shape\n",
    "3. Shape, color, shape\n",
    "4. Shape, shape, color\n",
    "\n",
    "Which of the four sets of questions is used, is chosen randomly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Once the questions are asked, the team members are not allowed to communicate anymore. Before that, the team members are allowed to agree on a strategy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- In the case that all players are asked for a color (1.), the team wins if an even number of people answered with red. Otherwise (when two are asked for a shape and only one for a color) they win if an uneven number of players answered with either red or star depending on the question they were asked. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Example:\n",
    "\n",
    "Question: Color, color, color\n",
    "\n",
    "Answer: red, red, blue\n",
    "> right answer, even number of red.\n",
    "\n",
    "Question: Color, shape, shape\n",
    "\n",
    "Answer: red, star, rectangle\n",
    "> wrong answer, even number of red and star, should be uneven.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "If you think about a *real* object that will answer the question about color and shape, each team member could  choose to think of one of the following four objects.  You are allowed to change your mind as often as you want as long as you do not know whether your team members were asked for a color or a shape:\n",
    "![title](GHZGame/shapes.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Make your choices:\n",
    "(The 0 or 1 inside the brakets of the drop down fields below show the corresponding bit value. 0 is interpreted as red or star and 1 as blue or rectangle.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print ('Your team can now discuss which values each of you will say when asked either for the color or the shape of your object.')\n",
    "print ('')\n",
    "\n",
    "print ('Alice:')\n",
    "interact(Alice, AlicesColor={'red (1)':1,'blue (0)':-1}, AlicesShape={'star (1)':1,'rectangle (0)':-1})\n",
    "\n",
    "print ('Bob:')\n",
    "interact(Bob, BobsColor={'red (1)':1,'blue (0)':-1}, BobsShape={'star (1)':1,'rectangle (0)':-1})\n",
    "\n",
    "print ('You:')\n",
    "interact(You, YourColor={'red (1)':1,'blue (0)':-1}, YourShape={'star (1)':1,'rectangle (0)':-1})\n",
    "print ('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If you are confident with your choices try it out here. Do you have a 100% winning strategie that gives the correct answer for each of the four sets of questions? (\"If you loose once, you will stay in prison forever\".)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# runs the experiment for both teams, asking all four questions.\n",
    "runExperiment()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why has the other team a 100% winning strategie while your team does not?\n",
    "\n",
    "To find out what they do differently you talk to team Schrödinger and their team member Erwin explains what they did."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bob: \n",
    "\"*How did you do that? Isn't it impossible to constantly win this game? I mean look at this, we tried to solve it mathematically and the problem is unsolvable, you must have cheated!*\"\n",
    "\n",
    "(For easier calculations we replaced 0 for blue and rectangle with -1)\n",
    "    \n",
    "\n",
    "    \n",
    "   ![title](GHZGame/proof1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Erwin (from team Schrödinger): \n",
    "\"*Yes, you are right, but we did not cheat! We used so-called qubits and entanglement and with that it is possible to always win.*\"\n",
    "\n",
    "Bob: \n",
    "\"*What exactly is that and how does it work?*\"\n",
    "    \n",
    "Erwin: \n",
    "\"*Each of us had a qubit. You can imagine them as a little sphere with a vector pointing in \n",
    "    one direction. This vector describes the state the qubit is currently in.*\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "plot_bloch_vector([1,0,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Erwin: \n",
    "\"*However - as you know from quantum mechanics - you cannot see in which state the qubit is, but \n",
    "    need to measure it to find out something about its state. The result of a measurement is always \n",
    "    either 0 or 1. These values correspond to the shape and color of the objects in such a way that we \n",
    "    answered with red or star whenever measuring 1 and accordingly with blue or rectangle when measuring 0.\n",
    "    For example, when asked for the color of your object and you are measuring a 0 you answer blue. For a 1 \n",
    "    your answer would be red.*\n",
    "    \n",
    "*The vector in the sphere above, is in a position other than 0 (top of the sphere) or 1 (at the bottom). When \n",
    "    measuring, you would still get one of these results. In this case, it would be 0 with 50% probability \n",
    "    and 1 with 50% probability. The actual result for a single measurement is random.*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Erwin: \n",
    "\"*So we used qubits that were entangled with each other and different \"observables\" of a quantum object. Normally, a Quantum Computer measures the Z-basis of a qubit but we measured X when asked for a color and when asked for a shape we measured Y. The result for the Y measurement in the example above \n",
    "    would always be 1, instead of the 50% probability of 0 or 1 when measuring the Z-value. \n",
    "    I will explain later why exactly this works but as all three of our qubits were entangled, we got the correct answer for all cases.*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Bob: \n",
    "\"*But isn't that against the rule to not communicate with each other after the question was asked?*\"\n",
    "    \n",
    "Erwin: \n",
    "\"*No it is not because the qubits do not communicate with each other. They are just correlated in \n",
    "    such a way that they cannot be seen as independent. We can just try it out :) Before we start we \n",
    "    need to bring all our three qubits into the so-called GHZ-state. This is an entangled state that creates \n",
    "    dependencies between the qubits. To do so, we need to apply the following Quantum circuit:*\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# this circuit is explained in more detail later on.\n",
    "qc = QuantumCircuit(q, c)\n",
    "# create GHZ state\n",
    "qc.h(q[0]) #apply H-gate to the first qubit\n",
    "qc.cx(q[0],q[1]) #entangle the first two qubits\n",
    "qc.cx(q[0],q[2]) #entangle the first and the last qubit\n",
    "qc.barrier() #visual seperation (optional)\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Erwin:  \n",
    "\"*The first gate we see in the circuit above is the H-gate which brings the qubit into a \n",
    "            Superposition. When measured it has a 50% probability of beeing 0 and a 50% probability of beeing 1.*\"\n",
    "\n",
    "\"*The other gates we see look different. They are called CNOT-gates and operate on 2 qubits. \n",
    "            The qubit with the dot is the control bit and the other one with the cross sign is the target \n",
    "            bit. If the control bit is one an X-gate is applied to the target bit. Otherwise nothing happens.*\"\n",
    "            \n",
    "(An X-gate cannot be found in the picture above. The X-gate is similar to a NOT-gate used on classical computers. When applied to a qubit in state $ \\;\\;|1\\rangle $ it becomes $ \\;\\;|0\\rangle $ and the other way around.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Erwin:  \"*On a Quantum Computer you can only measure what \n",
    "            points in the direction of the Z-axis. Therefore, we need to make the state vector point in the  direction to derive information about the X or Y basis. When you are asked for the color (corresponds to x value) of your qubit you need to apply an \n",
    "            H-gate and measure the state afterwards. Applying the H-gate turns your state vector 180° around the \n",
    "            Z-axis and 90° around the Y-axis and therefore, enables you to read out the X-value.* \n",
    "            \n",
    "*When asked for\n",
    "            the shape you apply the sdg-gate followed by an H-gate and measure afterwards. This corresponds to \n",
    "            a Y measurement (shape) as the sdg gate turns the object by 270° around the Z-axis so that the \n",
    "            shape of the object is now pointing towards X. When applying an H-gate afterwards, it turns the \n",
    "            object 180° around the Z-axis and 90° around the Y-axis so that it is now pointing towards Z which is the only axis we are able to measure.*\n",
    "            \n",
    "*You can try to reconstruct the movements of a single qubit using the visualization below. Whether \n",
    "            the top or bottom side of the dice is revealed in a measurement is randomly chosen. In the initial \n",
    "            GHZ-state the dice is pointing up with a black side so that a color is pointing towards X and a\n",
    "            shape towards Y.*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![title](GHZGame/visualization.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Erwin:  \n",
    "\"*The results for each player seems to be perfectly random, but all three results in fact are \n",
    "            strongly correlated and not independent. This is caused by the entanglement. The Bloch Sphere\n",
    "            visualization can only be used for a single qubit, but not for the entire (entangled) system \n",
    "            of multiple qubits. However the so-called QSphere shows that the measurement results of the GHZ-State can only be |000> or |111> with equal probability:*\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "backend = BasicProvider().get_backend('basic_simulator') # the device to run on\n",
    "transpiled_circuit = transpile(qc, backend)\n",
    "result = backend.run(transpiled_circuit).result()\n",
    "psi = Statevector.from_instruction(qc)\n",
    "plot_state_qsphere(psi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print (\"To measure the Y-basis of a quantum state, the following quantum circuit can be used:\")\n",
    "qc = QuantumCircuit(q, c) #create a new Quantum circuit\n",
    "# If measuring the X or Z-value, this step is not necessary:\n",
    "#apply sdg-gate to qubit 0. Vector moves 90° counterclockwise around the Z-axis (e.g. from y-basis to x-basis)\n",
    "qc.sdg(q[0]) \n",
    "# If measuring the Z-value, this step is not necessary:\n",
    "#apply H-gate to qubit 0. Vector moves 180° around the Z-axis and 90° around the Y-axis (e.g. from x-basis to z-basis)\n",
    "qc.h(q[0]) \n",
    "#create measurement gate for qubit 0\n",
    "qc.measure(q[0],c[0]) \n",
    "#draw the circuit\n",
    "qc.draw(output='mpl') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "    Can you modify the cell above to build a Quantum circuit that is suitable for an X measurement by \n",
    "    commenting out or deleting the line that is not necessary? \n",
    "\n",
    "    Can you do the same for a Z-measurement? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "    A quantum circuit that can be used when your team is asked for the XYY-values, therefore, could look like\n",
    "    this:\n",
    "    (XYY means that Alice (player 1) is asked for the color while Bob and you (player 2 and 3) are asked for \n",
    "    a shape.\n",
    "    1 -> red or star\n",
    "    0 -> blue or rectangle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(q, c) #create a new Quantum circuit\n",
    "# create GHZ state\n",
    "qc.h(q[0]) #apply H-gate to the first qubit\n",
    "qc.cx(q[0],q[1]) #entangle the first two qubits\n",
    "qc.cx(q[0],q[2]) #entangle the first and the last qubit\n",
    "qc.barrier() #visual seperation (optional)\n",
    "\n",
    "# measure each qubit accordingly\n",
    "qc.h(q[0]) #apply H-gate to the first qubit (for x-value, player 1)\n",
    "qc.sdg(q[1]) #apply sdg-gate to the second qubit\n",
    "qc.h(q[1]) #apply H-gate to the second qubit (for y-value, player 2)\n",
    "qc.sdg (q[2]) #apply sdg-gate to the third qubit\n",
    "qc.h(q[2]) #apply H-gate to the third qubit (for y-value, player 3)\n",
    "qc.measure(q,c) #create measurement gates for all qubits\n",
    "qc.draw(output='mpl') #draw the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "    In this case the measurement results are distributed as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(q, c) #create a new Quantum circuit\n",
    "# create GHZ state\n",
    "qc.h(q[0]) #apply H-gate to the first qubit\n",
    "qc.cx(q[0],q[1]) #entangle the first two qubits\n",
    "qc.cx(q[0],q[2]) #entangle the first and the last qubit\n",
    "qc.barrier() #visual seperation (optional)\n",
    "\n",
    "# measure each qubit accordingly\n",
    "qc.h(q[0]) #apply H-gate to the first qubit (for x-value, player 1)\n",
    "qc.sdg(q[1]) #apply sdg-gate to the second qubit\n",
    "qc.h(q[1]) #apply H-gate to the second qubit (for y-value, player 2)\n",
    "qc.sdg (q[2]) #apply sdg-gate to the third qubit\n",
    "qc.h(q[2]) #apply H-gate to the third qubit (for y-value, player 3)\n",
    "qc.draw(output='mpl') #draw the circuit\n",
    "transpiled_circuit = transpile(qc, backend)\n",
    "result = backend.run(transpiled_circuit).result()\n",
    "psi = Statevector.from_instruction(qc)\n",
    "plot_state_qsphere(psi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# So now let's play again, using this new strategy\n",
    "\n",
    "To generate a random question execute the next cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "question = randomQuestion()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Try to build a quantum circuit that can be used to answer these questions on the next slide and provide the right answers to your team members (if you need  help use the previous cells as examples or continue to the next cells):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(q, c) #creates a new Quantum circuit\n",
    "\n",
    "#TODO: create GHZ-state (try not to use the predefined function)\n",
    "\n",
    "#TODO: apply gates according to the question above\n",
    "\n",
    "qc.draw(output='mpl') #draw the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Now let's test your Quantum circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# runs your quantum circuit 100 times on a simulator\n",
    "simulate(qc, q, c, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Now you can check your results for yourself. You get several different answers and this can be correct as the requirements of an even or uneven number of ones or zeros can be satisfied in multiple ways."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Do you think your answers were right? Check it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# compares whether the measurement results from your circuit correspond to the question asked\n",
    "circuitCheck(qc, q, c, question)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Need some help? \n",
    "(Otherwise skip this cell)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(q, c) #create a new Quantum circuit\n",
    "\n",
    "#creates GHZ-state\n",
    "qc.h(q[0]) #apply H-gate to the first qubit\n",
    "qc.cx(q[0],q[1]) #entangle the first two qubits\n",
    "qc.cx(q[0],q[2]) #entangle the first and the last qubit\n",
    "qc.barrier() #visual seperation (optional)\n",
    "\n",
    "#TODO: apply gates according to the question above - choose the right ones\n",
    "qc.sdg(q[0]) #apply sdg-gate to the first qubit\n",
    "qc.h(q[0]) #apply H-gate to the first qubit\n",
    "qc.sdg(q[1]) #apply sdg-gate to the second qubit\n",
    "qc.h(q[1]) #apply H-gate to the second qubit\n",
    "#qc.sdg (q[2]) #apply sdg-gate to the third qubit\n",
    "qc.h(q[2]) #apply H-gate to the third qubit \n",
    "\n",
    "#Hint: only h-gate for x-value, both gates for y-value\n",
    "\n",
    "\n",
    "qc.measure(q,c) #create measurement gates for all qubits\n",
    "qc.draw(output='mpl') #draw the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To check your answer return to the previous slide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# prints out the correct code for your questions\n",
    "correctAnswer(question)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You: \n",
    "\"*Cool it works, and with this Quantum strategy the team can always win, no matter which question is asked. But still I don't really understand why and how?!*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Background Information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Entangled qubits have a strong dependency. Therefore, their states cannot be described individually but only in a correlated manner.\n",
    "In the GHZ state, for example, when performing an XXX-measurement only the results $\\;\\; |000\\rangle, |011\\rangle,  |101\\rangle $ and $ \\;\\;|110\\rangle $ occur.\n",
    "The fascinating thing is each qubit when observed individually (for example when only looking at the first qubit), behaves perfectly random. But when considering the whole system a dependency becomes obvious. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A commonly known entangled state is the Bell state.The state can be $\\;\\frac{|00\\rangle + |11\\rangle}{\\sqrt{2}}\\;\\;$. When measuring the first qubit in state 1 we can already say with certainty that the result of the second measurement will also be 1, as a state with mixed results cannot occur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "But let's go back to our Experiment. We remember the GHZ-state from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(q,c)\n",
    "ghz_state(qc,q).draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Which outcomes do you expect when executing this circuit, using the z-axis as measurement basis?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "quiz()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Now try it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "plot_histogram(simulate(qc, q, c, 100)) # Visualise the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Interestingly the only results that you get are either $ \\;\\;|000\\rangle $ or $ \\;\\;|111\\rangle $ with roughly 50/50 probability (Increase the number of shots to get more accurate results - closer to 50%).\n",
    "This is because q0 is brought into a superposition. In case it is 0 the two CNOT gates do not change the value of the other two qubits. If it is 1 both of the other values (which initially were 0) are flipped to 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "This becomes obvious when looking at the state which can be written as $\\;\\;|GHZ\\rangle=\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}}\\;\\;$ and only consists of these two basis states."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "And why can it be used to answer the questions of the experiment above?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "When measuring on the XXX-basis, we apply a Hadamard-gate to each of the qubits.\n",
    "A Hadamard-gate can be described with the following matrix:\n",
    "\n",
    "$$ H=\\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "If we want to apply the H-gate 3 times (one time on each qubit) we can use the tensor product. For the tensor product A⨂B each block aij*B is calculated. For the tensor product of three Hadamard gates this means:\n",
    "$$ H⨂H⨂H=\\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix} $$\n",
    "$$=  \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} H & H \\\\ H & -H \\end{pmatrix}=   \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix} ⨂\\frac 1 {2}\\begin{pmatrix} 1 & 1 & 1 & 1 \\\\ 1 & -1 & 1 & -1 \\\\ 1 & 1 & -1 & -1 \\\\ 1 & -1 & -1 & 1 \\end{pmatrix}$$\n",
    "$$= \\frac 1 {2\\sqrt{2}} \\begin{pmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\\\ 1 & -1 & 1 & -1 & 1 & -1 & 1 & -1 \\\\ 1 & 1 & -1 & -1 & 1 & 1 & -1 & -1 \\\\ 1 & -1 & -1 & 1 & 1 & -1 & -1 & 1 \\\\ 1 & 1 & 1 & 1 & -1 & -1 & -1 & -1 \\\\ 1 & -1 & 1 & -1 & -1 & 1 & -1 & 1 \\\\ 1 & 1 & -1 & -1 & -1 & -1 & 1 & 1 \\\\ 1 & -1 & -1 & 1 & -1 & 1 & 1 & -1\\end{pmatrix}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The states $ \\;\\;|0\\rangle $ and $ \\;\\;|1\\rangle $ can also be represented by the vectors $ \\;\\;|0\\rangle=\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix}|1\\rangle=\\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix} \\;\\;$\n",
    "\n",
    "Therefore, the GHZ state can also be represented as a vector:\n",
    "$$|GHZ\\rangle=\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}} = \\frac{|0\\rangle |0\\rangle |0\\rangle+ |1\\rangle |1\\rangle |1\\rangle}{\\sqrt{2}} $$\n",
    "$$ =\\frac {\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix}⨂\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix}⨂\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix}+ \\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}⨂\\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}⨂\\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}}{\\sqrt{2}}$$\n",
    "$$ =\\frac {\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix}⨂\\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0\\end{pmatrix}+ \\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}⨂\\begin{pmatrix} 0 \\\\ 0\\\\ 0\\\\ 1\\end{pmatrix}⨂\\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}}{\\sqrt{2}}$$\n",
    "$$ =\\frac 1 {\\sqrt{2}}\\left( {\\begin{pmatrix} 1 \\\\ 0 \\\\0 \\\\0 \\\\ 0\\\\ 0\\\\ 0 \\\\ 0\\end{pmatrix}+ \\begin{pmatrix} 0 \\\\ 0\\\\ 0\\\\ 0 \\\\0 \\\\0\\\\ 0\\\\ 1\\end{pmatrix}} \\right)\n",
    "= \\frac 1 {\\sqrt{2}} {\\begin{pmatrix} 1 \\\\ 0 \\\\0 \\\\0 \\\\ 0\\\\ 0\\\\ 0 \\\\ 1\\end{pmatrix}}$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "When applying three Hadamard-gates to the GHZ state:\n",
    "$$\\frac 1 {2\\sqrt{2}} \\begin{pmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\\\ 1 & -1 & 1 & -1 & 1 & -1 & 1 & -1 \\\\ 1 & 1 & -1 & -1 & 1 & 1 & -1 & -1 \\\\ 1 & -1 & -1 & 1 & 1 & -1 & -1 & 1 \\\\ 1 & 1 & 1 & 1 & -1 & -1 & -1 & -1 \\\\ 1 & -1 & 1 & -1 & -1 & 1 & -1 & 1 \\\\ 1 & 1 & -1 & -1 & -1 & -1 & 1 & 1 \\\\ 1 & -1 & -1 & 1 & -1 & 1 & 1 & -1\\end{pmatrix}*\\frac 1 {\\sqrt{2}} {\\begin{pmatrix} 1 \\\\ 0 \\\\0 \\\\0 \\\\ 0\\\\ 0\\\\ 0 \\\\ 1\\end{pmatrix}}= \\frac 1 {4} {\\begin{pmatrix} 2 \\\\ 0 \\\\0 \\\\2 \\\\ 0\\\\ 2\\\\ 2 \\\\ 0\\end{pmatrix}} $$\n",
    "$$= \\frac 1 {4} (2*|000\\rangle+0*|001\\rangle+0*|010\\rangle+2*|011\\rangle+0*|100\\rangle+2*|101\\rangle+2*|110\\rangle+0*|111\\rangle)$$\n",
    "$$= \\frac 1 {2} (|000\\rangle+|011\\rangle+|101\\rangle+|110\\rangle)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "As expected only the results with an even number of ones occur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "When measuring a Y-value we need an additional gate: $$ S^†= \\begin{pmatrix} 1 & 0 \\\\ 0 & -i \\end{pmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "For the YYX-measurement we would apply the sdg-gate to qubit 0 and 1 follwed by a Hadamard-gate on all three qubits. Therefore the following needs to be caluclated:\n",
    "\n",
    "$$HS^†⨂HS^†⨂H$$\n",
    "$$=\\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}\\begin{pmatrix} 1 & 0 \\\\ 0 & -i \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}\\begin{pmatrix} 1 & 0 \\\\ 0 & -i \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix} $$\n",
    "$$= \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & -i \\\\ 1 & i \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & -i \\\\ 1 & i \\end{pmatrix}⨂ \\frac 1 {\\sqrt{2}} \\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "When applying this measurement to the GHZ state:\n",
    "\n",
    "$$HS^†⨂HS^†⨂H *\\frac 1 {\\sqrt{2}} {\\begin{pmatrix} 1 \\\\ 0 \\\\0 \\\\0 \\\\ 0\\\\ 0\\\\ 0 \\\\ 1\\end{pmatrix}}= \\frac 1 {4} {\\begin{pmatrix} 0 \\\\ 2 \\\\2 \\\\0 \\\\ 2\\\\ 0\\\\ 0 \\\\ 2\\end{pmatrix}} $$\n",
    "$$= \\frac 1 {4} (0*|000\\rangle+2*|001\\rangle+2*|010\\rangle+0*|011\\rangle+2*|100\\rangle+0*|101\\rangle+0*|110\\rangle+2*|111\\rangle)$$\n",
    "$$= \\frac 1 {2} (|001\\rangle+|010\\rangle+|100\\rangle+|111\\rangle)$$\n",
    "\n",
    "only the results with an even number of zeros, and accordingly an even number of blue or rectangle, remain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## What does it change?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "As we saw above, any strategy that is using pre-defined answers (i.e. \"local hidden variables\") cannot answer all four sets of questions correctly. But the procedure based on quantum mechanics and Entaglement, i.e. the GHZ state, was able to give a correct answer all the time. \n",
    "\n",
    "How can that be explained? \n",
    "\n",
    "The final pragraphs of Mermin's book \"Quantum Computer Science: An Introduction\" conclude: \"The best explanation anybody has come up with to this day is to insist that no explanation is needed beyond what one can infer from the laws of quantum mechanics. Those laws are correct. (...) One gets puzzled only if one tries to understand how the rules can work not only for the actual situation in which they are applied, but also in alternative situations that might have been chosen but were not. (...) A good motto for the quantum physicist and for future quantum computer scientists might be 'What didn’t happen didn't happen.'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To learn more about Quantum Entanglement you can look at the Hardy's paradox here: https://mybinder.org/v2/gh/JanLahmann/Fun-with-Quantum/master?filepath=Hardys-Paradox.ipynb\n",
    "\n",
    "One use case entanglement is needed for is the so-called \"Quantum Teleportation\". You can learn what it is and find out more about Quantum Entanglement here: https://github.com/Qiskit/textbook/blob/main/notebooks/ch-algorithms/teleportation.ipynb"
   ]
  }
 ],
 "metadata": {
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}