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://quantumexperience.ng.bluemix.net/qx/editor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 execute, BasicAer\n",
    "from qiskit.tools.visualization import plot_histogram, circuit_drawer\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# auxillary 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": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# hit \"shift + Enter\" to execute this cell\n",
    "# auxillary 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": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e690c16545146b194b38e41ea5b225c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_A1', options={'id Gate': 0, 'X Gate': 1}, value=0), Output())…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5bca0c66039e44b1887356bd51691345",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_B1', options={'id Gate': 0, 'X Gate': 1}, value=0), Output())…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e0df63d055744920a3941df14e98aeae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_A2', options={'id Gate': 0, 'X Gate': 1}, value=0), Output())…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0\n"
     ]
    }
   ],
   "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": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 454.315x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 = BasicAer.get_backend('qasm_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": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0': 200}\n",
      "The winner is A\n"
     ]
    }
   ],
   "source": [
    "# execute the quantum circiut (coin moves) and identify the winner\n",
    "\n",
    "job = execute(qc, backend, 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": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d941f093ecd94654843185e94cbc9588",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_A1', options={'id Gate': 0, 'X Gate': 1, 'H Gate': 2}, value=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4ddec66ca6e843218f613b5c6f4d6679",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_B1', options={'id Gate': 0, 'X Gate': 1}, value=0), Output())…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bb2da233e8fe4c7989b8a9744319436a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='move_A2', options={'id Gate': 0, 'X Gate': 1, 'H Gate': 2}, value=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interact(MoveA2, move_A2={'id Gate':0,'X Gate':1, 'H Gate':2});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0\n"
     ]
    }
   ],
   "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": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 454.719x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 = BasicAer.get_backend('qasm_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": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0': 200}\n",
      "The winner is A\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# execute the quantum circiut (coin moves) and identify the winner\n",
    "\n",
    "job = execute(qc, backend, 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": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 472.545x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 = BasicAer.get_backend('qasm_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": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1': 102, '0': 98}\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAGwCAYAAAA5X9QTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6KklEQVR4nO3deXzMd+LH8fdMZiREDq0QR4S0iLbqbMTdOBKlrVWK2lJtF+22tpbdR39sW7Rbapet7upJkV0sWr22ZVFHXHG0K6glgkakBHEkkge5Zn5/eGTWNIeMmcjE9/V8PDwemc/3M5+jzczjnc/3+JjsdrtdAAAAMAxzVQ8AAAAAtxYBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMJaqHsDtzGaz6dSpUwoICJDJZKrq4QAAgNuY3W7X5cuX1bBhQ5nN5a/xEQAr0alTpxQWFlbVwwAAAAZy8uRJNW7cuNw6BMBKFBAQIOna/4jAwMAqHg0AALidZWdnKywszJE/yuO1AXDPnj2aOnWqduzYoYKCArVu3VoTJ07U0KFDXWrn7Nmzmjlzpr7++mudPHlS/v7+atGihUaNGqXnn3++RP21a9dqxowZ+s9//iOTyaQOHTrolVdeUe/evV2eQ/Fp38DAQAIgAAC4JSpy2ZnJG/cC3rRpk+Li4uTn56fhw4crICBAq1at0okTJzR79mxNmjSpQu0kJSUpNjZWFy9e1IABA9SqVSvl5OTo0KFDqlGjhlavXu1Uf8mSJRo5cqRCQkI0bNgwSdKKFSuUmZmplStXasiQIS7NIzs7W0FBQcrKyiIAAgCASuVK7vC6AFhYWKjIyEilp6dr586datu2rSQpKytLUVFRSk1N1ZEjRxQeHl5uO9nZ2WrdurWuXLmib7/9Vvfff3+JfiyW/y2AXrx4UREREbJYLNq7d6/j3Hl6erratWsnSTp+/HiFllWvHwMBEAAA3Aqu5A6vewzMxo0bdezYMY0YMcIR/iQpKChIU6ZMUX5+vuLj42/Yznvvvae0tDS99dZbJcKfJKfwJ0mffPKJLl26pPHjxztdONm4cWO9+OKLyszM1Oeff37zEwMAAPASXhcAN2/eLEmKjY0tcSwuLk6SlJCQcMN2VqxYIZPJpMGDBys5OVl/+9vf9Kc//UlfffWV8vPzK61fAAAAb+d1N4GkpKRIkpo3b17iWGhoqGrXru2oU5b8/HwdOHBAISEh+tvf/qapU6fKZrM5jkdEROiLL75Q69atK9RvcdmN+s3Ly1NeXp7jdXZ2tiSpoKBABQUFkiSz2SwfHx8VFRU5jam4vLCwUNeflffx8ZHZbC6zvLjdYsUrm4WFhRUqt1qtstlsKioqcpSZTCZZLJYyy8saO3NiTsyJOTEn5sScqm5OrvC6AJiVlSXp2inf0gQGBjrqlOXChQsqKirS+fPn9frrr+tPf/qTRo4cqYKCAn344Yf64x//qEceeUSHDx+Wn5/fDfstPo9+o35nzpyp6dOnlyhft26datWqJUlq0qSJ2rVrp/379ystLc1Rp2XLloqMjNTu3bt17tw5R3nbtm0VHh6uLVu26PLly47yzp07q169elq3bp3TL1hMTIxq1qxZ4gaX/v3768qVK9q0aZOjzGKxaMCAAcrMzFRiYqKjPCAgQL169dLJkyeVlJTkKA8JCVGXLl2UkpKi5ORkRzlzYk7MiTkxJ+bEnKp+Tg0bNlRFed1NILGxsVq/fr1SUlJ09913lzjeqFEj5eTklBvGTp06pUaNGkmSXnrpJc2dO9fp+LBhw7Ry5Ur94x//0JNPPilJatGihVJSUlRQUFDi+sCCggLVqFFD999/v/bt21dmv6WtAIaFhSkzM9MRIo321whzYk7MiTkxJ+bEnG7NnHJzcyt8E4jXrQAWr8CVFfCys7NVp06dCrUhSY8++miJ448++qhWrlyp7777zhEAr+/3zjvvLNHnz9stja+vr3x9fUuUW61WWa1WpzIfHx/5+PiUqPvz8Hmj8p+3ezPlZrO51KXjssrLGjtzYk6uljMn5iQxp7LG6Go5c2JOrvC6m0DKu94uIyNDOTk5pV6ndz1/f3/HCmBwcHCJ48VlV65cqVC/5V0fCAAAUN14XQDs2bOnpGvXzf3c2rVrneqUp1evXpKk//73vyWOFZc1bdrU4/0CAAB4O6+7BrCwsFAtW7bUTz/9VOaDoJOTkx3h7fTp08rKylKDBg2cTtHu2LFDXbt21b333qtt27Y5Vv0yMjLUsWNHnT59WocOHVKLFi0kXXsQdLNmzWS1WnkQNAAAqHaq9YOgLRaLFixYIJvNph49emjs2LGaNGmS2rRpoyNHjmjGjBlOK3eTJ09Wq1atSjykuUuXLpo4caIOHjyo+++/Xy+88ILGjh2rNm3a6KefftIf//hHR/iTpDp16mjevHnKzMxU+/btNX78eI0fP17t27fX+fPn9d5777kU/gAAALyV190EIl27rXrbtm2aOnWqVqxYoYKCArVu3VqzZs1y7NFbEXPmzFHr1q317rvvavHixTKZTGrXrp0++OADDRo0qET9J598UnXr1tWMGTO0aNEimUwmdejQQa+88or69OnjySkCAABUGa87BXw74RQwAAC4Var1KWAAAABULgIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACADAbezdd99V06ZN5efnp06dOmn37t1l1l28eLFMJpPTPz8/P6c6n332mWJjY3XnnXfKZDIpKSmpRDtXr17VCy+8oDvvvFO1a9fW4MGDdebMGU9PDW4gAAIAcJtasWKFJk6cqKlTp+o///mP2rRpo7i4OJ09e7bM9wQGBur06dOOfydOnHA6npubq27dumnWrFlltvHb3/5W//rXv/TJJ58oISFBp06d0mOPPeaxecF9lqoeAAAAqBx/+ctfNGbMGD399NOSpA8++EDffPONFi5cqP/7v/8r9T0mk0mhoaFltjly5EhJUmpqaqnHs7Ky9PHHH2vZsmXq1auXJGnRokVq1aqVdu7cqejoaDdmBE9hBRAAgNtQfn6+vv/+e/Xp08dRZjab1adPHyUmJpb5vpycHIWHhyssLEwDBw7UwYMHXer3+++/V0FBgVO/kZGRatKkSbn94tYiAAIAcBvKzMxUUVGR6tev71Rev359ZWRklPqeli1bauHChfryyy+1ZMkS2Ww2denSRenp6RXuNyMjQzVq1FBwcHCF+8WtxylgAAAgSercubM6d+7seN2lSxe1atVKH374od54440qHBk8jRVAAABuQ3Xr1pWPj0+Ju2/PnDlT7jV+17NarWrXrp2OHj1a4X5DQ0OVn5+vS5cu3XS/qHwEQAAAbkM1atRQhw4dtGHDBkeZzWbThg0bnFb5ylNUVKQDBw6oQYMGFe63Q4cOslqtTv0mJycrLS2twv2i8nEKGACA29TEiRP11FNPqWPHjoqKitLcuXOVm5vruCt41KhRatSokWbOnClJev311xUdHa27775bly5d0p///GedOHFCv/rVrxxtXrhwQWlpaTp16pSka+FOurbyFxoaqqCgID377LOaOHGi7rjjDgUGBmr8+PHq3LkzdwB7EQIgAAC3qWHDhuncuXN67bXXlJGRobZt2+rf//6348aQtLQ0mc3/Oxl48eJFjRkzRhkZGapTp446dOigHTt26J577nHU+eqrrxwBUpKGDx8uSZo6daqmTZsmSXr77bdlNps1ePBg5eXlKS4uTu+9994tmDEqymS32+1VPYjbVXZ2toKCgpSVlaXAwMCqHg4AALiNuZI7uAYQAADAYAiAAAAABkMAxG3Blc3Or7d8+XKZTCb94he/cCo/c+aMRo8erYYNG6pWrVrq16+fUlJSnOqw2TkAoLoiAKLau5nNzqVr+1j+7ne/U/fu3Z3K7Xa7fvGLX+j48eP68ssvtXfvXoWHh6tPnz7Kzc111GOzcwBAdcVNIJWIm0BujU6dOumBBx7QvHnzJF17zlVYWJjGjx9f5mbnRUVF6tGjh5555hlt3bpVly5d0hdffCFJOnLkiFq2bKkffvhB9957r6PN0NBQzZgxQ7/61a+UlZWlkJAQLVu2TEOGDJEkHT58WK1atVJiYiKPOgAA3HLcBALDuNnNzl9//XXVq1dPzz77bIljeXl5kiQ/Pz+nNn19fbVt2zZJbHYOAKjeCICo1m5ms/Nt27bp448/1vz580s9XhzkJk+erIsXLyo/P1+zZs1Senq6Tp8+LYnNzgEA1RsBEIZy+fJljRw5UvPnz1fdunVLrWO1WvXZZ5/pyJEjuuOOO1SrVi1t2rRJDz30kNMDUwEAqK7YCQTVmqubnR87dkypqal65JFHHGU2m02SZLFYlJycrLvuuksdOnRQUlKSsrKylJ+fr5CQEHXq1EkdO3aU5LzZ+fWrgGx2DgCoDljOQLXm6mbnkZGROnDggJKSkhz/Hn30UcXExCgpKUlhYWFO9YOCghQSEqKUlBR99913GjhwoCQ2OwcAVG+sAKLac2Wzcz8/P913331O7y9ewbu+/JNPPlFISIiaNGmiAwcO6KWXXtIvfvELxcbGShKbnQMAqjUCIKo9Vzc7r4jTp09r4sSJOnPmjBo0aKBRo0bp1VdfdarDZucAgOqK5wBWIp4DCAAAbhWeAwgAAIAyEQABAAAMhgAIAABgMARAAAAAg+EuYADAbWvM3KoeAfA/8ydU9Qj+hxVAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZjqeoBwD1sdA5v402bnQMASscKIAAAgMEQAAEAAAyGAAgAAGAwBEAAAACDIQACAAAYDAEQAADAYAiAAAAABkMABAAAMBgCIAAAgMEQAAEAAAyGAAgAAGAwBEAAAACDIQACAAAYDAEQAADAYAiAAAAABkMABAAAMBgCIAAAgMEQAAEAAAzGawPgnj171L9/fwUHB8vf31/R0dFauXLlTbd38eJFNWrUSCaTSf369Su1jslkKvPf6NGjb7pvAAAAb2Kp6gGUZtOmTYqLi5Ofn5+GDx+ugIAArVq1SsOGDdPJkyc1adIkl9t88cUXlZWVdcN64eHhpYa9tm3butwnAACAN/K6AFhYWKgxY8bIbDZry5YtjuD12muvKSoqSlOmTNGQIUMUHh5e4TZXrVqlZcuWad68eXrxxRfLrdu0aVNNmzbNjRkAAAB4N687Bbxx40YdO3ZMI0aMcFp1CwoK0pQpU5Sfn6/4+PgKt3fu3Dk9//zzGjlypAYMGFAJIwYAAKhevG4FcPPmzZKk2NjYEsfi4uIkSQkJCRVu77nnnpOPj4/eeeedCp0CvnTpkj766CNlZmbqjjvuUNeuXdW6desK9wcAAODtvC4ApqSkSJKaN29e4lhoaKhq167tqHMjS5Ys0WeffaYvvvhCderUqVAA3Ldvn8aNG+dU1q9fP8XHx6tevXrlvjcvL095eXmO19nZ2ZKkgoICFRQUSJLMZrN8fHxUVFQkm83mqFtcXlhYKLvd7ij38fGR2WwusxzwNsW/68UslmtfM4WFhU7lVqtVNptNRUVFjjKTySSLxVJmeVmfG099nio6duZUneZkEuBNKvPz5AqvC4DFIS0oKKjU44GBgRUKcqdOndJvfvMbPfHEExo4cGCF+p40aZIGDx6sFi1aqEaNGvrhhx/0xhtvaM2aNXr44YeVmJgoHx+fMt8/c+ZMTZ8+vUT5unXrVKtWLUlSkyZN1K5dO+3fv19paWmOOi1btlRkZKR2796tc+fOOcrbtm2r8PBwbdmyRZcvX3aUd+7c+YaBFKgKq1evdnrdv39/XblyRZs2bXKUWSwWDRgwQJmZmUpMTHSUBwQEqFevXjp58qSSkpIc5SEhIerSpYtSUlKUnJzsKPf052ndunVOISImJkY1a9ZkTtV4TpJVgDepzM9Tw4YNKzwOk/36P6+8QGxsrNavX6+UlBTdfffdJY43atRIOTk5NwyB/fv31/fff6+DBw+qbt26kqTU1FQ1a9ZMcXFx+ve//12h8dhsNvXq1UsJCQlatWqVHnvssTLrlrYCGBYWpszMTAUGBkry/F/CY+ZWaBrALfPeC6wAMifvmdPYd1gBhPeYP6FyVwBzc3MVFBSkrKwsR+4oi9etABav/JUV8LKzs1WnTp1y24iPj9eaNWv0ySefOMLfzTKbzRozZowSEhK0ffv2cgOgr6+vfH19S5RbrVZZrc5/hfr4+JS6mlj8RVbRcsDb/Px3vbxys9lc6mmLssrL+tx46vPkytjLKmdO3jcnwJtU9uepwuO46XdWkuJr/0q7zi8jI0M5OTmlXh94vb1790qSHn/8caeHOTdr1kyStHbtWplMpgo/2684RObm5lZ0GgAAAF7L65aVevbsqZkzZ2rdunUaPny407G1a9c66pSnc+fOysnJKVGek5OjFStWqHHjxoqLi1OTJk0qNKZdu3ZJuvaMQAAAgOrO664BLCwsVMuWLfXTTz9p586djlW6rKwsRUVFKTU1VcnJyY4wdvr0aWVlZalBgwZl3jhSrLxrAA8cOKDIyMgSpxB27Nihvn37qqCgQIcOHdJdd91V4blkZ2dX+Fz8zeIaQHib+ROqegTA//AdCW9S2d+PruQOr1sBtFgsWrBggeLi4tSjRw+nreBOnDih2bNnO63ETZ48WfHx8Vq0aJFb+/XOmTNH33zzjbp166awsDBZrVYdPHhQ69atk8lk0rvvvutS+AMAAPBWXhcApWu39G/btk1Tp07VihUrVFBQoNatW2vWrFkaNmxYpfQ5cOBAXbp0Sfv27dP69euVn5+v0NBQDR8+XBMmTFBUVFSl9AsAAHCred0p4NsJp4BhRJwChjfhOxLexJtOAXvdXcAAAACoXARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAg7FURqOpqalav369/Pz8NGjQINWuXbsyugEAAMBNcGsFcMaMGWrWrJkuXrzoKNu8ebPuu+8+Pffccxo9erTat2+vCxcuuD1QAAAAeIZbAfCLL75Q06ZNVadOHUfZyy+/LJvNpunTp+v555/X0aNHNXfuXHfHCQAAAA9xKwCmpqbqnnvucbw+deqU9uzZoxdeeEGvvPKK5s2bp969e+vzzz93e6AAAADwDLcCYHZ2toKDgx2vt2zZIpPJpEceecRR1r59e6WlpbnTDQAAADzIrQBYv359nThxwvF6/fr18vX1VadOnRxlV69elclkcqcbAAAAeJBbdwE/8MAD+vLLL/X111/Lz89PK1asUExMjHx9fR11fvzxRzVs2NDtgQIAAMAz3FoBnDJligoLCzVw4EDFxcXp6tWrmjJliuN4Xl6etmzZ4rQiCAAAgKrl1gpg+/bttXPnTv3jH/+QJA0dOlRRUVGO43v37lVMTIxGjBjh3igBAADgMW4/CLpNmzZq06ZNqceio6O5AxgAAMDLeGwnkJycHB05ckS5ubnq3r27p5oFAACAh7m9F3BqaqoGDhyoOnXq6IEHHlBMTIzj2Pbt23XPPfdo8+bN7nYDAAAAD3ErAKalpSk6OlqrV6/WwIED1blzZ9ntdsfxTp06KTMzU//85z/dHigAAAA8w60AOHXqVF28eFEJCQn69NNP1bdvX6fjFotF3bt31/bt290aJAAAADzHrQC4du1aDRo0SF26dCmzTnh4uH766Sd3ugEAAIAHuRUAL1y4oKZNm5Zbx263Ky8vz51uAAAA4EFubwWXkpJSbp0DBw6oSZMm7nQDAAAAD3IrAPbt21dff/219u/fX+rxrVu3auPGjerfv7873QAAAMCD3AqAr7zyimrWrKkePXrozTff1NGjRyVJa9as0auvvqp+/fqpbt26+v3vf++RwQIAAMB9bj0IumnTplq7dq2GDx+uV199VSaTSXa7XQ8//LDsdruaNGmiTz/9VA0aNPDUeAEAAOAmt3cC6dSpk1JSUvSvf/1Lu3bt0oULFxQYGKhOnTpp4MCBqlGjhifGCQAAAA/xyFZwFotFgwYN0qBBgzzRHAAAACqR21vBAQAAoHpxaQXw73//uyRp0KBBCggIcLyuiFGjRrk2MgAAAFQKlwLg6NGjZTKZFB0drYCAAMfr8tjtdplMJgIgAACAl3ApAC5cuFAmk8lxV++iRYsqZVAAAACoPC6vAF7vqaee8uRYAAAAcAu4dRPIli1blJaWVm6dkydPasuWLe50AwAAAA9yKwDGxMRo8eLF5db5+9//rpiYGHe6AQAAgAe5FQDtdvsN69hsthveKAIAAIBbp9KfA5iSkqKgoKDK7gYAAAAV5PJOIM8884zT6y+++EKpqakl6hUVFTmu/3vooYdueoAAAADwLJcD4PXX/JlMJiUlJSkpKanUuiaTSQ888IDefvvtmx0fAAAAPMzlAPjjjz9Kunb9X0REhCZMmKCXXnqpRD0fHx/VqVNH/v7+7o8SAAAAHuNyAAwPD3f8vGjRIrVt29apDAAAAN7N5QB4PR4EDQAAUP24FACLH+gcFRUlPz8/lx7w3KNHD9dGBgAAgErhUgB88MEHZTKZdOjQIbVo0cLxuiKKiopuaoAAAADwLJcC4GuvvSaTyaS6des6vQYAAED14VIAnDZtWrmvAQAA4P0qfScQAAAAeBcCIAAAgMG4dAq4V69eN9WJyWTShg0bbuq9AAAA8CyXAuDmzZtvqhNuFAEAAPAeLgVAm81WWeMAAADALcI1gAAAAAZDAAQAADAYtoIDAAAwGLaCAwAAMBi2ggMAADAYtoIDAAAwGG4CAQAAMBiXVgDLkpeXp9WrV2vv3r3KyspSUFCQ2rVrp/79+8vX19cTXQAAAMBD3A6AX331lcaOHatz587Jbrc7yk0mk+rVq6ePPvpIjzzyiLvdAAAAwEPcOgW8YcMGDR48WJcuXdIzzzyjxYsXa82aNVq8eLGefvppXbx4UY899pg2btzoctt79uxR//79FRwcLH9/f0VHR2vlypUVfv+aNWs0fPhwRUZGKjg4WLVq1VJkZKSeffZZHTlypMz3rV27Vj179lRAQIACAwMVExPDPsYAAOC24tYK4NSpU1WzZk3t2LFD9913n9OxUaNG6Te/+Y26du2qqVOnqlevXhVud9OmTYqLi5Ofn5+GDx+ugIAArVq1SsOGDdPJkyc1adKkG7axevVq7dy5U506ddJDDz0kq9WqQ4cOKT4+XkuXLtXq1atLjGnJkiUaOXKkQkJCNHr0aEnSihUr1LdvX61cuVJDhgyp8BwAAAC8lcl+/XlbF/n7+2vEiBGaP39+mXWeffZZLV++XLm5uRVqs7CwUJGRkUpPT9fOnTvVtm1bSVJWVpaioqKUmpqqI0eOKDw8vNx2rl69Kj8/vxLlGzZsUJ8+fdSxY0ft2bPHUX7x4kVFRETIYrFo7969aty4sSQpPT1d7dq1kyQdP35cAQEBFZqHJGVnZysoKEhZWVkKDAys8PtcMWZupTQL3LT5E6p6BMD/8B0Jb1LZ34+u5A63TgHXqlVLISEh5dapV6+eatWqVeE2N27cqGPHjmnEiBGO8CdJQUFBmjJlivLz8xUfH3/DdkoLf5LUu3dv1alTR0ePHnUq/+STT3Tp0iWNHz/eEf4kqXHjxnrxxReVmZmpzz//vMLzAAAA8FZunQLu06ePvv32W82YMaPMOt9++6369u1b4TY3b94sSYqNjS1xLC4uTpKUkJDg2kCvk5iYqIsXL6pbt24u9Ttt2jQlJCRo1KhRZbadl5envLw8x+vs7GxJUkFBgQoKCiRJZrNZPj4+Kioqks1mc9QtLi8sLHS6mcbHx0dms7nMcsDbFP+uF7NYrn3NFBYWOpVbrVbZbDanXYJMJpMsFkuZ5WV9bjz1earo2JlTdZoTmxXAu1Tm58kVbgXA2bNnq2vXrho1apTefPNNhYWFOY6dPHlSU6ZMUWZmpr788ssKt5mSkiJJat68eYljoaGhql27tqNORaxbt047duxQXl6eUlJS9PXXX6tu3bp6++23K9xvcdmN+p05c6amT59e6hiKV0GbNGmidu3aaf/+/UpLS3PUadmypSIjI7V7926dO3fOUd62bVuFh4dry5Ytunz5sqO8c+fOqlev3o2mD9xyq1evdnrdv39/XblyRZs2bXKUWSwWDRgwQJmZmUpMTHSUBwQEqFevXjp58qSSkpIc5SEhIerSpYtSUlKUnJzsKPf052ndunVOISImJkY1a9ZkTtV4TpJVgDepzM9Tw4YNKzwOl64BLO1GjosXL2r//v3y8fFRkyZNVL9+fZ05c0ZpaWkqKirS/fffrzvuuKPCd9LGxsZq/fr1SklJ0d13313ieKNGjZSTk6OsrKwKtfe73/1Oc+bMcby+++67tXz5cnXo0MGpXosWLZSSkqKCggLHX5PFCgoKVKNGDd1///3at29fmX2VtgIYFhamzMxMx7l4T/8lzPUt8DbvvcAKIHPynjmNfYcVQHiP+RMqdwUwNze3wtcAurQCWHyatDSFhYU6fvy4jh8/7lS+b9++Kt0vePbs2Zo9e7ZycnL03//+V6+//rq6du2qhQsXasSIER7ty9fXt9QHX1utVlmtzn+F+vj4yMfHp0Tdn4fPG5UD3ubnv+vllZvN5lJPW5RVXtbnxlOfJ1fGXlY5c/K+OQHepLI/TxUehyuVbTbbTf27PtHeSFBQkCSVucJXfIeLq2rXrq2oqCh98cUXioyMdDy8uiL9Fl/LdzP9AgAAeBuvu4ugvOvtMjIylJOTU+p1ehVlsVgUExOj3NxcfffddxXqt7zrAwEAAKobrwuAPXv2lHTtxomfW7t2rVOdm3Xq1ClJzqcLbkW/AAAA3sCtB0EXS09P16ZNm3Tq1CmnmyAcnZhMevXVVyvUVmFhoVq2bKmffvqpzAdBJycnq2nTppKk06dPKysrSw0aNHA6Rfvdd9+pY8eOJdpfu3atHnnkEfn7+ys9PV3+/v6Srt3M0qxZM1mtVh4EDbiBB0HDm/AdCW/iTQ+CdvvOgt///vd65513nK7zs9vtjhs/in+uaAC0WCxasGCB4uLi1KNHD6et4E6cOKHZs2c7wp8kTZ48WfHx8Vq0aJFj+zZJeuCBB3Tffffp/vvvV+PGjZWbm6v9+/dr69atslqtWrhwoSP8SVKdOnU0b948jRw5Uu3bt9ewYcMkXdsK7vz581qxYoVL4Q8AAMBbuXUKeP78+ZozZ45iYmL06aefym6366mnntI///lPPffcc7JYLHr88ce1ceNGl9qNiYnRtm3b1LVrV61YsULvv/++6tevr+XLl1doH2BJmjFjhho0aKCEhATNnTtXH3/8sc6cOaOxY8dq3759GjRoUIn3PPnkk1qzZo0iIyO1aNEiLV68WPfcc4/WrVunxx9/3KU5AAAAeCu3TgE/8MADOn/+vI4ePeq4fXnatGl67bXXJF3bsaNv375atmyZhgwZ4rFBVxecAoYRcQoY3oTvSHgTbzoF7NYK4OHDh9WvXz+n59Zc/yDOnj17asCAAZo9e7Y73QAAAMCD3L4LODg42PGzv7+/zp8/73S8ZcuWOnjwoLvdAAAAwEPcCoCNGjVSenq64/Vdd92lXbt2OdX54YcfnG62AAAAQNVyKwB27dpVO3fudLweOHCg9u7dq3Hjxumbb77R5MmTtWbNGvXo0cPtgQIAAMAz3HoMzMiRI3Xq1CmdOHFC4eHh+v3vf6+vv/5a8+fP14IFC2S329W0aVP9+c9/9tR4AQAA4Ca3AuCDDz6oBx980PG6du3a2rlzp7788ksdO3ZM4eHhjocuAwAAwDu4/SDon7NarYZ85AsAAEB14bEAeP78ee3bt09ZWVkKCgpSmzZtdOedd3qqeQAAAHiI2wEwNTVVL730kr755htd/0xpk8mkhx9+WHPnznXaug0AAABVy60AeOzYMXXt2lVnz55V8+bN1bVrV9WvX19nzpzRjh079NVXX2nnzp3asWOHIiIiPDVmAAAAuMGtAPjyyy/r3Llz+uCDDzRmzBiZTCbHMbvdro8++ki//vWv9fLLL+uTTz5xe7AAAABwn1sBcMOGDXr00Uc1duzYEsdMJpPGjRun1atX69tvv3WnGwAAAHiQWw+CLioq0r333ltunfvuu09FRUXudAMAAAAPcisAtm/f/ob7/B48eFAdO3Z0pxsAAAB4kFsB8M0339SaNWu0YMGCUo9/9NFHWrt2rf74xz+60w0AAAA8yKVrAF9//fUSZTExMRo3bpzmzJnjdBfw9u3bdeTIEcXFxWnDhg3q0qWLxwYNAACAm2eyX//wvhswm29uwdBkMhnyOsDs7GwFBQUpKytLgYGBldLHmLmV0ixw0+ZPqOoRAP/DdyS8SWV/P7qSO1xaAdy0aZNbAwMAAEDVcykA9uzZs7LGAQAAgFvErZtAAAAAUP24vRewJG3fvl2LFy9WUlKSsrOzFRgYqHbt2mnUqFHq1q2bJ7oAAACAh7gdAH/729/qr3/9q4rvJTGZTLLb7fr+++/18ccf66WXXtJf/vIXtwcKAAAAz3DrFHB8fLzeeecdNW/eXEuXLtWpU6dUWFio06dPa9myZWrRooXeeecd/f3vf/fUeAEAAOAmtwLg+++/r8aNG2vXrl164oknFBoaKpPJpPr162v48OHauXOnGjVqpPfee89T4wUAAICb3AqABw8e1ODBgxUUFFTq8aCgIA0ePPiG28UBAADg1qn0u4BNJlNldwEAAAAXuBUA7733Xq1atUo5OTmlHr98+bJWrVqle++9151uAAAA4EFuBcBx48YpPT1dnTt31qpVq5SZmSlJyszM1KeffqouXbooPT1dzz//vEcGCwAAAPe59RiYp59+Wnv37tW8efM0dOhQSdf2C7bZbJIku92u8ePH66mnnnJ/pAAAAPAIt58D+Ne//lWPP/54qQ+Cfuqpp9S9e3dPjBMAAAAe4lYA3LJliwIDA9W9e3eCHgAAQDXh1jWAMTEx+uijjzw1FgAAANwCbgXAevXqyc/Pz1NjAQAAwC3gVgDs27evNm/e7NgHGAAAAN7PrQD41ltv6fz58xo7dqwuXLjgqTEBAACgErl1E8iTTz6p4OBgLVy4UEuWLFGzZs1Uv379Ert/mEwmbdiwwa2BAgAAwDPcCoCbN292/JyXl6fDhw/r8OHDJeqxHRwAAID3cCsAFj/wGQAAANXHTV0DmJiYqF69eikgIEBBQUHq27evdu/e7emxAQAAoBK4vAJ44MAB9e7dW1evXnWUbdiwQTt27NDu3bt17733enSAAAAA8CyXVwDfeustXb16VX/4wx+UkZGhjIwMvfrqq7py5YpmzZpVGWMEAACAB7m8Arh161Z169ZNb7zxhqNs+vTp2rx5sxISEjw6OAAAAHieyyuAZ86cUXR0dInyTp066cyZMx4ZFAAAACqPywGwoKBAtWvXLlHu7++vgoICjwwKAAAAlcetnUAAAABQ/dzUcwCXLFminTt3OpUdPXpUktS/f/8S9U0mk7755pub6QoAAAAedlMB8OjRo47A93P//ve/S5SxEwgAAID3cDkA/vjjj5UxDgAAANwiLgfA8PDwyhgHAAAAbhFuAgEAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGIzXBsA9e/aof//+Cg4Olr+/v6Kjo7Vy5coKv//YsWOaNm2aHn30UTVq1Egmk0lNmzYt9z0mk6nMf6NHj3ZvQgAAAF7CUtUDKM2mTZsUFxcnPz8/DR8+XAEBAVq1apWGDRumkydPatKkSTdsY+vWrZo+fbp8fHzUqlUrZWRkVKjv8PDwUsNe27ZtXZwFAACAd/K6AFhYWKgxY8bIbDZry5YtjuD12muvKSoqSlOmTNGQIUMUHh5ebjs9evRQYmKi2rRpo5o1a8rPz69C/Tdt2lTTpk1zcxYAAADey+tOAW/cuFHHjh3TiBEjnFbdgoKCNGXKFOXn5ys+Pv6G7URERCg6Olo1a9asxNECAABUP163Arh582ZJUmxsbIljcXFxkqSEhIRK6//SpUv66KOPlJmZqTvuuENdu3ZV69atK60/AACAW83rAmBKSookqXnz5iWOhYaGqnbt2o46lWHfvn0aN26cU1m/fv0UHx+vevXqlfvevLw85eXlOV5nZ2dLkgoKClRQUCBJMpvN8vHxUVFRkWw2m6NucXlhYaHsdruj3MfHR2azucxywNsU/64Xs1iufc0UFhY6lVutVtlsNhUVFTnKTCaTLBZLmeVlfW489Xmq6NiZU3Wak0mAN6nMz5MrvC4AZmVlSbp2yrc0gYGBjjqeNmnSJA0ePFgtWrRQjRo19MMPP+iNN97QmjVr9PDDDysxMVE+Pj5lvn/mzJmaPn16ifJ169apVq1akqQmTZqoXbt22r9/v9LS0hx1WrZsqcjISO3evVvnzp1zlLdt21bh4eHasmWLLl++7Cjv3LnzDQMpUBVWr17t9Lp///66cuWKNm3a5CizWCwaMGCAMjMzlZiY6CgPCAhQr169dPLkSSUlJTnKQ0JC1KVLF6WkpCg5OdlR7unP07p165xCRExMjGrWrMmcqvGcJKsAb1KZn6eGDRtWeBwm+/V/XnmB2NhYrV+/XikpKbr77rtLHG/UqJFycnJcDoF+fn4KDQ1VamqqS++z2Wzq1auXEhIStGrVKj322GNl1i1tBTAsLEyZmZkKDAyU5Pm/hMfMdWk6QKV77wVWAJmT98xp7DusAMJ7zJ9QuSuAubm5CgoKUlZWliN3lMXrVgCLV/7KCnjZ2dmqU6fOLRuP2WzWmDFjlJCQoO3bt5cbAH19feXr61ui3Gq1ymp1/ivUx8en1NXE4i+yipYD3ubnv+vllZvN5lJPW5RVXtbnxlOfJ1fGXlY5c/K+OQHepLI/TxUex02/s5IUX/tX2nV+GRkZysnJKfX6wMpUt25dSVJubu4t7RcAAKAyeF0A7Nmzp6Rr18393Nq1a53q3Cq7du2SpBvuJAIAAFAdeF0A7N27tyIiIrRs2TKniyGzsrI0Y8YM1ahRQ6NGjXKUnz59WocPH3b7xpADBw6UuK5Eknbs2KFZs2bJarXq8ccfd6sPAAAAb+B1F5ZZLBYtWLBAcXFx6tGjh9NWcCdOnNDs2bOdVuImT56s+Ph4LVq0yGkLt8zMTP3ud79zvC4oKFBmZqZTndmzZztO786ZM0fffPONunXrprCwMFmtVh08eFDr1q2TyWTSu+++q7vuuquypw8AAFDpvC4AStdu6d+2bZumTp2qFStWqKCgQK1bt9asWbM0bNiwCrWRk5NTYseQ3Nxcp7Jp06Y5AuDAgQN16dIl7du3T+vXr1d+fr5CQ0M1fPhwTZgwQVFRUZ6bIAAAQBXyusfA3E6ys7MrfDv2zeIxMPA28ydU9QiA/+E7Et6ksr8fXckdXncNIAAAACoXARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDAEQAAAAIMhAAIAABgMARAAAMBgCIAAAAAGQwAEAAAwGAIgAACAwRAAAQAADIYACAAAYDBeGwD37Nmj/v37Kzg4WP7+/oqOjtbKlStdaiMvL0+vv/66mjdvLj8/PzVs2FBjx47V2bNny3zP0qVLFRUVJX9/f9WpU0cPP/yw/vOf/7g7HQAAAK/hlQFw06ZN6tq1q7Zt26ahQ4fqueeeU0ZGhoYNG6Y5c+ZUqA2bzaaBAwdq6tSpqlu3riZMmKDOnTtrwYIF6ty5s86dO1fiPW+++aaefPJJnT17Vs8995wef/xxbdmyRV26dNH27ds9PU0AAIAqYbLb7faqHsT1CgsLFRkZqfT0dO3cuVNt27aVJGVlZSkqKkqpqak6cuSIwsPDy21n0aJFeuaZZ/TEE09o6dKlMplMkqQPPvhAzz//vMaOHasPP/zQUT8lJUX33HOPIiIitHv3bgUFBUmSkpKSFB0drYiICP3www8ymyuembOzsxUUFKSsrCwFBga6+F+iYsbMrZRmgZs2f0JVjwD4H74j4U0q+/vRldzhdSuAGzdu1LFjxzRixAhH+JOkoKAgTZkyRfn5+YqPj79hO/Pnz5ckzZw50xH+JGncuHGKiIjQ0qVLdeXKFUf5okWLVFhYqD/84Q+O8CdJbdu21RNPPKFDhw5p27ZtHpghAABA1fK6ALh582ZJUmxsbIljcXFxkqSEhIRy27h69ap27dqlli1bllgpNJlM6tu3r3Jzc/Xdd995tF8AAIDqwFLVA/i5lJQUSVLz5s1LHAsNDVXt2rUddcpy7Ngx2Wy2Utu4vu2UlBR1797d8XPt2rUVGhpabv3y5OXlKS8vz/E6KytLknThwgUVFBRIksxms3x8fFRUVCSbzeaoW1xeWFio68/K+/j4yGw2l1mef7XcIQG33PnzBU6vLZZrXzOFhYVO5VarVTabTUVFRY4yk8kki8VSZnlZnxtPfZ6KP6c3Gjtzqj5zyr9qEuAtsrNVqZ+n3NxcSVJFru7zugBYHJquPw17vcDAQEcdd9q4vl7xz/Xq1atw/dLMnDlT06dPL1HerFmzct8H3E7+PrmqRwAA3ulWfT9evny5zAxUzOsCYHU2efJkTZw40fHaZrPpwoULuvPOO52uQ4T3yc7OVlhYmE6ePFlpN+wAQHXE92P1YbfbdfnyZTVs2PCGdb0uABYn1rJW27Kzs1WnTh2327i+XvHPrtQvja+vr3x9fZ3KgoODy30PvEtgYCBfcABQCr4fq4cbZZViXncTSHnX22VkZCgnJ6fMa/uKRUREyGw2l3nNXmnXGTZv3lw5OTnKyMioUH0AAIDqyusCYM+ePSVJ69atK3Fs7dq1TnXKUrNmTUVFRSk5OVknTpxwOma327V+/Xr5+/urY8eOHu0XAACgOvC6ANi7d29FRERo2bJlSkpKcpRnZWVpxowZqlGjhkaNGuUoP336tA4fPlzi9O3YsWMlXbsu7/q7YT788EMdP35cv/zlL1WzZk1H+dNPPy2LxaI333zTqa2kpCT985//VKtWrdStWzdPTxdewtfXV1OnTi1xCh8AjI7vx9uT1+0EIl3bCi4uLk5+fn4aPny4AgICtGrVKp04cUKzZ8/WpEmTHHVHjx6t+Ph4LVq0SKNHj3aU22w29e/fX2vXrlV0dLR69uypo0eP6rPPPlPTpk21a9cuhYSEOPX75ptv6pVXXlF4eLgGDx6sy5cva/ny5crPz9eGDRvUtWvXW/WfAAAAoNJ43QqgJMXExGjbtm3q2rWrVqxYoffff1/169fX8uXLncJfecxms7788ktNmzZN586d09tvv63t27fr2WefVWJiYonwJ0l/+MMftGTJEoWEhOj999/XypUr1b17d+3YsYPwBwAAbhteuQIIAACAyuOVK4AAAACoPARAAAAAgyEAAgAAGAwBEAAAwGAIgDCU4nueuPcJAGBkBEAYislkkt1ul8lkUkZGhmw2W1UPCQCAW85S1QMAbpXCwkJt375dCxcu1JEjR2Q2m1WzZk21bdtWjz32mLp06VLVQwQA4JbgOYAwjNmzZ+uNN97Q5cuXddddd8lisSg5OdlxPDIyUmPHjtXw4cMVGhpahSMFgKpVfKYEty8CIAzhxx9/VOvWrdW+fXvFx8erRo0aql+/vjIyMvTVV1/p008/1ebNmyVJvXr10p/+9Ce1b9++agcNALfIlStXlJaWpiZNmqhmzZpVPRzcAgRAGMJrr72mDz/8UMuWLVPv3r0llfwL98CBA5o9e7ZWrlyp8PBwLV26VB06dKiqIQPALfPWW29p1apVeuyxxxQdHa2WLVuqfv368vHxKfM9mZmZCg4OlsXC1WTVEQEQhjB48GAlJSVp06ZNatKkiQoLC2WxWGS322Wz2Zy+5N555x399re/1VNPPaVFixZV4agB4NZo3LixTp06JR8fHwUFBalLly6KjY1Vp06dFBERoTvvvNOpfm5urqZNm6bz589rwYIFMpu5p7S6IbbDENq1a6fPP/9cOTk5kuT4i9VkMjnCX/GK4EsvvaStW7dq48aNOn78uCIiIqps3ABQ2Y4cOaKsrCx17txZI0aM0Pr165WYmKivv/5aTZo00YMPPqg+ffqoXbt2atSokYKDg/XDDz9o/vz5evDBBwl/1RQBEIYQExMjSfrlL3+pOXPmqFu3bqpRo0aJekVFRfLx8VHLli21Zs0aR2AEgNvVkSNHdPXqVcXGxuqFF17Qww8/rOTkZCUmJmrjxo1atWqVli5dqnvuuUe9evVSv379tGHDBmVnZ2vMmDFVPXzcJE4BwxCKior08ssv6y9/+YsiIyP1wgsvaMiQIapfv36JuhcvXtSECRO0Zs0anT17tgpGCwC3zqeffqqhQ4dq+fLlGjp0qKO8oKBAJ06c0L59+7R161Zt3rxZhw4dktVqld1ul6+vry5cuFCFI4c7CIAwlA8//FB//vOfdfz4cTVs2FCDBg3SQw89pLCwMPn4+Cg4OFh/+9vfNHfuXP3617/WnDlzqnrIAFCp7Ha7Dh8+LD8/PzVr1qzUR8Dk5ubqyJEjSk5O1qJFi7R+/Xq9+OKL+utf/1pFo4a7CIAwFLvdrqNHj2r+/Plavny50tPTJUn16tWT1WrV6dOnZbPZ9MQTT2jWrFlq3LhxFY8YAKpOaWHwN7/5jebNm6fvv/9e7dq1q6KRwV0EQBhWbm6udu/era+++kqnTp3S2bNnFRgYqKFDh2rw4MHy8/Or6iECgFew2Wwym81KTU3VwIEDdfHiRaWlpVX1sOAGbgKBYfn7+ysmJkYxMTEqKCiQ1Wqt6iEBgFcqvtP3p59+UkFBgX79619X8YjgLlYAAQBAhdjtdqWnp+uOO+6Qv79/VQ8HbiAAAgAAGAxPbwQAADAYAiAAAIDBEAABAAAMhgAIAABgMARAAAAAgyEAAgAAGAwBEAAAwGAIgAAAAAZDAAQAADCY/wflpxjFa1iM3wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# execute the quantum circiut (coin moves) and identify the winner\n",
    "\n",
    "job = execute(qc, backend, 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 fundamentaly 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 formlism 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.9.13"
  },
  "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
}