Phase 1_Quantum Gates.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Report_EE_225_Final_Phase1.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_3Q2f8y5jPyM"
      },
      "source": [
        "#EE 225: Introduction to Quantum Computing \n",
        "#Final Project: Phase 1 (Quantum Gates)\n",
        "#MSEE San Jose State University \n",
        "# Hector Jose Morrell Jr\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wZR0pYY5l3WE"
      },
      "source": [
        "#Summary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VdmbLEcclgit"
      },
      "source": [
        "In Quantum Computing and especially in quantum circuitry, Quantum Gates are the fundamantal functions we use for operating on Qubits. Qubits are are the basic unit of quantum information, similarly to the binary bit in classical computers with 2 states.\n",
        "\n",
        "Just like classical computers, quantum gates are placed on qubits to perform an operation, the difference between the quantum gate and classical gates is that quantum gates are reversable. These gates being reversible is an advantage given the fact that if needed we could take an output and find out what the input waveform is so that we can see the properties of that qubit. \n",
        "\n",
        "In this project we will be writing functions for several quantum gates: NOT gate, XOR gate, SWAP gate, 1 -bit phase shift gate, 2-bit  phase  shift  gate,  Toffoli  gate,  and  5-bit  Hadamard  gate. The gates need to be able to take any input(decimal, integer, negative, positive) and be able to perform the operation.  \n",
        "\n",
        "  Below is a list of the quantum gates that were used in this report and a brief explanation of what each gate does.  \n",
        "\n",
        "1.   NOT Gate: The purpose of the NOT gate is similar to the inverter in classical computing where it will invert the bit. \n",
        "\n",
        "2.   XOR(Controll Not) Gate: Controlled gates act on 2 qubits, where one qubit act as a control for another qubit and the control is intended to invert the controlled bit. \n",
        "\n",
        "3.   Phase Shift: The Phase Shift gate is intended to rotate bits a certain phase. The phase shift in this code can be changed but was decided to be (pi/4). The phase shift of (pi/4) was chosen because a phase shift of (pi) would cause e^(i*theta) to become -1, which is the same as the Pauli-Z matrix. \n",
        "\n",
        "4.   SWAP Gate: The SWAP gate simply swaps the states of two qubits.\n",
        "\n",
        "5.   Toffoli Gate: Has two control qubits and one target.  The Toffoli is a Control-Control not. So the third qubit will only change when both control bits are 1. \n",
        "\n",
        "6. Hadamard Gate: The Hadamard gate acts on a single bit mapping it and making it a superposition of either |1> or |0>. It is a rotational measurement across the axis of a Bloch Sphere.\n",
        "\n",
        "\n",
        "  This simulator for the gates does have the input waveforms hard coded in, all you need to do is compile the code and it will give you the expected results. For any waves forms you would like to change please refer to the gate you are wanting to use and change the waveforms constants as pleased."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U5ogz8UdduZU"
      },
      "source": [
        "#Expedected Results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Cjwo3Kvd4na"
      },
      "source": [
        "1.   Not Gate: \n",
        "\n",
        "            |1> ---> |0>\n",
        "            |0> ---> |1>\n",
        "\n",
        "2.   XOR(Controll Not) Gate:  \n",
        "\n",
        "            |00> ---> |00>\n",
        "            |01> ---> |01>\n",
        "            |10> ---> |11>\n",
        "            |11> ---> |10>\n",
        "\n",
        "3.   SWAP Gate: \n",
        "\n",
        "            |00> ---> |00>\n",
        "            |01> ---> |10>\n",
        "            |10> ---> |01>\n",
        "            |11> ---> |11>\n",
        "\n",
        "4.   Phase Shift: \n",
        "\n",
        "            i = phase shift of e^(i*theta)\n",
        "\n",
        "            1-Bit\n",
        "            |0> ---> |0>\n",
        "            |1> ---> (i)|1>\n",
        "\n",
        "            2-Bit\n",
        "            |00> ---> |00>\n",
        "            |01> ---> (i)|01>\n",
        "            |10> ---> (i)|10>\n",
        "            |11> ---> (-1)|11>\n",
        "\n",
        "5.   Toffoli Gate: \n",
        "\n",
        "            |000> ---> |000>\n",
        "            |001> ---> |001>\n",
        "            |010> ---> |010>\n",
        "            |011> ---> |011>\n",
        "            |100> ---> |100>\n",
        "            |101> ---> |101>\n",
        "            |110> ---> |111>\n",
        "            |111> ---> |110>\n",
        "\n",
        "6. Hadamard Gate: This expected results will be applied to each individual bits.  \n",
        "\n",
        "          |0> ---> (1/sqrt(2))[|0> + |1>]\n",
        "          |1> ---> (1/sqrt(2))[|0> - |1>]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFJcxWEGosKE"
      },
      "source": [
        "# Code\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPtkDknaoxpB"
      },
      "source": [
        "Below is the code used for the Qunatum Gate Outputs. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MrvINE72oO23"
      },
      "source": [
        "##Not Gate"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TTtYhwws8vBL"
      },
      "source": [
        "The Not gate below has has the ability to perform both a 1 qubit and 2 qubit function. \n",
        "\n",
        "For the 1 qubit the input is a 2x1 Vector with R1 being the first row and R2 being the second row of the matrix\n",
        "\n",
        "For the 2 qubit the input is a 4x1 Vector with R4 being the first row and then R5, R6, R7 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different Vector please change the below in the code. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wHsIfP3ps2hu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4d0e206-da29-48ac-be68-eeb3fbdaa1bd"
      },
      "source": [
        "\n",
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "\n",
        "''' This function is to determine the output after using NOT Gate '''\n",
        "\n",
        "\n",
        "def not_gate():\n",
        "    print('\\nTHIS SECTION IS NOT GATE')\n",
        "    # Defining the NOT Gate\n",
        "    NOT_1bit = [[0, 1],\n",
        "                [1, 0]]\n",
        "    NOT_2bit = [[0, 0, 0, 1],\n",
        "                [0, 0, 1, 0],\n",
        "                [0, 1, 0, 0],\n",
        "                [1, 0, 0, 0]]\n",
        "\n",
        "    # Declaration statement to redirect to appropriate Qubit calculation\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R1 = -.707\n",
        "    R2 = 0\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R1, \"\\n\", R2)\n",
        "\n",
        "\n",
        "    # Setting List as an Array\n",
        "    Matrix1 = np.array([R1, R2])\n",
        "    print(\"\\n\"\"Vector\", Matrix1)\n",
        "\n",
        "    # The function to Multiply the Matrices\n",
        "    NOT_GATE_OUT1 = Matrix1.dot(NOT_1bit)\n",
        "    print(\"NOT Gate Output\", NOT_GATE_OUT1)\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R4 = .707\n",
        "    R5 = 0\n",
        "    R6 = .707\n",
        "    R7 = 0\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R4, \"\\n\", R5, \"\\n\", R6, \"\\n\", R7)\n",
        "\n",
        "\n",
        "    # Setting List as an Array\n",
        "    Matrix = np.array([R4, R5, R6, R7])\n",
        "    print(\"\\n\"\"Vector\", Matrix)\n",
        "\n",
        "    # The function to Multiply the Matrices\n",
        "    NOT_GATE_OUT = Matrix.dot(NOT_2bit)\n",
        "    print(\"NOT Gate Output\", NOT_GATE_OUT)\n",
        "\n",
        "not_gate()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "THIS SECTION IS NOT GATE\n",
            "\n",
            "Vector is -  \n",
            " -0.707 \n",
            " 0\n",
            "\n",
            "Vector [-0.707  0.   ]\n",
            "NOT Gate Output [ 0.    -0.707]\n",
            "\n",
            "Vector is -  \n",
            " 0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0\n",
            "\n",
            "Vector [0.707 0.    0.707 0.   ]\n",
            "NOT Gate Output [0.    0.707 0.    0.707]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a_V8eRt_n2Zu"
      },
      "source": [
        "##XOR GATE(CNOT)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bozDAx6x9mjz"
      },
      "source": [
        "The XOR(CNOT) gate below has has the ability to perform a 2 qubit function. \n",
        "\n",
        "For 2 qubit, the input is a 4x1 vector with R1 being the first row and then R2, R3, R4 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different vector please change the below in the code. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3w7jGyRZmYB0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5290931a-e895-427a-e235-9ab1b0fcbf32"
      },
      "source": [
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "def XOR_GATE():\n",
        "    print('\\n\\nTHIS SECTION IS XOR(CNNOT) GATE')\n",
        "    # Defining the XOR Gate\n",
        "    CNOT_2bit = [[1, 0, 0, 0],\n",
        "                 [0, 1, 0, 0],\n",
        "                 [0, 0, 0, 1],\n",
        "                 [0, 0, 1, 0]]\n",
        "\n",
        "    # Informing user of the matrices size\n",
        "    print(\"\\nYou have Selected the XOR(CNOT)\\nThe Vector Required is a 4x1\")\n",
        "\n",
        "\n",
        "    # Below line read inputs\n",
        "    R1 = -.707\n",
        "    R2 = 0\n",
        "    R3 = .707\n",
        "    R4 = 0\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R1, \"\\n\", R2, \"\\n\", R3, \"\\n\", R4)\n",
        "\n",
        "\n",
        "    # Setting List as an Array\n",
        "    Matrix = np.array([R1, R2, R3, R4])\n",
        "    print(\"\\nInput - Vector\", Matrix)\n",
        "\n",
        "    # Function to Multiply the Matrices\n",
        "    CNOT_GATE_OUT = Matrix.dot(CNOT_2bit)\n",
        "    print(\"XOR Gate Output\", CNOT_GATE_OUT)\n",
        "\n",
        "XOR_GATE()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "THIS SECTION IS XOR(CNNOT) GATE\n",
            "\n",
            "You have Selected the XOR(CNOT)\n",
            "The Vector Required is a 4x1\n",
            "\n",
            "Vector is -  \n",
            " -0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0\n",
            "\n",
            "Input - Vector [-0.707  0.     0.707  0.   ]\n",
            "XOR Gate Output [-0.707  0.     0.     0.707]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U0llUnlGn4DT"
      },
      "source": [
        "##SWAP GATE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1MhRij9B916H"
      },
      "source": [
        "The SWAP gate below has has the ability to perform a 2 qubit function. \n",
        "\n",
        "For 2 qubit, the input is a 4x1 matrix with R1 being the first row and then R2, R3, R4 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different vector please change the below in the code. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lyOsCzclmX3W",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "30ce1a7c-8d9c-4b03-f34f-23c014a3639c"
      },
      "source": [
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "'''This function is to determine the output after using SWAP Gate'''\n",
        "\n",
        "\n",
        "def SWAP_GATE():\n",
        "    print('\\n\\nTHIS SECTION IS SWAP GATE')\n",
        "    # Defining the XOR Gate\n",
        "    SWAP = [[1, 0, 0, 0],\n",
        "            [0, 0, 1, 0],\n",
        "            [0, 1, 0, 0],\n",
        "            [0, 0, 0, 1]]\n",
        "\n",
        "    # Informing user of the matrices siz\n",
        "    print(\"\\nYou have Selected the SWAP Gate\\nThe vector Required is a 4x1\")\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R1 = -.707\n",
        "    R2 = 0\n",
        "    R3 = .707\n",
        "    R4 = 0\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R1, \"\\n\", R2, \"\\n\", R3, \"\\n\", R4)\n",
        "\n",
        "\n",
        "    # Setting List as an Array\n",
        "    Matrix = np.array([R1, R2, R3, R4])\n",
        "    print(\"\\n\"\"Input - Vector\", Matrix)\n",
        "\n",
        "    # Multiplying Matrices\n",
        "    SWAP_OUT = Matrix.dot(SWAP)\n",
        "    print(\"SWAP Gate Output\", SWAP_OUT)\n",
        "\n",
        "\n",
        "SWAP_GATE()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "THIS SECTION IS SWAP GATE\n",
            "\n",
            "You have Selected the SWAP Gate\n",
            "The vector Required is a 4x1\n",
            "\n",
            "Vector is -  \n",
            " -0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0\n",
            "\n",
            "Input - Vector [-0.707  0.     0.707  0.   ]\n",
            "SWAP Gate Output [-0.707  0.707  0.     0.   ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwQfBmy1n6Ek"
      },
      "source": [
        "##Phase Shift"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZugsQRp9-R7"
      },
      "source": [
        "The Not gate below has has the ability to perform both a 1 qubit and 2 qubit function. \n",
        "\n",
        "For the 1 qubit the input is a 2x1 matrix with R1 being the first row and R2 being the second row of the matrix\n",
        "\n",
        "For the 2 qubit the input is a 4x1 matrix with R3 being the first row and then R4, R5, R6 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different vector please change the below in the code. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w8iTKLiVmXoz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 372
        },
        "outputId": "c90fe311-55cb-429d-e6df-297675f2025e"
      },
      "source": [
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "def Phase_Shift():\n",
        "    print('\\n\\nTHIS SECTION IS Phase Shift GATE')\n",
        "    # Setting variable of z as an imaginary number if j\n",
        "    z = 1j\n",
        "\n",
        "\n",
        "    # Setting Varibale theta for the phase shift of system\n",
        "    theta = np.pi / 6\n",
        "\n",
        "\n",
        "    # Setting i as varibale for Phase Shift Matrix\n",
        "    i = exp(theta * z)\n",
        "\n",
        "    # Defining the NOT Gate\n",
        "    Phase_1bit = [[1, 0], \n",
        "                  [0, i]]\n",
        "    Phase_2bit = [[1, 0, 0, 0],\n",
        "                  [0, 1, 0, 0],\n",
        "                  [0, 0, 1, 0],\n",
        "                  [0, 0, 0, i]]\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R1 = -.707\n",
        "    R2 = 0\n",
        "    print(\"\\n\"\"1-Bit Vector is - \", \"\\n\", R1, \"\\n\", R2)\n",
        "    Matrix1 = np.array([R1, R2])\n",
        "    print(\"\\n\"\"Vector\", Matrix1)\n",
        "\n",
        "\n",
        "\n",
        "    Phase_GATE_OUT = Matrix1.dot(Phase_1bit)\n",
        "    print(\"Phase Gate Output\", Phase_GATE_OUT)\n",
        "\n",
        "    \n",
        "    # Below line read inputs from user\n",
        "    R3 = .707\n",
        "    R4 = 0\n",
        "    R5 = .707\n",
        "    R6 = 0\n",
        "    print(\"\\n\"\"2-Bit Vector is - \", \"\\n\", R3, \"\\n\", R4, \"\\n\", R5, \"\\n\", R6)\n",
        "    Matrix = np.array([R3, R4, R5, R6])\n",
        "    print(\"\\n\"\"Input - Vector\", Matrix)\n",
        "\n",
        "\n",
        "    Phase2_GATE_OUT = Matrix.dot(Phase_2bit)\n",
        "    print(\"2-Bit Phase Gate Output\", Phase2_GATE_OUT)\n",
        "\n",
        "Phase_Shift()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "THIS SECTION IS Phase Shift GATE\n",
            "\n",
            "1-Bit Vector is -  \n",
            " -0.707 \n",
            " 0\n",
            "\n",
            "Vector [-0.707  0.   ]\n",
            "Phase Gate Output [-0.707+0.j  0.   +0.j]\n",
            "\n",
            "2-Bit Vector is -  \n",
            " 0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0\n",
            "\n",
            "Input - Vector [0.707 0.    0.707 0.   ]\n",
            "2-Bit Phase Gate Output [0.707     +0.j     0.        +0.j     0.61227996+0.3535j\n",
            " 0.        +0.j    ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vaaitWmBn8gN"
      },
      "source": [
        "##Toffoli Gate"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3UX2EQ--NOl"
      },
      "source": [
        "The Toffoli gate below has has the ability to perform a 3 qubit function. \n",
        "\n",
        "For the 3 qubit the input is a 8x1 matrix with R1 being the first row and then R2-R8 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different vector please change the below in the code. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "87IMgN5CmXe1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        },
        "outputId": "a2c1d344-5f53-4505-8c70-b6997f527055"
      },
      "source": [
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "def Toffoli_GATE():\n",
        "    print('\\n\\nTHIS SECTION IS Toffoli GATE')\n",
        "    # Defining the Toffoli Gate\n",
        "    Toffoli_bit = [[1, 0, 0, 0, 0, 0, 0, 0],\n",
        "                   [0, 1, 0, 0, 0, 0, 0, 0],\n",
        "                   [0, 0, 1, 0, 0, 0, 0, 0],\n",
        "                   [0, 0, 0, 1, 0, 0, 0, 0],\n",
        "                   [0, 0, 0, 0, 1, 0, 0, 0],\n",
        "                   [0, 0, 0, 0, 0, 1, 0, 0],\n",
        "                   [0, 0, 0, 0, 0, 0, 0, 1],\n",
        "                   [0, 0, 0, 0, 0, 0, 1, 0]]\n",
        "\n",
        "    # Informing user of the elements needed for this gate\n",
        "    print(\"\\nYou have Selected the Toffoli Gate\\nThe vector Required is a 8x1\")\n",
        "\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R1 = -.707\n",
        "    R2 = 0\n",
        "    R3 = .707\n",
        "    R4 = 0\n",
        "    R5 = .707\n",
        "    R6 = 0\n",
        "    R7 = .707\n",
        "    R8 = 0\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R1, \"\\n\", R2, \"\\n\", R3, \"\\n\", R4, \"\\n\", R5, \"\\n\", R6, \"\\n\", R7, \"\\n\", R8)\n",
        "\n",
        "\n",
        "\n",
        "    # Setting Matrix as an Array\n",
        "    Matrix = np.array([R1, R2, R3, R4, R5, R6, R7, R8])\n",
        "    print(\"\\n\"\"Input - Vector\", Matrix)\n",
        "\n",
        "    # Matrix multiplication of the user input and Toffoli Gate\n",
        "    Toffoli_GATE_OUT = Matrix.dot(Toffoli_bit)\n",
        "    print(\"Toffoli Gate Output\", Toffoli_GATE_OUT)\n",
        "\n",
        "Toffoli_GATE()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "THIS SECTION IS Toffoli GATE\n",
            "\n",
            "You have Selected the Toffoli Gate\n",
            "The vector Required is a 8x1\n",
            "\n",
            "Vector is -  \n",
            " -0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0 \n",
            " 0.707 \n",
            " 0\n",
            "\n",
            "Input - Vector [-0.707  0.     0.707  0.     0.707  0.     0.707  0.   ]\n",
            "Toffoli Gate Output [-0.707  0.     0.707  0.     0.707  0.     0.     0.707]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33vRsvgdn-Hg"
      },
      "source": [
        "##Hadamard Gate"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JwA9Iauv-VaK"
      },
      "source": [
        "The Hadamard gate below has has the ability to perform a 5 qubit function. \n",
        "\n",
        "For the 5 qubit the input is a 32x1 matrix with R1 being the first row and then R2-R32 being the subsequent rows.\n",
        "\n",
        "If you would like to compute a different vector please change the below in the code. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W5ZEyN_TmXQX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "f9ffc5d8-715f-48c1-b2d5-70b574ed69a6"
      },
      "source": [
        "import numpy as np\n",
        "from numpy.ma import exp\n",
        "from math import sqrt\n",
        "\n",
        "def Hadamard_Gate():\n",
        "    print('\\n\\nTHIS SECTION IS 5-Bit Hadamard GATE')\n",
        "    # Defining the H Gate\n",
        "    H = [([1 / sqrt(2), 1 / sqrt(2)], \n",
        "          [1 / sqrt(2), -1 / sqrt(2)])]\n",
        "\n",
        "    print('\\nThis is the Hadamard Gate', '\\n', H)\n",
        "\n",
        "    # Iterative tensor product to determine the 5-Qubit Hadamard Gate\n",
        "    H_2 = np.kron(H, H)\n",
        "    H_3 = np.kron(H_2, H)\n",
        "    H_4 = np.kron(H_3, H)\n",
        "    H_Tensor = np.kron(H_4, H)\n",
        "\n",
        "    print('\\nThis is the 5-Bit Hadamard Gate', '\\n', H_Tensor)\n",
        "\n",
        "    # Informing user of the number of elements in this system\n",
        "    print(\"\\nYou have selcted the 5-Bit Hadamard Gate \\nThe Vector Required is a 32x1\")\n",
        "\n",
        "\n",
        "\n",
        "    # Below line read inputs from user\n",
        "    R1 = 1\n",
        "    R2 = 0\n",
        "    R3 = 0\n",
        "    R4 = 0\n",
        "    R5 = 0\n",
        "    R6 = 0\n",
        "    R7 = 0\n",
        "    R8 = 0\n",
        "    R9 = 0\n",
        "    R10 = 0\n",
        "    R11 = 0\n",
        "    R12 = 0\n",
        "    R13 = 0\n",
        "    R14 = 0\n",
        "    R15 = 0\n",
        "    R16 = 0\n",
        "    R17 = 0\n",
        "    R18 = 0\n",
        "    R19 = 0\n",
        "    R20 = 0\n",
        "    R21 = 0\n",
        "    R22 = 0\n",
        "    R23 = 0\n",
        "    R24 = 0\n",
        "    R25 = 0\n",
        "    R26 = 0\n",
        "    R27 = 0\n",
        "    R28 = 0\n",
        "    R29 = 0\n",
        "    R30 = 0\n",
        "    R31 = 0\n",
        "    R32 = 0\n",
        "\n",
        "\n",
        "    print(\"\\n\"\"Vector is - \", \"\\n\", R1, \"\\n\", R2, \"\\n\", R3, \"\\n\", R4, \"\\n\", R5, \"\\n\", R6, \"\\n\", R7, \"\\n\", R8,\n",
        "          \"\\n\", R9, \"\\n\", R10, \"\\n\", R11, \"\\n\", R12, \"\\n\", R13, \"\\n\", R14, \"\\n\", R15, \"\\n\", R16,\n",
        "          \"\\n\", R17, \"\\n\", R18, \"\\n\", R19, \"\\n\", R20, \"\\n\", R21, \"\\n\", R22, \"\\n\", R23, \"\\n\", R24,\n",
        "          \"\\n\", R25, \"\\n\", R26, \"\\n\", R27, \"\\n\", R28, \"\\n\", R29, \"\\n\", R30, \"\\n\", R31, \"\\n\", R32)\n",
        "\n",
        "    # Setting matrix as an array\n",
        "    Matrix = np.array([R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20,\n",
        "                       R21, R22, R23, R24, R25, R26, R27, R28, R29, R30, R31, R32])\n",
        "    print(\"\\n\"\"Input - Vector\", Matrix)\n",
        "\n",
        "    # Matrix Multiplication\n",
        "    H_GATE_OUT = Matrix.dot(H_Tensor)\n",
        "    print(\"\\n\"\"5-Bit Hadamard Gate Output\", H_GATE_OUT)\n",
        "\n",
        "Hadamard_Gate()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "THIS SECTION IS 5-Bit Hadamard GATE\n",
            "\n",
            "This is the Hadamard Gate \n",
            " [([0.7071067811865475, 0.7071067811865475], [0.7071067811865475, -0.7071067811865475])]\n",
            "\n",
            "This is the 5-Bit Hadamard Gate \n",
            " [[[ 0.1767767  0.1767767  0.1767767 ...  0.1767767  0.1767767  0.1767767]\n",
            "  [ 0.1767767 -0.1767767  0.1767767 ... -0.1767767  0.1767767 -0.1767767]\n",
            "  [ 0.1767767  0.1767767 -0.1767767 ...  0.1767767 -0.1767767 -0.1767767]\n",
            "  ...\n",
            "  [ 0.1767767 -0.1767767  0.1767767 ...  0.1767767 -0.1767767  0.1767767]\n",
            "  [ 0.1767767  0.1767767 -0.1767767 ... -0.1767767  0.1767767  0.1767767]\n",
            "  [ 0.1767767 -0.1767767 -0.1767767 ...  0.1767767  0.1767767 -0.1767767]]]\n",
            "\n",
            "You have selcted the 5-Bit Hadamard Gate \n",
            "The Vector Required is a 32x1\n",
            "\n",
            "Vector is -  \n",
            " 1 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0 \n",
            " 0\n",
            "\n",
            "Input - Vector [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            "5-Bit Hadamard Gate Output [[0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767\n",
            "  0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767\n",
            "  0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767\n",
            "  0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767 0.1767767\n",
            "  0.1767767 0.1767767 0.1767767 0.1767767]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_oDIS9SWpGNm"
      },
      "source": [
        "# Results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H8jLq2u6pNNW"
      },
      "source": [
        "The results of my code were conclusive that everything is working properly and according to design. The functions were able to take any input regardless whether they were decimals, integers, positive or negative, and were able to perform the necessary function designed for.  \n",
        "\n",
        "The NOTE Gate results were resulting in the states being swapped |0> ---> |1> or |1> ---> |0>. The qubits were effectively inverted.\n",
        "\n",
        "The XOR(CNOT) would effectively use the control bit to swap the state of the second bit. |11> ---> |10> or |10> ---> |11>, while leaving the other states unchanged.\n",
        "\n",
        "The SWAP Gate was able to effectively swap the bits, |01> ---> |10> and |10> ---> |01>, while leaving the other states unchanged.  \n",
        "\n",
        "The Phase Shift was able to successfully shift the bit of interest a certain phase that was determined by the use. For this report it was shifted for the (pi/4), this was picked because a phase shift of (pi) would cause e^(i*theta) to become -1, which is the same as the Pauli-Z matrix.  \n",
        "\n",
        "The Toffoli also known as the CCNOT gate, Control-Control Not gate, which will swap the third bit if both the control bits are 1. For the simulation the the following states inverterd the third bit, |111> and |110>.  \n",
        "\n",
        "The 5-Bit Hadamard would place each individual bits into a superposition of |0> and |1>. For the Hadamard Gate since it was a 5-Bit the way to obtain this 32x32 matrix was to Tensor product 5 1-Hadamard gate to make the 5-Bit Hadamard gate. When testing the Hadamard Gate, I inputeda a 32x1 Matrix consisting of the first row being 1 and the rest being 0. The expected output would be a 32x1 matrix with all the rows consisting of .176, which is exactly what is reported. Concluding that the Hadamard gate is working correctly. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOPeBpatpPrC"
      },
      "source": [
        "# Conclusion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZUukj3YgpSJU"
      },
      "source": [
        "This project was effective in teaching how to implement quantum gates without the need of programs such as IBMQ. This code is just the beginning, we will be using it as the stepping stone to not only Phase 2 of this project, which is Implement Deutsch’s Algorithm, but also to a more refined and broader function. An idea I want to pursue is to make this code dynamic and able to take more qubits so that I could be used for more quantum Circuit/Computing functions. \n",
        "\n"
      ]
    }
  ]
}