Quantum-Coin-Game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How Quantum Power Helps to Win a Coin Game\n",
    "\n",
    "A quantum coin game to illustrate the power of quantum superposition and interference - implemented by [Jan-R. Lahmann](https://twitter.com/JanLahmann) using [Qiskit](http://qiskit.org), [binder](https://mybinder.org) and [RISE](https://rise.readthedocs.io/).\n",
    "\n",
    "Inspired by the TED talk of Shohini Ghose  \n",
    "[\"Quantum computing explained in 10 minutes\"](https://www.ted.com/talks/shohini_ghose_quantum_computing_explained_in_10_minutes)  \n",
    "\n",
    "(hit space or right arrow to move to next slide)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "https://www.ted.com/talks/shohini_ghose_quantum_computing_explained_in_10_minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Usage instructions for the user interface\n",
    "\n",
    "1. \"Ctrl -\" and \"Ctrl +\" (or \"command -\", \"command +\") adjust the zoom level to fit the text to the browser window\n",
    "* Use \"space\" and \"shift  space\" to navigate through the slides \n",
    "* \"Shift Enter\" executes the interactive cells (might need to click the cell, first)\n",
    "* Execute the interactive cells on each slide (\"In [1]:\", etc)\n",
    "* In case a cell is not formatted correctly, try to double-click and then \"Shift Enter\" to re-execute\n",
    "* Interactive cells can be modified, if needed\n",
    "* \"X\" at the top left exits the slideshow and enters the jupyter notebook interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Coin Game\n",
    "\n",
    "Two players, A(lice) and B(ob), play a coin game.  \n",
    "\n",
    "1. The game starts with the coin showing Heads.\n",
    "* Player A starts and may either turn the coin or leave it as is. \n",
    "* The moves are hidden, i.e. not revealed to the other player.\n",
    "* B may now also turn the coin or leave it as is.\n",
    "* A then has the third and final move.\n",
    "* Now the coin gets revealed. \n",
    "* If it shows Heads, A wins; if it shows Tails, B wins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This notebook implements the coin game using Qiskit, an SDK by IBM to program quantum computers.  \n",
    "\n",
    "On three separate slides, the players can make their choice to either turn the coin (apply an \"X-Gate\") or leave it as is (apply an \"id-Gate\" / identity-Gate).  \n",
    "Heads is encoded by \"0\", Tails encoded by \"1\".  \n",
    "At the end, the quantum program evaluates the moves and declares the winner.  \n",
    "\n",
    "In a second phase, one player will be allowed to use an additional gate (\"coin move\"), which is only available in the Quantum world: the \"Hadamard Gate\".  \n",
    "Will this change the game?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The game can also be played using the IBM \"Quantum Composer\" graphical UI https://quantum.ibm.com/composer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# loading some basic functions needed for the game\n",
    "from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit\n",
    "from qiskit import transpile\n",
    "from qiskit.providers.basic_provider import BasicProvider\n",
    "from qiskit.visualization import plot_histogram, circuit_drawer\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# auxiliary functions for the coin moves\n",
    "\n",
    "def MoveA1(move_A1): global moveA1; moveA1=move_A1;\n",
    "def MoveB1(move_B1): global moveB1; moveB1=move_B1;\n",
    "def MoveA2(move_A2): global moveA2; moveA2=move_A2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# auxiliary function to identify the winner\n",
    "\n",
    "def who_wins(counts):\n",
    "    if len(counts)==1 :\n",
    "        print('The winner is', 'A' if (\"0\" in counts) else 'B')\n",
    "    else:\n",
    "        count0=counts[\"0\"]\n",
    "        count1=counts[\"1\"]\n",
    "        print('The coin is in superposition of |0⟩ and |1⟩')\n",
    "        print('A wins with probability',  \"%.1f%%\" % (100.*count0/(count0+count1)))\n",
    "        print('B wins with probability',  \"%.1f%%\" % (100.*count1/(count0+count1)))\n",
    "    return()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ready to play?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Player A makes the first move and applies an X-Gate (turn the coin) or id-Gate (leave it is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# then make your choice using the drop-down widget\n",
    "interact(MoveA1, move_A1={'id Gate':0,'X Gate':1});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Player B makes the his move and applies an X-Gate (turn the coin) or id-Gate (leave it is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell \n",
    "# you might need to click the cell, first, to activate it\n",
    "# then make your choice using the drop-down widget\n",
    "interact(MoveB1, move_B1={'id Gate':0,'X Gate':1});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Player A makes his second move and applies an X-Gate (turn the coin) or id-Gate (leave it is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# you might need to click the cell, first, to activate it\n",
    "# then make your choice using the drop-down widget\n",
    "interact(MoveA2, move_A2={'id Gate':0,'X Gate':1});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# optional: print the three moves. \n",
    "# 0: id Gate (leave the coin unchanged), 1: X Gate (turn the coin)\n",
    "print(moveA1, moveB1, moveA2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# create the quantum circuit with the chosen coin moves\n",
    "q = QuantumRegister(1) # create a quantum register with one qubit\n",
    "# create a classical register that will hold the results of the measurement\n",
    "c = ClassicalRegister(1) \n",
    "qc = QuantumCircuit(q, c) # creates the quantum circuit\n",
    "backend = BasicProvider().get_backend('basic_simulator') # define the backend\n",
    "\n",
    "# 1. move of A\n",
    "qc.id(q[0]) if (moveA1 == 0) else qc.x(q[0]) \n",
    "    \n",
    "# 1. move of B \n",
    "qc.id(q[0]) if (moveB1 == 0) else qc.x(q[0])      \n",
    "\n",
    "# 2. move of A\n",
    "qc.id(q[0]) if (moveA2 == 0) else qc.x(q[0]) \n",
    "    \n",
    "qc.measure(q, c) # Measure the qubits\n",
    "qc.draw(output='mpl') # plot the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# execute the quantum circuit (coin moves) and identify the winner\n",
    "\n",
    "transpiled_circuit = transpile(qc, backend)\n",
    "job = backend.run(transpiled_circuit, shots=200) # run the job simulation\n",
    "\n",
    "result = job.result() # grab the result\n",
    "\n",
    "counts = result.get_counts(qc) # results for the number of runs\n",
    "\n",
    "print(counts); # print the results of the runs\n",
    "who_wins(counts); # celebrate the winner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Is there a safe strategy for A to always win the game? (or for B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It is easy to see that A and B will win with the same probability.  \n",
    "There is no strategy for A (or B) to increase this probability - and certainly no strategy to always win."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Does this change if A has \"Quantum Power\" and may use \"H-Gates\" in addition to id and X?\n",
    "(B may still only use id- and X-Gates)\n",
    "\n",
    "Is there a safe strategy for A (or B) to always win using the new power?  \n",
    "How do you interpret this? Is it a \"sleight of hand\" or is there more behind it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ready to play with Quantum Power?\n",
    "A may now use id-, X- and H-gates.  \n",
    "B may use only id- and X-gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Player A makes the first move and applies an id-, X- or H-Gate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interact(MoveA1, move_A1={'id Gate':0,'X Gate':1, 'H Gate':2});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Player B makes his first move and applies an id- or X-Gate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interact(MoveB1, move_B1={'id Gate':0,'X Gate':1});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Player A makes her second move and applies an id-, X- or H-Gate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interact(MoveA2, move_A2={'id Gate':0,'X Gate':1, 'H Gate':2});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# optional: print the three moves. \n",
    "# 0: id Gate (leave the coin unchanged), 1: X Gate (turn the coin), 2: H Gate\n",
    "print(moveA1, moveB1, moveA2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# create the quantum circuit with the chosen coin moves\n",
    "q = QuantumRegister(1) # create a quantum register with one qubit\n",
    "# create a classical register that will hold the results of the measurement\n",
    "c = ClassicalRegister(1) \n",
    "qc = QuantumCircuit(q, c) # creates the quantum circuit\n",
    "backend = BasicProvider().get_backend('basic_simulator') # define the backend\n",
    "\n",
    "# 1. move of A\n",
    "if   moveA1 == 0 : qc.id(q[0])\n",
    "elif moveA1 == 1 : qc.x(q[0]) \n",
    "elif moveA1 == 2 : qc.h(q[0]) \n",
    "    \n",
    "# 1. move of B \n",
    "if   moveB1 == 0 : qc.id(q[0])\n",
    "elif moveB1 == 1 : qc.x(q[0])     \n",
    "\n",
    "# 2. move of A\n",
    "if   moveA2 == 0 : qc.id(q[0])\n",
    "elif moveA2 == 1 : qc.x(q[0]) \n",
    "elif moveA2 == 2 : qc.h(q[0]) \n",
    "\n",
    "qc.measure(q, c) # Measure the qubits\n",
    "qc.draw(output='mpl') # plot the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# execute the quantum circuit (coin moves) and identify the winner\n",
    "\n",
    "transpiled_circuit = transpile(qc, backend)\n",
    "job = backend.run(transpiled_circuit, shots=200) # run the job simulation\n",
    "\n",
    "result = job.result() # grab the result\n",
    "\n",
    "counts = result.get_counts(qc) # results for the number of runs\n",
    "\n",
    "print(counts); # print the results of the runs\n",
    "who_wins(counts); # celebrate the winner\n",
    "\n",
    "plot_histogram(counts) # Visualise the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Want to make some own experiments to understand the state of the qubit (\"quantum coin\")?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# create the quantum circuit with the chosen coin moves\n",
    "q = QuantumRegister(1) # create a quantum register with one qubit\n",
    "# create a classical register that will hold the results of the measurement\n",
    "c = ClassicalRegister(1) \n",
    "qc = QuantumCircuit(q, c) # creates the quantum circuit\n",
    "backend = BasicProvider().get_backend('basic_simulator') # define the backend\n",
    "\n",
    "\n",
    "# define the quantum gates (=coin moves) as you like\n",
    "# you could also try change the number of moves to just 1 or 2\n",
    "#qc.id(q[0])\n",
    "#qc.x(q[0]) \n",
    "#qc.h(q[0]) \n",
    "\n",
    "qc.id(q[0])\n",
    "qc.x(q[0]) \n",
    "qc.h(q[0])\n",
    "\n",
    "qc.measure(q, c) # Measure the qubits\n",
    "qc.draw(output='mpl') # plot the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# execute the quantum circuit (coin moves) and identify the winner\n",
    "\n",
    "transpiled_circuit = transpile(qc, backend)\n",
    "job = backend.run(transpiled_circuit, shots=200) # run the job simulation\n",
    "\n",
    "result = job.result() # grab the result\n",
    "\n",
    "counts = result.get_counts(qc) # results for the number of runs\n",
    "\n",
    "print(counts); # print the results of the runs\n",
    "\n",
    "plot_histogram(counts) # Visualise the results\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Some Quantum Theory related to this Coin Game\n",
    "\n",
    "(hint: In case a cell is not formatted correctly, try to double-click and then \"Shift Enter\" to re-execute)  \n",
    "A (general) quantum state can be written as $\\;\\; \\alpha |0\\rangle + \\beta |1\\rangle $.  \n",
    "It is called a superposition of $\\;|0\\rangle\\;$  and $\\;|1\\rangle\\;$.  \n",
    "$ \\alpha , \\beta $ are generalized probabilities (for measuring 0 or 1) with $\\; \\alpha , \\beta \\in \\mathbb{C},\\; |\\alpha|^2 + |\\beta|^2 = 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A quantum gate acting on a single qubit can be defined by its action on the basis vectors $|0\\rangle$  and $|1\\rangle$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "X-Gate maps $\\;|0\\rangle$  to $|1\\rangle\\;$  and $\\;|1\\rangle$  to $|0\\rangle$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hadamard-Gate maps $\\;|0\\rangle\\;$ to $\\;\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\;\\;$  and   $\\;\\;|1\\rangle\\;$ to $\\;\\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If we can show that \n",
    "$$ H(\\; id( H(|0\\rangle) ) \\;) = |0\\rangle\\, $$\n",
    "and \n",
    "$$ H(\\;\\, X( H(|0\\rangle) ) \\;)  = |0\\rangle, $$  \n",
    "it becomes clear that if A applies an H-Gate in both of her moves, she wins the game - independent of the move of B (X or id).\n",
    "\n",
    "Remember: Heads is encoded by $|0\\rangle$, Tails encoded by $|1\\rangle$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The first equation holds because:  \n",
    "\n",
    "\\begin{align*} \n",
    "H(\\; id(\\; H(|0\\rangle) \\;)\\; ) \n",
    "      = &\\;\\; H(\\; H(|0\\rangle)\\; )  \\\\\n",
    "      = &\\;\\; H(\\; \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\;) \\\\\n",
    "      = &\\;\\; \\frac{1}{\\sqrt{2}}\\;(\\; H(|0\\rangle) + H(|1\\rangle) \\;) \\\\\n",
    "      = &\\;\\; \\frac{1}{\\sqrt{2}}\\;(\\;\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}} + \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}\\;) \\\\\n",
    "      = &\\;\\; \\frac{1}{{2}}\\; (\\;|0\\rangle + |1\\rangle + |0\\rangle - |1\\rangle\\; )\\\\\n",
    "      = &\\;\\; |0\\rangle\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This fundamentally uses superposition (created by the H-Gate) and in the last equality (destructive) interference of the amplitudes (generalized probabilities) of $|1\\rangle$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In case B choses to use an X-Gate instead of id, the following identity\n",
    "\n",
    "$$ X(\\; H(|0\\rangle) \\;) = X\\; (\\;\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\; ) = \\frac{|1\\rangle + |0\\rangle}{\\sqrt{2}} = H(|0\\rangle) $$\n",
    "\n",
    "can be used to show that the final state is $ |0\\rangle$:\n",
    "\n",
    "$$ H(\\; X( H(|0\\rangle) ) \\;) = H(\\; H(|0\\rangle)\\; ) = |0\\rangle $$\n",
    "\n",
    "[These charts](https://github.com/JanLahmann/Fun-with-Quantum/raw/master/QuantumTheory-for-QuantumCoinGame.pdf) explain a bit more of the quantum theory and formalism required to prove the above identities, in case you are interested."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We now have shown that the final state is always $ |0\\rangle$, independent of the move of B.  \n",
    "\n",
    "Thus, A wins the game with certainty, if she applies an H-Gate in both of her moves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "How do you interpret this?  \n",
    "Is it a \"sleight of hand\" or is there more to it?  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hint:  \n",
    "What if an \"algorithm\" could use the \"extra moves\" to calculate answers that cannot be calculated (or take much longer to be calculated) with \"classical moves\"?"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "livereveal": {
   "autolaunch": true
  },
  "nav_menu": {},
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}