final notebook qpu.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Purple Cats\n",
        "\n",
        "## Objective\n",
        "\n",
        "This videogame aims to learn how a quantum circuit works and to do additions and subtractions from Draper's method, as we believe that with an application can help people learn about quantum computation.\n",
        "\n",
        "## Context\n",
        "In a laboratory dedicated to problems of quantum mechanics they have 5 cats as pets, some are green and others are purple. One of the research experiments were in several boxes called QFT, QFT$^{-1}$ and P with certain dephase, one day when they left the cats they forgot to keep the boxes in a place where the cats could not see them, consequently the cats got into the boxes and when the researchers arrived they realized that the cats were green. In this game we must consider the proper way to arrange the boxes in such a way that we find the purple cats in a specific porden since they only know the number of the cat by the collar they wear. \n",
        "\n",
        "\n",
        "![init_cats](videogame_Img/init_cat.png)\n",
        "\n",
        "\n",
        "## Teorical Part\n",
        "\n",
        "Thisp orject works using the Draper idea of the adder, that using the Amplitude Amplification, The central idea behind amplitude amplification is to amplify the probability of a desired outcome occurring by performing a sequence of reflections. These reflections rotate the initial state closer towards a desired target state, often called a marked state\n",
        " \n",
        "Quantum Fourier Transform\n"
      ],
      "metadata": {},
      "id": "ab0c0e26"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Rules\n",
        "\n",
        "\n",
        "At the time the cats were found, only two boxes QFT and QFT$^{-1}$ were not moved, the first one at the beginning and the second one at the end, as shown in the following figure.\n",
        "\n",
        "![template.png](videogame_Img/template.png)\n",
        "\n",
        "\n",
        "You have the following boxes in an unordered manner:\n",
        "\n",
        "- 5 box with $P({\\pi})$\n",
        "- 4 box with $P(\\frac{\\pi}{2})$\n",
        "- 3 box with $P(\\frac{\\pi}{4})$\n",
        "- 2 box with $P(\\frac{\\pi}{8})$\n",
        "- 1 box with $P(\\frac{\\pi}{16})$\n",
        "\n",
        "\n",
        "\n",
        "Find the way to find the purple cats by following the structure , where the boxes must be arranged in a row order for the cats, it is also possible that not all boxes can be used.\n",
        "\n",
        "\n",
        "You can select or not to put one or more boxes\n",
        "\n"
      ],
      "metadata": {},
      "id": "d03f849f"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Hints\n",
        "\n",
        "The researchers found the following 4 answers, with this information helping to find purple cats.\n",
        "\n",
        "\n",
        "\n",
        "![ex_10000.png](videogame_Img/ex_10000.png)"
      ],
      "metadata": {},
      "id": "38ded684"
    },
    {
      "cell_type": "markdown",
      "source": [
        "![ex_01000.png](videogame_Img/ex_01000.png)"
      ],
      "metadata": {},
      "id": "75b121e6"
    },
    {
      "cell_type": "markdown",
      "source": [
        "![ex_00100.png](videogame_Img/ex_00100.png)"
      ],
      "metadata": {},
      "id": "4271c794"
    },
    {
      "cell_type": "markdown",
      "source": [
        "![ex_00010.png](videogame_Img/ex_00010.png)"
      ],
      "metadata": {},
      "id": "36cae710"
    },
    {
      "cell_type": "markdown",
      "source": [
        "![ex_00001.png](videogame_Img/ex_00001.png)"
      ],
      "metadata": {},
      "id": "2f427260"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Code to choose the random value\n",
        "\n",
        "\n",
        "Using the noise model methods of qiskit we can added some noise like i na real hardware and general a quantum circuit using Hadamards and Cnots gates to generate a random circuit. With the nosie model we cam  consider the noise in the gates X"
      ],
      "metadata": {},
      "id": "13b4ab44"
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Qiskit libraries \n",
        "from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute, QuantumRegister, ClassicalRegister\n",
        "from qiskit.tools.jupyter import *\n",
        "from qiskit.visualization import *\n",
        "from qiskit.circuit.library import QFT\n",
        "#Qsharp libraries\n",
        "from azure.quantum.qiskit import AzureQuantumProvider\n",
        "import qsharp\n",
        "import qsharp.experimental\n",
        "qsharp.experimental.enable_noisy_simulation()\n",
        "qsharp.experimental.get_noise_model"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 8,
          "data": {
            "text/plain": "<function qsharp.experimental.get_noise_model()>"
          },
          "metadata": {}
        }
      ],
      "execution_count": 8,
      "metadata": {},
      "id": "3e1abfb2"
    },
    {
      "cell_type": "code",
      "source": [
        "provider = AzureQuantumProvider(\n",
        "  resource_id=\"/subscriptions/b1d7f7f8-743f-458e-b3a0-3e09734d716d/resourceGroups/aq-hackathons/providers/Microsoft.Quantum/Workspaces/aq-hackathon-01\",\n",
        "  location=\"East US\"\n",
        ")"
      ],
      "outputs": [],
      "execution_count": 9,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "3fdac236-3e93-4e6c-83b7-4f1d45bbcc6b"
    },
    {
      "cell_type": "code",
      "source": [
        "# generate the circuti that do a QRNG\n",
        "def random_number(): \n",
        "\n",
        "    qrng = qsharp.compile(\"\"\"\n",
        "    open Microsoft.Quantum.Arrays;\n",
        "    open Microsoft.Quantum.Measurement;\n",
        "        \n",
        "    operation RandomNumber() : Result[] {\n",
        "        use register = Qubit[5] {\n",
        "            // Set qubits in superposition.\n",
        "            for index in 0 .. 10  {\n",
        "    \n",
        "            ApplyToEachA(H, register);\n",
        "            CNOT(register[0], register[1]);\n",
        "            CNOT(register[0], register[2]);\n",
        "            CNOT(register[0], register[3]);\n",
        "            CNOT(register[0], register[4]);\n",
        "\n",
        "            CNOT(register[1], register[2]);\n",
        "            CNOT(register[1], register[3]);\n",
        "            CNOT(register[1], register[4]);\n",
        "\n",
        "            CNOT(register[2], register[3]);\n",
        "            CNOT(register[3], register[4]);\n",
        "            \n",
        "            CNOT(register[3], register[4]);\n",
        "            X(register[0]);\n",
        "            }\n",
        "            // Measure all qubits and return.\n",
        "            return ForEach(MResetZ, register);\n",
        "        }\n",
        "    }\n",
        "    \"\"\")\n",
        "    s = \"\"\n",
        "    for i in qrng.simulate():\n",
        "        s = s+str(i)\n",
        "    return s"
      ],
      "outputs": [],
      "execution_count": 29,
      "metadata": {},
      "id": "5dd8bf79"
    },
    {
      "cell_type": "code",
      "source": [],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "666d45a2-c31e-4e80-a30a-9abec6ebee0e"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### proof the random number\n",
        "\n",
        "We can call the method random_number() and return a bitstring with the expect output, where \n",
        "- 0 is equal a green cat\n",
        "- 1 is equal a purple cat"
      ],
      "metadata": {},
      "id": "9fadab6e"
    },
    {
      "cell_type": "code",
      "source": [
        "purple_cats_numer = random_number()\n",
        "purple_cats_numer"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 30,
          "data": {
            "text/plain": "'00100'"
          },
          "metadata": {}
        }
      ],
      "execution_count": 30,
      "metadata": {},
      "id": "b3cffb67"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Design the algorithm for the videogames\n",
        "\n",
        "We following the idea of the Draper addition, is neccesary use the QFT and  the inverse QFT, and for generate the data we can use the gates P, this is\n",
        "\n",
        "$$\\begin{split}P(\\lambda) =\n",
        "    \\begin{pmatrix}\n",
        "        1 & 0 \\\\\n",
        "        0 & e^{i\\lambda}\n",
        "    \\end{pmatrix}\\end{split}$$\n",
        "    \n",
        "    \n",
        "Whit this in a certain order of  $\\lambda$ is important consider the next expression \n",
        "\n",
        "$$e^{i 2 \\pi / 2^{n}}$$\n",
        "\n",
        "\n",
        "- if $n = 1$ we can obtain  $e^{i  \\pi }$\n",
        "\n",
        "- if $n = 2$ we can obtain  $e^{i  \\frac{\\pi} {2}}$\n",
        "\n",
        "- if $n = 3$ we can obtain  $e^{i  \\frac{\\pi} {4}}$\n",
        "\n",
        "- if $n = 4$ we can obtain  $e^{i  \\frac{\\pi} {8}}$\n",
        "\n",
        "- if $n = 5$ we can obtain  $e^{i  \\frac{\\pi} {16}}$\n",
        "\n",
        "and we only have 5 cats, so is the same values for the boxes"
      ],
      "metadata": {},
      "id": "a80fa6dc"
    },
    {
      "cell_type": "code",
      "source": [
        "#convert  integer value to bin value for the quantum circuit\n",
        "def add_value(qc,data_qubits,const): \n",
        "    #a = bin(const)[2:]\n",
        "    #while len(a) < data_qubits:\n",
        "    #    a = '0'+a\n",
        "    a=const[::-1]\n",
        "    list_a = [0]*data_qubits\n",
        "    for i in range(data_qubits): \n",
        "        if a[i] =='1':\n",
        "            k = 0\n",
        "            for j in range(i,data_qubits):\n",
        "                list_a[data_qubits-j-1] +=np.pi/float(2**(k)) \n",
        "                k+=1\n",
        "            \n",
        "    for i in range(data_qubits):\n",
        "        if list_a[i] != 0:\n",
        "            qc.p(list_a[i],i)\n",
        "            k+=1\n"
      ],
      "outputs": [],
      "execution_count": 12,
      "metadata": {},
      "id": "013101a4"
    },
    {
      "cell_type": "code",
      "source": [
        "def qft(data_qubits: int, approximation_degree: int = 1):\n",
        "    qr = QuantumRegister(data_qubits)\n",
        "    qc = QuantumCircuit(qr)\n",
        "\n",
        "    for target in reversed(range(data_qubits)):\n",
        "        qc.h(target)\n",
        "        for k, control in enumerate(reversed(range(target)), start=2):\n",
        "            if k > (data_qubits - approximation_degree):\n",
        "                continue\n",
        "            qc.cp(2 * np.pi / (2 ** k), control, target)\n",
        "\n",
        "    return qc"
      ],
      "outputs": [],
      "execution_count": 34,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "5d521b86-5377-4942-9a85-e7259fa5dfd3"
    },
    {
      "cell_type": "code",
      "source": [
        "def find_purple_cats(pi,pi_2,pi_4,pi_8,pi_16,init_state=0):\n",
        "    num_cats = 5\n",
        "    quantum_cats = QuantumRegister(num_cats, \"cats\")\n",
        "    purple_cats = ClassicalRegister(num_cats,\"purple_cats\")\n",
        "    qc = QuantumCircuit(quantum_cats,purple_cats)\n",
        "\n",
        "    len_pi = len(pi)\n",
        "    len_pi_2 = len(pi_2)\n",
        "    len_pi_4 = len(pi_4)\n",
        "    len_pi_8 = len(pi_8)\n",
        "    len_pi_16 = len(pi_16)\n",
        "\n",
        "    qc.h(range(num_cats))\n",
        "    \n",
        "    if init_state != 0:\n",
        "        add_value(qc,5,init_state)\n",
        "    \n",
        "    for i in range(len_pi-1,-1,-1):\n",
        "        if pi[i]!= 0 :\n",
        "            qc.p(pi[i]*np.pi,i)\n",
        "            \n",
        "    for i in range(len_pi_2-1,-1,-1):\n",
        "        if pi_2[i]!= 0 :\n",
        "            qc.p(pi_2[i]*np.pi/2,i)\n",
        "            \n",
        "    for i in range(len_pi_4-1,-1,-1):\n",
        "        if pi_4[i]!= 0 :\n",
        "            qc.p(pi_4[i]*np.pi/4,i)\n",
        "\n",
        "            \n",
        "    for i in range(len_pi_8-1,-1,-1):\n",
        "        if pi_8[i]!= 0 :\n",
        "            qc.p(pi_8[i]*np.pi/8,i)\n",
        "            \n",
        "            \n",
        "    for i in range(len_pi_16-1,-1,-1):\n",
        "        if pi_16[i]!= 0 :\n",
        "            qc.p(pi_16[i]*np.pi/16,i)   \n",
        "    \n",
        "    qc = qc.compose(QFT(num_qubits=num_cats,inverse=True),quantum_cats)\n",
        "    #qc.append(qft(5), quantum_cats)\n",
        "    qc.measure(quantum_cats,purple_cats)\n",
        "    return qc"
      ],
      "outputs": [],
      "execution_count": 38,
      "metadata": {},
      "id": "2610a7c5"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# How to play \n",
        "\n",
        "## case 1:\n",
        "\n",
        "if you want to modify the **first green cat** to a **purple cat** is equal to **|00000> to |00001>**, the configuration is posible with the following code:\n",
        "\n",
        "```\n",
        "pi[4] = 1\n",
        "pi_2[3] = 1\n",
        "pi_4[2] = 1\n",
        "pi_8[1] = 1\n",
        "pi_16[0] = 1\n",
        "\n",
        "```\n",
        "\n",
        "## case 2:\n",
        "\n",
        "if you want to modify the **second green cat** to a **purple cat** is equal to **|00000> to |00010>**, the configuration is posible with the following code:\n",
        "\n",
        "```\n",
        "pi[3] = 1\n",
        "pi_2[2] = 1\n",
        "pi_4[1] = 1\n",
        "pi_8[0] = 1\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "## case 3:\n",
        "\n",
        "if you want to modify the **third green cat** to a **purple cat** is equal to **|00000> to |00100>**, the configuration is posible with the following code:\n",
        "\n",
        "```\n",
        "pi[2] = 1\n",
        "pi_2[1] = 1\n",
        "pi_4[0] = 1\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "## case 4:\n",
        "\n",
        "if you want to modify the **fourth green cat** to a **purple cat** is equal to **|00000> to |01000>**, the configuration is posible with the following code:\n",
        "\n",
        "```\n",
        "pi[1] = 1\n",
        "pi_2[0] = 1\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "## case 5:\n",
        "\n",
        "if you want to modify the **fifth green cat** to a **purple cat** is equal to **|00000> to |10000>**, the configuration is posible with the following code:\n",
        "\n",
        "```\n",
        "pi[0] = 1\n",
        "```"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "d23b059f-4e40-402c-a177-9717a3484a0e"
    },
    {
      "cell_type": "code",
      "source": [
        "# init variables\n",
        "pi = [0]*5\n",
        "pi_2 = [0]*4\n",
        "pi_4 = [0]*3\n",
        "pi_8 = [0]*2\n",
        "pi_16 = [0]\n",
        "\n",
        "\n",
        "# select the values \n",
        "\n",
        "\n",
        "\n",
        "pi[2] = 1\n",
        "pi_2[1] = 1\n",
        "pi_4[0] = 1\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "qc = find_purple_cats(pi,pi_2,pi_4,pi_8,pi_16)\n",
        "#qc.draw(\"mpl\")"
      ],
      "outputs": [],
      "execution_count": 51,
      "metadata": {},
      "id": "90b41ee8"
    },
    {
      "cell_type": "code",
      "source": [
        "qc = find_purple_cats(pi,pi_2,pi_4,pi_8,pi_16)\n",
        "counts = execute(qc,provider.get_backend('ionq.simulator')).result().get_counts()\n",
        "\n",
        "sol=list(counts.keys())[0]\n",
        "\n",
        "print(\"your answer is \",sol)\n",
        "if purple_cats_numer == sol:\n",
        "    print(\"You Got it\")\n",
        "else:\n",
        "    print(\"Try again\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "............your answer is  00100\nYou Got it\n"
        }
      ],
      "execution_count": 52,
      "metadata": {},
      "id": "096bc785"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## using a ionq qpu\n",
        "\n",
        "we compare the result with a real hardware"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "8b4bdd13-5a86-492d-88bb-84357e211364"
    },
    {
      "cell_type": "code",
      "source": [
        "qc = find_purple_cats(pi,pi_2,pi_4,pi_8,pi_16)\n",
        "\n",
        "target_basis = ['rx', 'ry', 'rz', 'h', 'cx']\n",
        "decomposed = transpile(qc,\n",
        "                       basis_gates=target_basis, \n",
        "                       optimization_level=0) \n",
        "\n",
        "qpu_backend = provider.get_backend(\"ionq.qpu\")\n",
        "qpu_job = qpu_backend.run(decomposed, shots=1024)\n",
        "job_id = qpu_job.id()\n",
        "\n",
        "# Get the job results (this method also waits for the Job to complete):\n",
        "import operator \n",
        "result = qpu_job.result()\n",
        "counts = {format(n, \"03b\"): 0 for n in range(8)}\n",
        "counts.update(result.get_counts(qc))\n",
        "sol= max(counts.items(), key=operator.itemgetter(1))[0]\n",
        "print(\"your answer is \",sol)\n",
        "if purple_cats_numer == sol:\n",
        "    print(\"You Got it\")\n",
        "else:\n",
        "    print(\"Try again\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "..........................................................your answer is  00100\nYou Got it\n"
        }
      ],
      "execution_count": 53,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "584bb779-a1f6-428a-90be-57d3ff050052"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Another modality\n",
        "\n",
        "There are two more considerations that if the purple cats are not the same as the ones we expect, then we must reconvert this, for this, we also have that the P-boxes can be positive or negative."
      ],
      "metadata": {},
      "id": "feb0be36"
    },
    {
      "cell_type": "code",
      "source": [
        "init_state = random_number()\n",
        "\n",
        "print(\"Initial state for the cats are\",init_state)\n",
        "print(\"The objective value is \", purple_cats_numer)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Initial state for the cats are 10000\nThe objective value is  00100\n"
        }
      ],
      "execution_count": 54,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "d67edf66-73ad-4007-8b31-075ddef80702"
    },
    {
      "cell_type": "markdown",
      "source": [
        "consider the initial state  we need to find the combination for the purple cats output, sometimes is add or subs so one binary number"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "1b09d05a-e281-418a-aae2-a239bad95fa4"
    },
    {
      "cell_type": "code",
      "source": [
        "# init variables\n",
        "pi = [0]*5\n",
        "pi_2 = [0]*4\n",
        "pi_4 = [0]*3\n",
        "pi_8 = [0]*2\n",
        "pi_16 = [0]\n",
        "\n",
        "\n",
        "# select the values \n",
        "\n",
        "\n",
        "pi[3] = -1\n",
        "pi_2[2] = -1\n",
        "pi_4[1] = -1\n",
        "pi_8[0] = -1\n",
        "\n",
        "\n",
        "\n"
      ],
      "outputs": [],
      "execution_count": 23,
      "metadata": {
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "8d45f68c-e922-45de-829b-f4edb55dfad5"
    },
    {
      "cell_type": "code",
      "source": [
        "qc = find_purple_cats(pi,pi_2,pi_4,pi_8,pi_16,init_state)\n",
        "counts = execute(qc,provider.get_backend('ionq.simulator')).result().get_counts()\n",
        "sol=list(counts.keys())[0]\n",
        "\n",
        "print(\"your answer is \",sol)\n",
        "if purple_cats_numer == sol:\n",
        "    print(\"You Got it\")\n",
        "else:\n",
        "    print(\"Try again\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "............your answer is  01110\nTry again\n"
        }
      ],
      "execution_count": 24,
      "metadata": {},
      "id": "18952201"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Authors\n",
        "- Alberto Maldonado Romo\n",
        "- Hanah Rahman\n",
        "- Jesse Fonseca \n",
        "- Karime Mejia\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "9c18a470-5c63-47f2-94bf-0d53bfd4eaae"
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3 (ipykernel)"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.12",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernel_info": {
      "name": "python3"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}