Quantum_Simulator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Quantum-Simulator.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8aVseGYjkkUk"
      },
      "source": [
        "# Creating a quantum simulator\r\n",
        "\r\n",
        "This notebook contains a quantum simulator built from scratch using basic libararies. The simulator performs the following functions:\r\n",
        "\r\n",
        "*   Initialize a state\r\n",
        "*   Run a program by calculating for each gate, a matrix operator and then applying it to the qubits\r\n",
        "*   Perform multi-shot measurements of all qubits using weighted random technique\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zGD6Bw4OW6fQ"
      },
      "source": [
        "# Importing basic libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aOrBYrzeNQTP"
      },
      "source": [
        "import numpy as np\r\n",
        "import json\r\n",
        "from collections import Counter"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9SUzyzqfXCr6"
      },
      "source": [
        "# Defining Quantum Gates\r\n",
        "\r\n",
        "Our simulator will support the following gates:\r\n",
        "\r\n",
        "*   Identity Gate\r\n",
        "*   Hadamard Gate\r\n",
        "*   Pauli-X Gate\r\n",
        "*   Pauli-Y Gate\r\n",
        "*   Pauli-Z Gate\r\n",
        "*   S Gate\r\n",
        "*   T Gate\r\n",
        "*   CNOT\r\n",
        "\r\n",
        "Definitions for each gate can be [found here](https://qiskit.org/textbook/ch-states/single-qubit-gates.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iMjFGQxXNTLe"
      },
      "source": [
        "# A dictionary containing the standard quantum gates \r\n",
        "\r\n",
        "gates = {\r\n",
        "    \"i\":np.identity(2),\r\n",
        "    \"h\":np.array([[1/np.sqrt(2), 1/np.sqrt(2)],[1/np.sqrt(2), -1/np.sqrt(2)]]),\r\n",
        "    \"x\":np.array([[0, 1],[1, 0]]),\r\n",
        "    \"y\":np.array([[0, +1j],[-1j, 0]]),\r\n",
        "    \"z\":np.array([[1, 0],[0, -1]]),\r\n",
        "    \"s\":np.array([[1, 0],[0, np.exp(np.pi * +1j / 2)]]),\r\n",
        "    \"t\":np.array([[1, 0],[0, np.exp(np.pi * +1j / 4)]]),\r\n",
        "}"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TeOZ_MiuYOds"
      },
      "source": [
        "# Defining the quantum simulator\r\n",
        "\r\n",
        "Since qubits can exist in more states than just the traditional 0 and 1 of a bit, we can encode more information using them. In practice, it is possible to encode a classical bit using a qubit, but the converse is not true. You cannot encode a qubit of information in a classical transistor. Using bits, an n-component system can be encoded using n transistors; only 8 stored bits are required to encapsulate an 8-bit classical system. If the n-component system were instead to be quantum, 2ⁿ complex numbers would be required to encode it (Kopczyk, 2018). By extension, encoding an 8-qubit quantum computer requires 256 complex numbers. And to simulate 64 qubits one will need 2⁶⁴=18, 446, 744, 073, 709, 551, 616 complex numbers on a classical machine.\r\n",
        "\r\n",
        "- From [The Gradient](https://thegradient.pub/knocking-on-turings-door-quantum-computing-and-machine-learning/)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "elJZUSObLVwf"
      },
      "source": [
        "def get_ground_state(num_qubits):\r\n",
        "    \"\"\"\r\n",
        "    Takes the number of qubits and returns a vector in the ground state representing |0>\r\n",
        "    @param num_qubits: number of qubits in the system \r\n",
        "    @return: vector of 2^n, where n is num_qubits, representing state |0> \r\n",
        "    \"\"\"\r\n",
        "    vector = [0 for i in range(2**num_qubits)]\r\n",
        "    vector[0] = 1\r\n",
        "    return np.array(vector)\r\n",
        "\r\n",
        "def get_single_qubit_operator(total_qubits, gate, target):\r\n",
        "    \"\"\"\r\n",
        "    Takes the number of qubits and returns a matrix operator of size 2^n x 2^n, where n is total_qubits, for required gate\r\n",
        "    @param total_qubits: count of qubits in the system\r\n",
        "    @param gate: the input gate for which the operator is needed\r\n",
        "    @param target: the target qubit(s) on which the gate is applied in the representation defined in [Link: shorturl.at/lpqxQ]\r\n",
        "    @return: matrix operator of size 2^n x 2^n, where n is total_qubits\r\n",
        "    \"\"\"\r\n",
        "    #starting tensor product with identity or the gate itself\r\n",
        "    operator = gate if target == 0 else gates['i']\r\n",
        "\r\n",
        "    for qubit in range(1, total_qubits):\r\n",
        "        if qubit == target:\r\n",
        "            #tensor product with the gate\r\n",
        "            operator = np.kron(operator, gate)\r\n",
        "        else:\r\n",
        "            #tensor product with identity\r\n",
        "            operator = np.kron(operator, gates['i'])\r\n",
        "    \r\n",
        "    return operator\r\n",
        "\r\n",
        "def get_cx_operator(total_qubits, control, target):\r\n",
        "    \"\"\"\r\n",
        "    Takes the number of qubits and returns a matrix operator of CNOT of size 2^n x 2^n, where n is total_qubits\r\n",
        "    @param total_qubits: count of qubits in the system\r\n",
        "    @param gate: the input gate for which the operator is needed; CNOT in this case\r\n",
        "    @param target: the target qubit(s) in the representation defined in [Link: shorturl.at/lpqxQ]\r\n",
        "    @return: CNOT matrix operator of size 2^n x 2^n, where n is total_qubits\r\n",
        "    \"\"\"\r\n",
        "    P0x0 = np.array([[1, 0],[0, 0]])\r\n",
        "    P1x1 = np.array([[0, 0],[0, 1]])\r\n",
        "    X = gates['x']\r\n",
        "\r\n",
        "    # case 1\r\n",
        "    operator1 = P0x0 if control == 0 else gates['i']\r\n",
        "\r\n",
        "    for qubit in range(1, total_qubits):\r\n",
        "        if qubit == control:\r\n",
        "            operator1 = np.kron(operator1, P0x0)\r\n",
        "        else:\r\n",
        "            operator1 = np.kron(operator1, gates['i'])\r\n",
        "\r\n",
        "    # case 2\r\n",
        "    operator2 = P1x1 if control == 0 else gates['i']\r\n",
        "\r\n",
        "    for qubit in range(1, total_qubits):\r\n",
        "        if qubit == control:\r\n",
        "            operator2 = np.kron(operator2, P1x1)\r\n",
        "        elif qubit == target:\r\n",
        "            operator2 = np.kron(operator2, X)\r\n",
        "        else:\r\n",
        "            operator2 = np.kron(operator2, gates['i'])\r\n",
        "    \r\n",
        "    #take the sum of both cases to generate the final matrix operator\r\n",
        "    return operator1 + operator2\r\n",
        "\r\n",
        "def get_operator(total_qubits, gate_unitary, target_qubits):\r\n",
        "    \"\"\"\r\n",
        "    Wrapper function for generating matrix operator to handle CNOT and all other gates separately\r\n",
        "    @param total_qubits: count of qubits in the system\r\n",
        "    @param gate_unitary: the input gate for which the operator is needed\r\n",
        "    @param target_qubits: the qubit(s) onto which the gate is to be applied\r\n",
        "    @return: matrix operator of size 2^n x 2^n, where n is total_qubits\r\n",
        "    \"\"\"\r\n",
        "    # return unitary operator of size 2**n x 2**n for given gate and target qubits\r\n",
        "\r\n",
        "    if gate_unitary == 'cx':\r\n",
        "        return get_cx_operator(total_qubits, target_qubits[0], target_qubits[1])\r\n",
        "    else:\r\n",
        "        return get_single_qubit_operator(total_qubits, gates[gate_unitary] , target_qubits[0])\r\n",
        "\r\n",
        "\r\n",
        "def run_program(initial_state, program):\r\n",
        "    \"\"\"\r\n",
        "    Main function that builds and runs the quantum circuit\r\n",
        "    @param initial_state: a state vector of n-qubits as input to the quantum system  \r\n",
        "    @param program: an array of objects, each containing \"gate\" and \"target\" for defining the gate operation and target qubits for it \r\n",
        "    @return: final/evolved state of the quantum system after running the program\r\n",
        "    \"\"\"\r\n",
        "    total_qubits = int(np.log2(len(initial_state)))\r\n",
        "\r\n",
        "    state = initial_state\r\n",
        "    \r\n",
        "    #for each instruction:\r\n",
        "    #   get matrix operator\r\n",
        "    #   apply it to state\r\n",
        "    #   move ahead\r\n",
        "    for instruction in program: \r\n",
        "        gate = instruction['gate']\r\n",
        "        targets = instruction['target']\r\n",
        "        operator = get_operator(total_qubits, gate, targets)\r\n",
        "        state = np.dot(operator, state)\r\n",
        "\r\n",
        "    return state\r\n",
        "\r\n",
        "def measure_all(state_vector):\r\n",
        "    \"\"\"\r\n",
        "    Measures qubits by taking them from |+> and |-> basis to the computational basis \r\n",
        "    @param state_vector: a state vector of n-qubits that are to be measured  \r\n",
        "    @return: index (or position) of the quantum state measured\r\n",
        "    \"\"\"\r\n",
        "    # choose element from state_vector using weighted random and return it's index\r\n",
        "    probabilities = np.abs(state_vector)**2\r\n",
        "    index = np.random.choice(a=len(state_vector), p=probabilities)\r\n",
        "\r\n",
        "    return index\r\n",
        "\r\n",
        "def get_counts(state_vector, num_shots):\r\n",
        "    \"\"\"\r\n",
        "    Executes quantum circuit num_shots times and return the probability distribution of each output through a dictionary \r\n",
        "    @param state_vector: a state vector of n-qubits\r\n",
        "    @param num_shots: number of times that the program is executes  \r\n",
        "    @return: dictionary containing the output state and its frequency\r\n",
        "    \"\"\"\r\n",
        "    # simply execute measure_all in a loop num_shots times and\r\n",
        "    # return object with statistics in following form:\r\n",
        "    #   {\r\n",
        "    #      element_index: number_of_ocurrences,\r\n",
        "    #      element_index: number_of_ocurrences,\r\n",
        "    #      element_index: number_of_ocurrences,\r\n",
        "    #      ...\r\n",
        "    #   }\r\n",
        "    # (only for elements which occoured - returned from measure_all)\r\n",
        "\r\n",
        "    results = []\r\n",
        "    \r\n",
        "    num_bits = int(np.log2(len(state_vector)))\r\n",
        "    \r\n",
        "\r\n",
        "    for _ in range(num_shots):\r\n",
        "        result = measure_all(state_vector)\r\n",
        "        results.append(\"{0:b}\".format(result).zfill(num_bits)[::-1]) \r\n",
        "\r\n",
        "    stats = Counter(results)   \r\n",
        "\r\n",
        "    return json.dumps(stats, sort_keys=True, indent=4)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2XVbq00MkOF-"
      },
      "source": [
        "# A sample program to execute using the simulator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lwTmYMcRLvAC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63869c5b-0b25-4487-fce1-737043136492"
      },
      "source": [
        "# Define program:\r\n",
        "\r\n",
        "my_circuit = [\r\n",
        "{ \"gate\": \"h\", \"target\": [0] }, \r\n",
        "{ \"gate\": \"cx\", \"target\": [0, 1] }\r\n",
        "]\r\n",
        "\r\n",
        "\r\n",
        "# Create \"quantum computer\" with 2 qubits (this is actually just a vector :) )\r\n",
        "my_qpu = get_ground_state(3)\r\n",
        "\r\n",
        "# Run circuit\r\n",
        "final_state = run_program(my_qpu, my_circuit)\r\n",
        "\r\n",
        "# Read results\r\n",
        "counts = get_counts(final_state, 1000)\r\n",
        "print(counts)\r\n",
        "\r\n",
        "# Should print something like:\r\n",
        "# {\r\n",
        "#   \"00\": 502,\r\n",
        "#   \"11\": 498\r\n",
        "# }\r\n",
        "\r\n",
        "# Voila!"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\n",
            "    \"000\": 500,\n",
            "    \"011\": 500\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}