Task3_QCS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.8.5"
    },
    "colab": {
      "name": "Task3_QCS.ipynb",
      "provenance": [],
      "machine_shape": "hm"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xNKy56c9GE9J"
      },
      "source": [
        "# Task 3 -  Quantum Circuit Simulator \n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ne1v06YBKQOB"
      },
      "source": [
        "\r\n",
        "**Introduction**\r\n",
        "\r\n",
        "Simulation of quantum systems on classical computers is a crucial task for the verification of quantum devices and the evaluation of quantum algorithms. \r\n",
        "The goal of this project is to implement a simple quantum circuit simulator. More specifically, a simulator that can perform the following tasks.\r\n",
        "\r\n",
        "- initialize state\r\n",
        "\r\n",
        "- read program, and for each gate:\r\n",
        "    - calculate matrix operator\r\n",
        "    - apply operator (modify state)\r\n",
        "    \r\n",
        "- perform multi-shot measurement of all qubits using weighted random technique\r\n",
        "\r\n",
        "**Qubit**\r\n",
        "\r\n",
        "The Qubit is the basic unit of quantum information and a fundamental piece for quantum computing. It is a two-state quantum-mechanical system, and can be represented by a linear superposition of two orthonormal basis states or basis vectors. The vector representation of a Qubit is the following: \r\n",
        "\r\n",
        "${\\vert a\\rangle =v_{0} \\vert 0\\rangle +v_{1} \\vert 1\\rangle \\rightarrow {\\begin{bmatrix}v_{0}\\\\v_{1}\\end{bmatrix}}}$\r\n",
        "\r\n",
        "Meanwhile a combined state of multiple qubits is the tensor product of their states. For example, the vector representation of two Qubits is:\r\n",
        "\r\n",
        "${\\displaystyle \\vert ab\\rangle =\\vert a\\rangle \\otimes \\vert b\\rangle =v_{00}\\vert 00\\rangle +v_{01}\\vert 01\\rangle +v_{10}\\vert 10\\rangle +v_{11}\\vert 11\\rangle \\rightarrow {\\begin{bmatrix}v_{00}\\\\v_{01}\\\\v_{10}\\\\v_{11}\\end{bmatrix}}}$\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z9kyToEpaNDG"
      },
      "source": [
        "**Quantum gates**\r\n",
        "\r\n",
        "In the quantum circuit model, a quantum logic gate is the basic quantum circuit operating in a determined number of qubits. Quantum gates are represented by unitary matrices. A quantum gate which acts on $n$ qubits is represented by a $2^n \\times 2^n$ unitary matrix. The most common quantum gates operate with one or two qubits, just like their classical counterpart. \r\n",
        "\r\n",
        "\r\n",
        "The action of a quantum gate is calculated by multiplying the vector ${\\vert a_1\\rangle }$ by the matrix $U$ representing the quantum gate. The result is a new quantum state ${\\vert a_2\\rangle }$ calculated in the following way.\r\n",
        "\r\n",
        "$U {\\vert a_1\\rangle } = {\\vert a_2\\rangle }$\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fu_2ycjeTDrr"
      },
      "source": [
        "\r\n",
        "**Numpy**\r\n",
        "\r\n",
        "To represent qubits or quantum gates in a classical computer, the usual way is to use arrays or matrices of complex numbers. For example in python, we commonly implement these quantum entities with the help of powerful frameworks such as Numpy. This framework is designed to work with multi-dimensional arrays and matrices, and to perform high-level mathematical functions with them.\r\n",
        "However, although Numpy is designed to take advantage of multiple CPU cores to perform its calculations, it neglects to take advantage of the powerful GPUs available today to speed up linear algebra operations.\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSD9y2LQ0QN8"
      },
      "source": [
        "**Pytorch**\r\n",
        "\r\n",
        "PyTorch is an open source framework for machine learning. It is based on Torch and is commonly used for the development and research of deep neural networks. PyTorch was built for two objectives: Development of Deep Neural Networks, and Tensor computing (like NumPy but with acceleration via graphic processing units). \r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EgQfy93ZBUPw"
      },
      "source": [
        "**Proposed Approach**\r\n",
        "\r\n",
        "To implement a quantum circuit simulator, we need a framework to efficiently perform calculations with multi-dimensional arrays (Such as Numpy or Pytorch). Next, to take advantage of the speed up provided by modern GPUs, we chose PyTorch to buld our architecture. We tested and developed our simulator using Google Colab and a Nvidia V100 as GPU. This GPU lets us work with circuits of 14 qubits before running out of memory. Finally, we implemented the possibility to run circuits in CPU mode as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QF4yg89lWGm5"
      },
      "source": [
        "# Quantum GPU Circuit Simulator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJjzVWO8GE9V"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data.sampler import WeightedRandomSampler\n",
        "from collections import Counter, OrderedDict\n",
        "import numpy as np\n",
        "import math  \n",
        "\n",
        "# We define the elemental quantum gates\n",
        "\n",
        "#Hadamard\n",
        "H_t = torch.tensor([\n",
        "[1/np.sqrt(2), 1/np.sqrt(2)],\n",
        "[1/np.sqrt(2), -1/np.sqrt(2)]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Pauli-X\n",
        "X_t = torch.tensor([\n",
        "[0, 1],\n",
        "[1, 0]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Pauli-Y\n",
        "Y_t = torch.tensor([\n",
        "[0, -1j],\n",
        "[1j, 0]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Pauli-Z\n",
        "Z_t = torch.tensor([\n",
        "[1, 0],\n",
        "[0, -1]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Swap gate\n",
        "Swap_t = torch.tensor([\n",
        "[1, 0, 0, 0],\n",
        "[0, 0, 1, 0],\n",
        "[0, 1, 0, 0],\n",
        "[0, 0, 0, 1]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Projector in 0\n",
        "P0x0_t = torch.tensor([\n",
        "[1, 0],\n",
        "[0, 0]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "#Projector in 1\n",
        "P1x1_t = torch.tensor([\n",
        "[0, 0],\n",
        "[0, 1]\n",
        "],  dtype=torch.cfloat)\n",
        "\n",
        "def kron(a, b):\n",
        "    #return the kronecker product between two tensors\n",
        "    assert a.dim() == b.dim()\n",
        "    a_view_shape = []\n",
        "    b_view_shape = []\n",
        "    ab_view_shape = []\n",
        "    for i in range(a.dim()):\n",
        "        a_view_shape.append(a.size(i))\n",
        "        a_view_shape.append(1)\n",
        "        b_view_shape.append(1)\n",
        "        b_view_shape.append(b.size(i))\n",
        "        ab_view_shape.append(a.size(i) * b.size(i))\n",
        "    return (a.reshape(a_view_shape) * \n",
        "            b.reshape(b_view_shape)).reshape(ab_view_shape)\n",
        "\n",
        "def get_ground_state(num_qubits):\n",
        "    # return vector of size 2**num_qubits with all zeroes except first element which is 1\n",
        "    state = torch.zeros(1, 2**num_qubits, dtype=torch.cfloat)\n",
        "    state[0,0] =  1+0j\n",
        "    return state\n",
        "\n",
        "def formulate_u3(parameters):\n",
        "    #return the matrix definition of the u3 gate given theta, phi and lambda values\n",
        "    theta = float(parameters[\"theta\"])\n",
        "    phi = float(parameters[\"phi\"])\n",
        "    lam = float(parameters[\"lambda\"])\n",
        "\n",
        "    cos = np.cos(theta / 2)\n",
        "    sin = np.sin(theta / 2)\n",
        "\n",
        "    u3 = torch.tensor([\n",
        "    [cos, -np.exp(1j * lam) * sin],\n",
        "    [np.exp(1j * phi) * sin, np.exp(1j * (phi + lam)) * cos]\n",
        "    ],  dtype=torch.cfloat)\n",
        "\n",
        "    # print(np.rint(u3.numpy()))\n",
        "    return u3\n",
        "\n",
        "def get_controlled_operator(total_qubits, \n",
        "                            gate_unitary,\n",
        "                            control_qubits,\n",
        "                            target_qubits, \n",
        "                            cuda = False):\n",
        "  \n",
        "    # return controlled unitary operator given gate and target qubits\n",
        "\n",
        "    identity = torch.eye(2).cuda() if cuda else torch.eye(2)\n",
        "    gate_unitary = gate_unitary.cuda() if cuda else gate_unitary\n",
        "    projection0 = P0x0_t.cuda() if cuda else P0x0_t  \n",
        "    projection1 = P1x1_t.cuda() if cuda else P1x1_t\n",
        "\n",
        "    if control_qubits[0] == 0:\n",
        "        current_gate1 = projection0\n",
        "        current_gate2 = projection1\n",
        "    elif target_qubits[0] == 0:\n",
        "        current_gate1 = identity\n",
        "        current_gate2 = gate_unitary\n",
        "    else:\n",
        "        current_gate1 = identity\n",
        "        current_gate2 = identity    \n",
        "\n",
        "    for i in range(1, total_qubits):\n",
        "\n",
        "        if i in control_qubits:\n",
        "            current_gate1 = kron(current_gate1, projection0)\n",
        "            current_gate2 = kron(current_gate2, projection1)\n",
        "        else: \n",
        "            current_gate1 = kron(current_gate1, identity)\n",
        "\n",
        "            if i in target_qubits:\n",
        "                current_gate2 = kron(current_gate2, gate_unitary)\n",
        "            else:\n",
        "                current_gate2 = kron(current_gate2, identity)\n",
        "\n",
        "    return current_gate1 + current_gate2\n",
        "\n",
        "def get_operator(total_qubits,\n",
        "                 gate_unitary, \n",
        "                 target_qubits, \n",
        "                 cuda = False):\n",
        "  \n",
        "    # return unitary operator of given gate and target qubits\n",
        "\n",
        "    identity = torch.eye(2).cuda() if cuda else torch.eye(2)\n",
        "    gate_unitary = gate_unitary.cuda() if cuda else gate_unitary\n",
        "\n",
        "    if target_qubits[0] == 0:\n",
        "        current_gate = gate_unitary\n",
        "    else:\n",
        "        current_gate = identity\n",
        "\n",
        "\n",
        "    for i in range(1, total_qubits):\n",
        "        if i in target_qubits:\n",
        "            current_gate = kron(current_gate, gate_unitary)\n",
        "        else:\n",
        "            current_gate = kron(current_gate, identity)\n",
        "\n",
        "    return current_gate\n",
        "\n",
        "def run_program(initial_state, program, params = None, cuda = False):\n",
        "    \n",
        "    # read program, and for each gate:\n",
        "    #   - calculate matrix operator\n",
        "    #   - multiply state with operator\n",
        "    # return final state\n",
        "\n",
        "    initial_state = initial_state.cuda() if cuda else initial_state\n",
        "    number_of_qubits = initial_state.shape[1].bit_length() - 1\n",
        "    for instruction in program:\n",
        "        if instruction[\"gate\"] == \"h\":\n",
        "            current_operator = get_operator(number_of_qubits, H_t, \n",
        "                                            instruction[\"target\"],\n",
        "                                            cuda = cuda)\n",
        "        elif instruction[\"gate\"] == \"x\":\n",
        "            current_operator = get_operator(number_of_qubits, X_t,\n",
        "                                            instruction[\"target\"],\n",
        "                                            cuda = cuda)\n",
        "        elif instruction[\"gate\"] == \"z\":\n",
        "            current_operator = get_operator(number_of_qubits, Z_t,\n",
        "                                            instruction[\"target\"],\n",
        "                                            cuda = cuda)\n",
        "        elif instruction[\"gate\"] == \"y\":\n",
        "            current_operator = get_operator(number_of_qubits, Y_t,\n",
        "                                            instruction[\"target\"],\n",
        "                                            cuda = cuda)\n",
        "        elif instruction[\"gate\"] == \"u3\":\n",
        "            current_gate = formulate_u3(instruction[\"params\"] if params is None else params)\n",
        "            current_operator = get_operator(number_of_qubits, current_gate,\n",
        "                                            instruction[\"target\"],\n",
        "                                            cuda = cuda)\n",
        "        elif instruction[\"gate\"] == \"cx\":\n",
        "            current_operator = get_controlled_operator(number_of_qubits, X_t,\n",
        "                                                       instruction[\"control\"],  \n",
        "                                                       instruction[\"target\"],\n",
        "                                                       cuda = cuda)   \n",
        "\n",
        "        initial_state = torch.matmul(initial_state, current_operator)\n",
        "\n",
        "    return initial_state\n",
        "\n",
        "def get_counts(state_vector, num_shots, print_results = False):\n",
        "    \n",
        "    # simply execute measure_all in a loop num_shots times and\n",
        "    state_vector = state_vector.abs()**2\n",
        "    sampler = WeightedRandomSampler(state_vector, num_shots)\n",
        "    format = '{0:0' + str(state_vector.shape[1].bit_length() - 1) + 'b}'\n",
        "\n",
        "    for idx in sampler:\n",
        "        counter = Counter(idx)\n",
        "\n",
        "    if print_results:\n",
        "        print('{')\n",
        "        for element in sorted(counter.items()) :\n",
        "            print(\"\\t\\\"\" +  format.format(element[0]) + '\\\" : ' + str(element[1]))\n",
        "        print('}')\n",
        "\n",
        "    return counter"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WdN6zUIhXQKH"
      },
      "source": [
        "# Requirement 1\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FNfhJDRUJqYv"
      },
      "source": [
        "The simulator should initialize a state, read a program like the following one, and perform multi-shot measurement of all qubits using a weighted random technique.\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "[\r\n",
        "  { \"gate\": \"h\", \"target\": [0] }, \r\n",
        "  { \"gate\": \"cx\", \"target\": [0, 1] }\r\n",
        "  ...\r\n",
        "]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l30KzTYwNjAW"
      },
      "source": [
        "**Deutsch-Jozsa Algorithm**\r\n",
        "\r\n",
        "With the goal of demonstrating  the functionality of our simulator we implemented the famous Deutsch-Jozsa Algorithm. This was the first example of a quantum algorithm that performs better than its classical counterpart, and showed that there can be advantages to using a quantum computer as a computational tool. \r\n",
        "\r\n",
        "**Deutsch-Jozsa Problem**\r\n",
        "\r\n",
        "We are given a hidden boolean function $f$, which takes as input a string of bits, and returns either $0$ or $1$:\r\n",
        "\r\n",
        "$f(\\{x_0,x_1,x_2,...\\}) \\rightarrow 0 \\textrm{ or } 1 \\textrm{ , where } x_n \\textrm{ is } 0 \\textrm{ or } 1$\r\n",
        "\r\n",
        "The feature of the given boolean function is that it is guaranteed to be balanced or constant. A constant function as the name implies, return $0$ or $1$ for any input. While the balanced function return $0$ for one half of the inputs and $1$ for the other half.\r\n",
        "\r\n",
        "**Quantum Oracle**\r\n",
        "\r\n",
        "Quantum Oracle is a black box which is commonly used in quantum algorithms. Often, the oracle is defined using a classical function $f: \\{ 0,1 \\}^{n} \\rightarrow \\{ 0,1 \\}^{m}$ which takes an $n$-bit binary input and produces an $m$-bit binary output. Then, with the purpose of making the oracle a quantum operator, it needs to be an unitary operator. Then, we define the Oracle in the following way:\r\n",
        "\r\n",
        "$ O ( \\vert x\\rangle \\oplus \\vert  y \\rangle ) = \\vert x\\rangle \\vert y \\oplus f(x)\\rangle$\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "**Quantum solution**\r\n",
        "\r\n",
        "Using a quantum computer, we can solve this problem with 100% accuracy, with a single call of the boolean function. But for that, we need the boolean function $f$ implemented as a quantum oracle, which is going to map the state $\\vert x\\rangle \\vert y\\rangle$ to the state $\\vert x\\rangle \\vert y \\oplus f(x)\\rangle$, where $\\oplus$ is addition module 2. \r\n",
        "\r\n",
        "\r\n",
        "**Algorithm description**\r\n",
        "\r\n",
        "\r\n",
        "1. The first step, is to prepare two quantum registers. The first is going to be a n-qubit register initialised to $|0\\rangle$ and the second is a one-qubit reigster initialised to $|1\\rangle$:\r\n",
        "\r\n",
        "  $\\vert \\psi_0 \\rangle = \\vert0\\rangle^{\\otimes n} \\vert 1\\rangle$\r\n",
        "\r\n",
        "2. Apply the Hadamard gate all registers:\r\n",
        "\r\n",
        "  $\\vert \\psi_1 \\rangle = \\frac{1}{\\sqrt{2^{n+1}}}\\sum_{x=0}^{2^n-1} \\vert x\\rangle \\left(|0\\rangle - |1 \\rangle \\right)$\r\n",
        "\r\n",
        "3. Apply the quantum oracle:\r\n",
        "\r\n",
        "  $\\vert \\psi_2 \\rangle = \\frac{1}{\\sqrt{2^{n+1}}}\\sum_{x=0}^{2^n-1} \\vert x\\rangle \\left(|f(x)\\rangle - |1 \\otimes f(x) \\rangle \\right)$\r\n",
        "\r\n",
        "  $\\vert \\psi_2 \\rangle = \\frac{1}{\\sqrt{2^{n+1}}}\\sum_{x=0}^{2^n-1} (-1)^{f(x)}\\vert x\\rangle \\left(|0\\rangle - |1  \\rangle \\right)$\r\n",
        "\r\n",
        "4. Apply Hadamard to each qubit of the first register:\r\n",
        "\r\n",
        "  $\\begin{aligned}\r\n",
        "              \\lvert \\psi_3 \\rangle \r\n",
        "                  & = \\frac{1}{2^n}\\sum_{x=0}^{2^n-1}(-1)^{f(x)}\r\n",
        "                      \\left[ \\sum_{y=0}^{2^n-1}(-1)^{x \\cdot y} \r\n",
        "                      \\vert y \\rangle \\right] \r\n",
        "                  & \r\n",
        "  \\end{aligned}$\r\n",
        "\r\n",
        "  $\\begin{aligned}\r\n",
        "              \\lvert \\psi_3 \\rangle \r\n",
        "                    & = \\frac{1}{2^n}\\sum_{y=0}^{2^n-1}\r\n",
        "                    \\left[ \\sum_{x=0}^{2^n-1}(-1)^{f(x)}(-1)^{x \\cdot y} \\right]\r\n",
        "                    \\vert y \\rangle\r\n",
        "  \\end{aligned}$\r\n",
        "\r\n",
        "5. Measure the first register. The probability of measuring $\\vert 0 \\rangle ^{\\otimes n} = \\lvert \\frac{1}{2^n}\\sum_{x=0}^{2^n-1}(-1)^{f(x)} \\rvert^2$ will be $1$ if $f(x)$ is constant and $0$ if $f(x)$ is balanced.\r\n",
        "\r\n",
        "**Implementation**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jQLZCRaMT4Ii",
        "outputId": "cb7c2015-f51d-47a8-ecb9-9e7cb16005ad"
      },
      "source": [
        "import time\r\n",
        "\r\n",
        "# First we define a register of 13 qubits, 1 ancilla, and 12 to work with the\r\n",
        "# oracle function.\r\n",
        "\r\n",
        "qubits = 13\r\n",
        "my_qpu = get_ground_state(qubits)\r\n",
        "\r\n",
        "# we apply the x gate to the last qubit for the oracle implementation\r\n",
        "# then, we apply Hadamard gate to all qubits\r\n",
        "# we apply CNOT to each qubit with the last register as target\r\n",
        "# finally we perform Hadamard gate to all qubits again.\r\n",
        "\r\n",
        "my_circuit = [\r\n",
        "{ \"gate\": \"x\", \"target\":  [qubits - 1] },\r\n",
        "{ \"gate\": \"h\", \"target\": range(0, qubits) },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [0], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [1], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [2], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [3], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [4], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [5], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [6], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [7], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [8], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [9], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [10], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [11], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"cx\",  \"control\": [12], \"target\": [qubits - 1] },\r\n",
        "{ \"gate\": \"h\", \"target\": range(0, qubits) }\r\n",
        "]\r\n",
        "\r\n",
        "#we run the program on CPU\r\n",
        "start = time.time()\r\n",
        "final_state = run_program(my_qpu, my_circuit, cuda = False)\r\n",
        "end = time.time()\r\n",
        "print('Exe time: ' + str(end - start))\r\n",
        "counts = get_counts(final_state, 16000, print_results = True)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Exe time: 13.599707126617432\n",
            "{\n",
            "\t\"1111111111111\" : 16000\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9U_bOv39a-td",
        "outputId": "70d01bff-090e-43fe-b973-6b7c6639cd33"
      },
      "source": [
        "#we run the program on CUDA\r\n",
        "start = time.time()\r\n",
        "final_state = run_program(my_qpu, my_circuit, cuda = True)\r\n",
        "end = time.time()\r\n",
        "print('Exe time: ' + str(end - start))\r\n",
        "counts = get_counts(final_state, 16000, print_results = True)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Exe time: 6.139760732650757\n",
            "{\n",
            "\t\"1111111111111\" : 16000\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "23z3lpI-bF35"
      },
      "source": [
        "\r\n",
        "Measuring the qubits showed in both examples all ones, indicating the implemented balanced function. Moreover, the execution time when using GPUs reduced 64.55 times the same operation performed in CPU. This shows how we can speed up quantum circuit simulations with the help of modern GPUs and popular frameworks such as PyTorch. \r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T51lyIia-67a"
      },
      "source": [
        "**CPU vs GPU**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qaMhKtIe_G6d"
      },
      "source": [
        "To compare the performance of our GPU Quantum Circuit Simulator with its CPU version, we measured the execution time of each circuit for multiple qubits (1 to 11). Then, we plotted the obtained information to visualize identify the benefits of our GPU Quantum Simulator.\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rn1fB3lcAUTx"
      },
      "source": [
        "import time\r\n",
        "\r\n",
        "QUBITS = 15\r\n",
        "\r\n",
        "def test_simulator(cuda):\r\n",
        "    execution_times = []\r\n",
        "\r\n",
        "    for qubits in range(2, QUBITS):\r\n",
        "        \r\n",
        "        my_qpu = get_ground_state(qubits)\r\n",
        "\r\n",
        "        my_circuit = [\r\n",
        "        { \"gate\": \"x\", \"target\":  [qubits - 1] },\r\n",
        "        { \"gate\": \"h\", \"target\": range(0, qubits) },\r\n",
        "        { \"gate\": \"cx\",  \"control\": [0], \"target\": [qubits - 1] },\r\n",
        "        { \"gate\": \"h\", \"target\": range(0, qubits) },\r\n",
        "        { \"gate\": \"z\", \"target\":  [qubits - 1] },\r\n",
        "        { \"gate\": \"h\", \"target\": range(0, qubits) },\r\n",
        "        { \"gate\": \"y\", \"target\":  [qubits - 1] },\r\n",
        "        { \"gate\": \"h\", \"target\": range(0, qubits) }\r\n",
        "        ]\r\n",
        "\r\n",
        "        start = time.time()\r\n",
        "        final_state = run_program(my_qpu, my_circuit, cuda = cuda)\r\n",
        "        end = time.time()\r\n",
        "\r\n",
        "        execution_times.append(end - start)\r\n",
        "\r\n",
        "    return execution_times\r\n",
        "\r\n",
        "\r\n",
        "cuda_times = test_simulator(True)\r\n",
        "cpu_times = test_simulator(False)"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 311
        },
        "id": "u4IYmCRdCufU",
        "outputId": "73436cba-bef6-40e7-a519-f73c03905e0a"
      },
      "source": [
        "import numpy as np\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import scipy.stats as stats\r\n",
        "mu = 0\r\n",
        "std = 1\r\n",
        "\r\n",
        "x = np.linspace(start=-4, stop=4, num=100)\r\n",
        "y = stats.norm.pdf(x, mu, std) \r\n",
        "line1 = plt.plot(range(2,QUBITS), cuda_times, label='Cuda')\r\n",
        "line2 = plt.plot(range(2,QUBITS), cpu_times, label='Cpu')\r\n",
        "plt.legend()\r\n",
        "plt.tight_layout()\r\n",
        "plt.grid()\r\n",
        "plt.xlabel(\"Number of Qubits\")\r\n",
        "plt.ylabel(\"Execution time (Seconds)\")\r\n",
        "\r\n",
        "plt.show()"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OLxSRdtbMMH9"
      },
      "source": [
        "**Conclusion**\r\n",
        "\r\n",
        "As proved in the aforementioned examples, our simulator is capable of performing quntum algorithms like the Deutsch-Jozsa algorithm. Moreover, our GPU Quantum Circuit Simulator performs better that its CPU version, proving that implemented simulators with the option of GPU acceleration could be a good asset to speed up quantum simulations.\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PW9UMW8XcTtd"
      },
      "source": [
        "# Requirement 2\r\n",
        "\r\n",
        "Add support of parametric gates to the quantum circuit simulator.\r\n",
        "\r\n",
        "Example of a program with parametric gates:\r\n",
        "\r\n",
        "`{ \"gate\": \"u3\", \"params\": { \"theta\": 3.1415, \"phi\": 1.5708, \"lambda\": -3.1415 }, \"target\": [0] }`\r\n",
        "\r\n",
        "which translates to the next operator.\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "[ 0+0j,  1+0j]\r\n",
        "\r\n",
        "[ 0+1j,  0+0j]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OAjPSngCmSSC"
      },
      "source": [
        "**U3 Gate Formulation**\r\n",
        "\r\n",
        "This gate is a generic single-qubit rotation with 3 Euler angles.\r\n",
        "\r\n",
        "$\r\n",
        "\\begin{align}\\begin{aligned}\\newcommand{\\th}{\\frac{\\theta}{2}}\\\\\\begin{split}U3(\\theta, \\phi, \\lambda) =\r\n",
        "    \\begin{pmatrix}\r\n",
        "        \\cos(\\th)          & -e^{i\\lambda}\\sin(\\th) \\\\\r\n",
        "        e^{i\\phi}\\sin(\\th) & e^{i(\\phi+\\lambda)}\\cos(\\th)\r\n",
        "    \\end{pmatrix}\\end{split}\\end{aligned}\\end{align}\r\n",
        "$\r\n",
        "\r\n",
        "**Implementation**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e7zq12qL2-8n",
        "outputId": "9511b016-85ef-4c9f-f24d-93b340852eec"
      },
      "source": [
        "qubits = 1\r\n",
        "my_qpu = get_ground_state(qubits)\r\n",
        "\r\n",
        "#we define the u3 gate\r\n",
        "my_circuit = [\r\n",
        "{ \"gate\": \"u3\", \"params\": { \"theta\": 3.1415, \"phi\": 1.5708, \"lambda\":  -3.1415}, \"target\": [0] }\r\n",
        "]\r\n",
        "\r\n",
        "#we print the final result and the operation matrix as well \r\n",
        "final_state = run_program(my_qpu, my_circuit, cuda = False)\r\n",
        "counts = get_counts(final_state, 1000, print_results = True)\r\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\n",
            "\t\"1\" : 1000\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6L3pjc7ipYrA"
      },
      "source": [
        "# Requirement 3\r\n",
        "\r\n",
        "Allow running variational quantum algorithms\r\n",
        "\r\n",
        "In some applications, it is important to find the minimum eigenvalue of a matrix. In the case of chemistry, the minimum eigenvalue of a Hermitian matrix characterizing the molecule is the ground state energy of the system. This could be solved using a quantum phase estimation algorithm, however, implementing this kind of algorithms exceed the limits of hardware available in the NISQ era. Then, in 2014, Peruzzo et al. proposed a VQE, which uses much shallower circuits to solve the problem of the ground state energy of a molecule.\r\n",
        "\r\n",
        "**Implementation**\r\n",
        "\r\n",
        "In this example we use a single qubit variational form to solve a problem similar to the ground state energy estimation. We are given a random probability vector $\\vec{x}$ and we wish to determine a possible parametrization for a single qubit. Such that when measured, the probability distribution is close to the determined before with $\\vec{x}$.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yZTa1XKbhZNA",
        "outputId": "bf0c4f38-3c7c-4238-94ef-671dd46a1d82"
      },
      "source": [
        "import numpy as np\r\n",
        "# np.random.seed(999990)\r\n",
        "target_distr = np.random.rand(2)\r\n",
        "# target_distr = np.array([0.9834016, 0.0165984])\r\n",
        "#we define the target distribution\r\n",
        "target_distr /= sum(target_distr)\r\n",
        "NUM_SHOTS = 10000\r\n",
        "print('Target dist: ', target_distr)\r\n",
        "\r\n",
        "def get_var_form(params):\r\n",
        "\r\n",
        "    # return the final count for the parameterized circuit given 3 euler angles \r\n",
        "\r\n",
        "    qubits =1\r\n",
        "    my_qpu = get_ground_state(qubits)\r\n",
        "    my_circuit = [\r\n",
        "    { \"gate\": \"u3\", \"params\":\r\n",
        "     { \"theta\": None, \"phi\": None, \"lambda\": None }, \"target\": [0] }\r\n",
        "    ]\r\n",
        "\r\n",
        "    final_state = run_program(my_qpu, my_circuit, \r\n",
        "                              {\"theta\": params[0],\r\n",
        "                               \"phi\": params[1], \r\n",
        "                               \"lambda\": params[2]}, \r\n",
        "                              cuda = True)\r\n",
        "    return final_state\r\n",
        "\r\n",
        "def get_probability_distribution(counts):\r\n",
        "\r\n",
        "    # return the probability distribution given a measaurement of multiple shoots\r\n",
        "\r\n",
        "    output_distr = [v[1] / NUM_SHOTS for v in sorted(counts.items())]\r\n",
        "    if len(output_distr) == 1:\r\n",
        "        output_distr.append(1 - output_distr[0])\r\n",
        "\r\n",
        "    return output_distr\r\n",
        "\r\n",
        "def objective_function(params):\r\n",
        "\r\n",
        "    # Calculate the cost as the distance between the output distribution and the target distribution\r\n",
        "\r\n",
        "    final_state = get_var_form(params)\r\n",
        "    result = get_counts(final_state, NUM_SHOTS)\r\n",
        "    output_distr = get_probability_distribution(result)\r\n",
        "    cost = sum([np.abs(output_distr[i] - target_distr[i]) for i in range(2)])\r\n",
        "    return cost"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Target dist:  [0.20415248 0.79584752]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e5Tg2vDSc62M"
      },
      "source": [
        "!pip install qiskit ipywidgets &> /dev/null"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NLyZm-7SmUmV",
        "outputId": "9aaed6bb-63dd-4bc7-c4b1-86e66ae4ef09"
      },
      "source": [
        "from qiskit.aqua.components.optimizers import COBYLA\r\n",
        "\r\n",
        "# Initialize the COBYLA optimizer\r\n",
        "optimizer = COBYLA(maxiter=1000, tol=0.00001)\r\n",
        "\r\n",
        "# Create the initial parameters (noting that our single qubit variational form has 3 parameters)\r\n",
        "params = np.random.rand(3)\r\n",
        "ret = optimizer.optimize(num_vars=3, objective_function=objective_function, initial_point=params)\r\n",
        "\r\n",
        "# Obtain the output distribution using the final parameters\r\n",
        "final_state = get_var_form(ret[0])\r\n",
        "result = get_counts(final_state, NUM_SHOTS)\r\n",
        "output_distr = get_probability_distribution(result)\r\n",
        "\r\n",
        "print(\"Target Distribution:\", target_distr)\r\n",
        "print(\"Obtained Distribution:\", output_distr)\r\n",
        "print(\"Output Error (Manhattan Distance):\", ret[1])\r\n",
        "print(\"Parameters Found:\", ret[0])"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Target Distribution: [0.20415248 0.79584752]\n",
            "Obtained Distribution: [0.2058, 0.7942]\n",
            "Output Error (Manhattan Distance): 0.012304962473901115\n",
            "Parameters Found: [4.07209616 1.57452526 1.78357923]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lg6yk2YY-L7l"
      },
      "source": [
        "**Conclusion**\r\n",
        "\r\n",
        "Machine learning approaches based in classical von Neumann architecture have been widely popular in either academic or industrial domains. Now, researchers have tried to implement machine learning approaches in the recent available quantum computers. However, it is hard to simulate classical deep learning models due to the intractability of deep quantum circuits. Thus, a new approach for feasible quantum machine learning is required. Variational quantum circuits were the response to that need and one of the key ingredients to implement them, is a parametrized quantum circuit, such as the one we can build with U3 Gates. U3 gates let us build Quantum Machine Learning solutions, at least for the near term NISQ devices which are available right now.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vNkC68QGJZYj"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}