TUT25_Hands_on_part_II_with_solutions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "04XpalIMsZ8U",
        "k_YIhAW-tHC2"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "##**Welcome**\n",
        "in the second hands-on session of this tutorial *Deep dive into the simulation of quantum circuits with QX-simulator*!\n",
        "\n",
        "This session should last until the end of the time allocated for the tutorial. Again, please do not hesitate to ask questions when needed.\n",
        "\n",
        "In this part, we will first try to think a little bit about sparse simulators and sparse quantum state vectors. For that, we won't use QX-simulator, but use Python to discover how to apply a quantum gate to a sparse state vector.\n",
        "\n",
        "In the last part, we will take a critical look at the performance of sparse simulators like QX-simulator when confronted with a variety of quantum circuits. For that, we've prepared some experiences to compare the performance of QX-simulator and Qiskit's Aer state vector simulator.\n"
      ],
      "metadata": {
        "id": "gWbXMmvSzLHy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# General questions\n",
        "\n",
        "For the following questions, feel free to use the Internet to find answers, but of course it's better to try first to think by yourself, with your own knowledge. These questions are here to get everybody familiar with sparse state vector simulation - if a question is easy for you, immediately skip to the next one :).\n",
        "\n",
        "1. What is a hashtable and what is it used for?"
      ],
      "metadata": {
        "id": "liP_E1A-zr5F"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rtPk0Q97zGrx"
      },
      "outputs": [],
      "source": [
        "# Type your answer in a comment here."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "# A hashtable is a data structure used for efficient implementation of\n",
        "# sets or maps. They need the key type to be hashable. They maintain a number of buckets,\n",
        "# each bucket containing multiple elements. The index of the bucket in which a given key is stored\n",
        "# is given by the hash function. That way, you can perform insertions, deletions and retrieval in amortized constant\n",
        "# asymptotic time complexity. That means that the THEORETICAL time it takes to perform those operations\n",
        "# does not grow with the number of elements that the hashtable contains."
      ],
      "metadata": {
        "id": "YOweq-t_J_M7",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Python dictionaries are implemented as hashtables. Let's try and represent some quantum state vectors with them. We will represent quantum kets as bitstrings using Python strings, for instance `\"101001\"`. Python also has built-in complex numbers, for instance you can write `myComplexNumber = 2+3.5j`.\n",
        "\n",
        "We are representing **sparse** state vectors, so do not add the zero amplitudes.\n",
        "\n",
        "Write below a Python dictionary representing the $\\left| + \\right>$ state, the Bell pair state and the GHZ state."
      ],
      "metadata": {
        "id": "Q44Onq120kVM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "# Write your answers below.\n",
        "\n",
        "plus = {}\n",
        "\n",
        "bell_pair = {}\n",
        "\n",
        "ghz = {}"
      ],
      "metadata": {
        "id": "iE2Y0W8A2k9K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "import math\n",
        "\n",
        "plus = {\"0\": math.sqrt(.5), \"1\": math.sqrt(.5)}\n",
        "bell_pair = {\"00\": math.sqrt(.5), \"11\": math.sqrt(.5)}\n",
        "ghz = {\"00000\": math.sqrt(.5), \"11111\": math.sqrt(.5)}\n",
        "print(plus)\n",
        "print(bell_pair)\n",
        "print(ghz)\n",
        "\n"
      ],
      "metadata": {
        "id": "tMIbZ6RSKkZG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09edc7f4-5c08-46e4-87b8-c13f57ac6df3",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'0': 0.7071067811865476, '1': 0.7071067811865476}\n",
            "{'00': 0.7071067811865476, '11': 0.7071067811865476}\n",
            "{'00000': 0.7071067811865476, '11111': 0.7071067811865476}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**[Bonus]** What do you think of representing kets with strings? How can you do better?"
      ],
      "metadata": {
        "id": "FgUw2Npz6-z-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "# Strings are intrinsically inefficient for that purpose: they are made to store all characters.\n",
        "# In Python, strings are unicode, one character uses a minumum of 1 byte, that is 8 bits.\n",
        "# Storing bits in a string is therefore very wasteful in terms of memory space.\n",
        "# A better alternative is to implement a proper bitset data structure, or to use\n",
        "# ad-hoc integers with bitmasks and bitwise operations to do this."
      ],
      "metadata": {
        "id": "0c3OYJBKK3sc",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. Now that we have states, let's define matrices. You know that matrices representing quantum gates are square, unitary matrices whose size is a power of two. For writing matrices we will use the famous `numpy` library. Write `numpy` arrays for the matrices of quantum gates X, Y, H and CNOT."
      ],
      "metadata": {
        "id": "FTX_2C9x4I37"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import math\n",
        "\n",
        "# Write your answers below.\n",
        "\n",
        "X = np.array([])\n",
        "\n",
        "Y = np.array([])\n",
        "\n",
        "H = np.array([])\n",
        "\n",
        "CNOT = np.array([])"
      ],
      "metadata": {
        "id": "CjLAVYV33PI-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "import numpy as np\n",
        "import math\n",
        "\n",
        "X = np.array([[0, 1], [1, 0]])\n",
        "\n",
        "Y = np.array([[0, -1j], [1j, 0]])\n",
        "\n",
        "H = math.sqrt(.5) * np.array([[1, 1], [1, -1]])\n",
        "\n",
        "CNOT = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])\n",
        "\n",
        "print(X)\n",
        "print(Y)\n",
        "print(H)\n",
        "print(CNOT)\n"
      ],
      "metadata": {
        "id": "m58Ur2rnLsrN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "832fda6a-4ae5-4291-c127-69b7e60ede9e",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1]\n",
            " [1 0]]\n",
            "[[ 0.+0.j -0.-1.j]\n",
            " [ 0.+1.j  0.+0.j]]\n",
            "[[ 0.70710678  0.70710678]\n",
            " [ 0.70710678 -0.70710678]]\n",
            "[[1 0 0 0]\n",
            " [0 1 0 0]\n",
            " [0 0 0 1]\n",
            " [0 0 1 0]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Quantum gate application is not a directly multiplication between the gate's matrix and the state vector. Indeed, the gate is often represented as a \"small\" matrix, but the state vector is in fact of size $2^N$ where $N$ is the number of qubits. What this means, is that you need an extra parameter, the operand or qubit index, to know how to apply the gate. This tells you the index of the gate in a tensor product of identities.\n",
        "\n",
        "Concretely, applying single-qubit gate $G$ to qubit $i$ starting from the right on a $N$ qubits system means multiplying the state vector by the matrix\n",
        "$$I ⊗ I \\otimes \\cdots \\otimes G \\otimes \\cdots \\otimes I$$\n",
        "where there are $i$ identities at the right of $G$.\n",
        "\n",
        "As for applying a quantum gate to a *sparse* state vector, it works the same as for normal state vectors, except that you won't see the zero or near-zero amplitudes."
      ],
      "metadata": {
        "id": "N86psTv8NMEG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Let's try to apply a gate to our sparse state vectors. We will only care about single-qubit gates. Write a Python function `apply(num_qubits, state_vector, matrix, operand)` which returns a new state vector, result of the application of `matrix` to `state_vector`.\n",
        "\n",
        "Note: we don't have to assume that the state vector is a proper quantum state vector, that is, that the sum of the squared modulus of the amplitudes is equal to 1. We also don't have to assume that the matrices are unitary. Your function should work in any case."
      ],
      "metadata": {
        "id": "n49xNeXf5lBD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import typing\n",
        "import numpy as np\n",
        "\n",
        "def apply(num_qubits: int, state_vector: dict[str, complex], matrix: np.ndarray, operand: int):\n",
        "  \"\"\"Given a `state_vector` describing a quantum state of `num_qubits` qubits, applies the gate given by\n",
        "    `matrix` to qubit index `operand`. Returns the new state vector after that gate application.\"\"\"\n",
        "  assert(matrix.shape == (2, 2))                                                         # Check that the input matrix is square 2x2\n",
        "  assert(all(len(ket) == num_qubits for ket in state_vector.keys()))                     # Check that the input state vector dictionary is well-formed\n",
        "  assert(all(all(c == '0' or c == '1' for c in ket) for ket in state_vector.keys()))     # Check that the input state vector dictionary is well-formed\n",
        "  assert(0 <= operand and operand < num_qubits)                                          # Check that the operand corresponds to a real qubit\n",
        "\n",
        "  # Write your answer here\n",
        "\n",
        "  return {\"0\": 1.}"
      ],
      "metadata": {
        "id": "8XRp7php6u6i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "import typing\n",
        "\n",
        "def apply(num_qubits: int, state_vector: dict[str, complex], matrix: np.ndarray, operand: int):\n",
        "  assert(matrix.shape == (2, 2))                                                         # Check that the input matrix is square 2x2\n",
        "  assert(all(len(ket) == num_qubits for ket in state_vector.keys()))                     # Check that the input state vector dictionary is well-formed\n",
        "  assert(all(all(c == '0' or c == '1' for c in ket) for ket in state_vector.keys()))     # Check that the input state vector dictionary is well-formed\n",
        "  assert(0 <= operand and operand < num_qubits)                                          # Check that the operand corresponds to a real qubit\n",
        "\n",
        "  result = {}\n",
        "\n",
        "  for ket, amplitude in state_vector.items():\n",
        "    index = len(ket) - operand - 1\n",
        "    op = ket[index]\n",
        "    matrixCol = matrix[:, 0 if op == '0' else 1]\n",
        "\n",
        "    firstKet = ket[:index] + \"0\" + ket[index + 1:]\n",
        "\n",
        "    secondKet = ket[:index] + \"1\" + ket[index + 1:]\n",
        "\n",
        "    firstAmplitude = result.get(firstKet, 0.)\n",
        "    result[firstKet] = firstAmplitude + amplitude * matrixCol[0]\n",
        "\n",
        "    secondAmplitude = result.get(secondKet, 0.)\n",
        "    result[secondKet] = secondAmplitude + amplitude * matrixCol[1]\n",
        "\n",
        "  return result"
      ],
      "metadata": {
        "id": "jgx2GLA4GQaC",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can verify that your `apply` function works correctly by running the cell below. If it does not, you'll get an error message with context."
      ],
      "metadata": {
        "id": "Ce-uBBPr8X2G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "ATOL = 0.00000001\n",
        "def eq(left: dict[str, complex], right: dict[str, complex]):\n",
        "  \"\"\" Check equality between two sparse state vectors. \"\"\"\n",
        "  common_keys = [k for k in left.keys() if k in right]\n",
        "\n",
        "  if not all(abs(v) == 0 for k, v in left.items() if k not in common_keys):\n",
        "    return False\n",
        "\n",
        "  if not all(abs(v) == 0 for k, v in right.items() if k not in common_keys):\n",
        "    return False\n",
        "\n",
        "  for k in common_keys:\n",
        "    if abs(left[k] - right[k]) > ATOL:\n",
        "      return False\n",
        "\n",
        "  return True\n",
        "\n",
        "\n",
        "def checkResult(num_qubits, state_vector, matrix, operand, expected_output):\n",
        "  \"\"\" Check the result of `apply` on those parameters, raise an exception if incorrect. \"\"\"\n",
        "  result = apply(num_qubits, state_vector, matrix, operand)\n",
        "  is_correct = eq(result, expected_output)\n",
        "  if is_correct:\n",
        "    return\n",
        "\n",
        "  raise Exception(f\"ERROR: your function returned {result} for\\n\\n\\tnum_qubits\\n{num_qubits}\\n\\n\\tstate_vector\\n{state_vector}\\n\\n\\tmatrix\\n{matrix}\\n\\n\\toperand\\n{operand}\\n\\nbut should have returned\\n{expected_output}\")\n",
        "\n",
        "\n",
        "checkResult(1, {\"0\": 1.}, np.array([[1, 0], [0, 1]]), 0, {\"0\": 1.})\n",
        "checkResult(1, {\"0\": 1j}, np.array([[1, 0], [0, 1]]), 0, {\"0\": 1j})\n",
        "checkResult(1, {\"0\": 1j}, np.array([[1j, 0], [0, 1j]]), 0, {\"0\": -1.})\n",
        "checkResult(1, {\"0\": math.sqrt(.5), \"1\": math.sqrt(.5)}, math.sqrt(.5) * np.array([[1, 1], [1, -1]]), 0, {\"0\": 1.})\n",
        "checkResult(1, {\"0\": 1.}, math.sqrt(.5) * np.array([[1, 1], [1, -1]]), 0, {\"0\": math.sqrt(.5), \"1\": math.sqrt(.5)})\n",
        "checkResult(2, {\"00\": 1.}, np.array([[1, 0], [0, 1]]), 0, {\"00\": 1.})\n",
        "checkResult(2, {\"00\": 1.}, np.array([[0, 1], [1, 0]]), 0, {\"01\": 1.})\n",
        "checkResult(2, {\"00\": 1.}, np.array([[0, 1], [1, 0]]), 1, {\"10\": 1.})\n",
        "checkResult(2, {\"10\": 1.}, np.array([[0, 1], [1, 0]]), 0, {\"11\": 1.})\n",
        "checkResult(2, {\"00\": 1.}, math.sqrt(.5) * np.array([[1, 1], [1, -1]]), 1, {\"00\": math.sqrt(.5), \"10\": math.sqrt(.5)})\n",
        "checkResult(5, {\"00000\": math.sqrt(.5), \"11111\": math.sqrt(.5)}, np.array([[0, 1], [1, 0]]), 2, {\"00100\": math.sqrt(.5), \"11011\": math.sqrt(.5)})"
      ],
      "metadata": {
        "id": "nKDlZ6JC8czR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "What do you need to do to keep the state sparse when possible, when applying this algorithm?"
      ],
      "metadata": {
        "id": "RkOTVPSyJqL8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "# When inserting the elements in the result dict, make sure those amplitudes are non-zero,\n",
        "# or that their absolute value / module is above a certain threshold (since we're computing with approximations\n",
        "# due to floating-point arithmetic)."
      ],
      "metadata": {
        "id": "PVaKkOksMBvs",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**[Advanced bonus]** How do you do this for 2+ qubit gates?"
      ],
      "metadata": {
        "id": "4A2OcrlM-FI-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "# You need to extract the relevant bits (based on operands) in the correct order\n",
        "# and insert/add amplitudes for as many kets as their are lines in the matrix..."
      ],
      "metadata": {
        "id": "LFjuKbeoMURV",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# QX vs Qiskit\n",
        "\n",
        "For the second part we would like to demonstrate the internal capabilities of QX-simulator against Qiskit."
      ],
      "metadata": {
        "id": "P5wz8sWCU_26"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Install pre-requisites"
      ],
      "metadata": {
        "id": "hHdEuMnyrLlv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install qxelarator qiskit qiskit-aer\n",
        "import qxelarator, time, zipfile\n",
        "from qiskit import execute, QuantumCircuit, Aer, transpile\n",
        "\n",
        "# with zipfile.ZipFile('/content/QuantumAlgorithms.zip', 'r') as zip_ref:\n",
        "#     zip_ref.extractall('/content/extracted_folder')"
      ],
      "metadata": {
        "id": "FIc1A7OL0d75",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de5b3d46-a6cd-4f8d-ad8e-2c8fc0a0c6a9"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: qxelarator in /usr/local/lib/python3.10/dist-packages (0.6.4)\n",
            "Requirement already satisfied: qiskit in /usr/local/lib/python3.10/dist-packages (0.44.1)\n",
            "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.12.2)\n",
            "Requirement already satisfied: qiskit-terra==0.25.1 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.25.1)\n",
            "Requirement already satisfied: rustworkx>=0.13.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.13.1)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.23.5)\n",
            "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (3.11)\n",
            "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (5.9.5)\n",
            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.11.2)\n",
            "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.12)\n",
            "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.3.7)\n",
            "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (2.8.2)\n",
            "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (5.1.0)\n",
            "Requirement already satisfied: symengine<0.10,>=0.9 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.9.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (4.5.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit-terra==0.25.1->qiskit) (1.16.0)\n",
            "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit-terra==0.25.1->qiskit) (5.11.1)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit-terra==0.25.1->qiskit) (1.3.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Circuits\n",
        "wow_qx = \"\"\"\n",
        "version 1.0\n",
        "\n",
        "qubits 64\n",
        "h q[0];\n",
        "cnot q[0], q[1];\n",
        "cnot q[0], q[2];\n",
        "cnot q[0], q[3];\n",
        "cnot q[0], q[4];\n",
        "cnot q[0], q[5];\n",
        "cnot q[0], q[6];\n",
        "cnot q[0], q[7];\n",
        "cnot q[0], q[8];\n",
        "cnot q[0], q[9];\n",
        "cnot q[0], q[10];\n",
        "cnot q[0], q[11];\n",
        "cnot q[0], q[12];\n",
        "cnot q[0], q[13];\n",
        "cnot q[0], q[14];\n",
        "cnot q[0], q[15];\n",
        "cnot q[0], q[16];\n",
        "cnot q[0], q[17];\n",
        "cnot q[0], q[18];\n",
        "cnot q[0], q[19];\n",
        "cnot q[0], q[20];\n",
        "cnot q[0], q[21];\n",
        "cnot q[0], q[22];\n",
        "cnot q[0], q[23];\n",
        "cnot q[0], q[24];\n",
        "cnot q[0], q[25];\n",
        "cnot q[0], q[26];\n",
        "cnot q[0], q[27];\n",
        "cnot q[0], q[28];\n",
        "cnot q[0], q[29];\n",
        "cnot q[0], q[30];\n",
        "cnot q[0], q[31];\n",
        "cnot q[0], q[32];\n",
        "cnot q[0], q[33];\n",
        "cnot q[0], q[34];\n",
        "cnot q[0], q[35];\n",
        "cnot q[0], q[36];\n",
        "cnot q[0], q[37];\n",
        "cnot q[0], q[38];\n",
        "cnot q[0], q[39];\n",
        "cnot q[0], q[40];\n",
        "cnot q[0], q[41];\n",
        "cnot q[0], q[42];\n",
        "cnot q[0], q[43];\n",
        "cnot q[0], q[44];\n",
        "cnot q[0], q[45];\n",
        "cnot q[0], q[46];\n",
        "cnot q[0], q[47];\n",
        "cnot q[0], q[48];\n",
        "cnot q[0], q[49];\n",
        "cnot q[0], q[50];\n",
        "cnot q[0], q[51];\n",
        "cnot q[0], q[52];\n",
        "cnot q[0], q[53];\n",
        "cnot q[0], q[54];\n",
        "cnot q[0], q[55];\n",
        "cnot q[0], q[56];\n",
        "cnot q[0], q[57];\n",
        "cnot q[0], q[58];\n",
        "cnot q[0], q[59];\n",
        "cnot q[0], q[60];\n",
        "cnot q[0], q[61];\n",
        "cnot q[0], q[62];\n",
        "cnot q[0], q[63];\n",
        "\"\"\"\n",
        "\n",
        "wow_qiskit = \"\"\"\n",
        "OPENQASM 2.0;\n",
        "include \"qelib1.inc\";\n",
        "qreg q[64];\n",
        "\n",
        "h q[0];\n",
        "cx q[0], q[1];\n",
        "cx q[0], q[2];\n",
        "cx q[0], q[3];\n",
        "cx q[0], q[4];\n",
        "cx q[0], q[5];\n",
        "cx q[0], q[6];\n",
        "cx q[0], q[7];\n",
        "cx q[0], q[8];\n",
        "cx q[0], q[9];\n",
        "cx q[0], q[10];\n",
        "cx q[0], q[11];\n",
        "cx q[0], q[12];\n",
        "cx q[0], q[13];\n",
        "cx q[0], q[14];\n",
        "cx q[0], q[15];\n",
        "cx q[0], q[16];\n",
        "cx q[0], q[17];\n",
        "cx q[0], q[18];\n",
        "cx q[0], q[19];\n",
        "cx q[0], q[20];\n",
        "cx q[0], q[21];\n",
        "cx q[0], q[22];\n",
        "cx q[0], q[23];\n",
        "cx q[0], q[24];\n",
        "cx q[0], q[25];\n",
        "cx q[0], q[26];\n",
        "cx q[0], q[27];\n",
        "cx q[0], q[28];\n",
        "cx q[0], q[29];\n",
        "cx q[0], q[30];\n",
        "cx q[0], q[31];\n",
        "cx q[0], q[32];\n",
        "cx q[0], q[33];\n",
        "cx q[0], q[34];\n",
        "cx q[0], q[35];\n",
        "cx q[0], q[36];\n",
        "cx q[0], q[37];\n",
        "cx q[0], q[38];\n",
        "cx q[0], q[39];\n",
        "cx q[0], q[40];\n",
        "cx q[0], q[41];\n",
        "cx q[0], q[42];\n",
        "cx q[0], q[43];\n",
        "cx q[0], q[44];\n",
        "cx q[0], q[45];\n",
        "cx q[0], q[46];\n",
        "cx q[0], q[47];\n",
        "cx q[0], q[48];\n",
        "cx q[0], q[49];\n",
        "cx q[0], q[50];\n",
        "cx q[0], q[51];\n",
        "cx q[0], q[52];\n",
        "cx q[0], q[53];\n",
        "cx q[0], q[54];\n",
        "cx q[0], q[55];\n",
        "cx q[0], q[56];\n",
        "cx q[0], q[57];\n",
        "cx q[0], q[58];\n",
        "cx q[0], q[59];\n",
        "cx q[0], q[60];\n",
        "cx q[0], q[61];\n",
        "cx q[0], q[62];\n",
        "cx q[0], q[63];\n",
        "\n",
        "\n",
        "\n",
        "\"\"\""
      ],
      "metadata": {
        "cellView": "form",
        "id": "IMhD7mYmcGRh"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Simulate 64 qubits, woow\n",
        "\n",
        "QX can handle this easily but Qiskit takes a lot of time and we have to quit the execution because it will crash. Check out the printed message!\n",
        "\n",
        "After force quiting, we need to run the pre-requisites cell again.\n"
      ],
      "metadata": {
        "id": "qHOL4o_aXG1e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "elapsed = time.time()\n",
        "result = qxelarator.execute_string(wow_qx)\n",
        "print(result)\n",
        "print(\"--- %s seconds Elapsed time QX---\" % (time.time() - elapsed))\n",
        "\n",
        "\n",
        "qc = QuantumCircuit.from_qasm_str(wow_qiskit)\n",
        "elapsed = time.time()\n",
        "simulator = Aer.get_backend(\"statevector_simulator\") # qasm_simulator, statevector_simulator\n",
        "# Transpile the circuit for the simulator\n",
        "compiled_circuit = transpile(qc, simulator)\n",
        "# Run the simulation\n",
        "result = simulator.run(compiled_circuit).result()\n",
        "print(\"--- %s seconds Elapsed time Qiskit---\" % (time.time() - elapsed))\n",
        "# Get the state vector from the results\n",
        "statevector = result.get_statevector()\n",
        "# statevector\n",
        "#print(counts)"
      ],
      "metadata": {
        "id": "zwuPkcO7XG1s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa0e12c1-1dec-4ac9-b1e0-b556a9e13cc4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shots requested: 1\n",
            "Shots done: 1\n",
            "Results: {'0000000000000000000000000000000000000000000000000000000000000000': 1}\n",
            "State: {'0000000000000000000000000000000000000000000000000000000000000000': (0.7071067811865475+0j), '1111111111111111111111111111111111111111111111111111111111111111': (0.7071067811865475+0j)}\n",
            "--- 0.0239713191986084 seconds Elapsed time QX---\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Quantum Volume\n",
        "\n",
        "The following comparison might not be fair as we get different probability distribution each time. In this example a instance of 5-qubit Quantum Volume cicruit is executed `range = 100` times and the measuremnt outcome is sampled. We can see distrubutions between Qiksit and QX are different each time we run the cell.\n",
        "\n",
        "Regardless, what do you observe the elapsed time? How can you explain the result?\n",
        "\n",
        "Quantum Volume circuits are random by nature and its type gate ratios are not in our control. Therefore, in the upcoming examples we have handpicked our quantum algorithm to be identical for cqasm and openqasm."
      ],
      "metadata": {
        "id": "04XpalIMsZ8U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "range = 100 # interation times\n",
        "rang = [0]*range\n",
        "\n",
        "#Qiskit\n",
        "\n",
        "qc = QuantumCircuit.from_qasm_file(\"/content/extracted_folder/QuantumAlgorithms/openqasm/quantum_volume_5.qasm\") # quantum_volume_15\n",
        "# You can choose other backend also.\n",
        "elapsed = time.time()\n",
        "counts_dict = {}\n",
        "for i in rang:\n",
        "    simulator = Aer.get_backend(\"statevector_simulator\") # qasm_simulator, statevector_simulator\n",
        "    # Transpile the circuit for the simulator\n",
        "    compiled_circuit = transpile(qc, simulator)\n",
        "    # Run the simulation\n",
        "    result = simulator.run(compiled_circuit).result()\n",
        "    counts = result.get_counts()\n",
        "    if list(counts.keys())[0] in counts_dict:  # Check if the key exists in the dictionary\n",
        "        counts_dict[list(counts.keys())[0]] += list(counts.values())[0]\n",
        "    else:\n",
        "        counts_dict[list(counts.keys())[0]] = list(counts.values())[0]\n",
        "print(\"--- %s seconds Elapsed time Qiskit---\" % (time.time() - elapsed))\n",
        "# Get the state vector from the results\n",
        "statevector = result.get_statevector()\n",
        "print(counts_dict)\n",
        "statevector\n",
        "#print(counts)\n",
        "print(statevector)\n",
        "\n",
        "# plot_state_qsphere(statevector)\n",
        "\n",
        "#QX\n",
        "with open(\"/content/extracted_folder/QuantumAlgorithms/cqasm/quantum_volume_5.qasm\", \"r\") as file: # quantum_volume_15\n",
        "    content = file.read()\n",
        "    # print(content)\n",
        "    elapsed = time.time()\n",
        "    result = qxelarator.execute_string(content,iterations=range)\n",
        "    print(\"--- %s seconds Elapsed time QX---\" % (time.time() - elapsed))\n",
        "result\n"
      ],
      "metadata": {
        "id": "aZMSGjXlpRTV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99152d8d-9224-4bfa-aba1-40369116acef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--- 16.74353528022766 seconds Elapsed time Qiskit---\n",
            "{'10111': 2, '11110': 4, '11111': 13, '00000': 4, '00111': 1, '11101': 6, '01111': 16, '10001': 5, '01100': 2, '10000': 4, '00011': 5, '01011': 3, '00100': 2, '01101': 6, '11010': 2, '10101': 1, '11011': 4, '10100': 4, '00101': 4, '00010': 1, '10011': 3, '00110': 4, '01110': 3, '01010': 1}\n",
            "Statevector([ 0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       , -0.54672612+0.8373115j,\n",
            "              0.        +0.j       , -0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ,\n",
            "             -0.        +0.j       , -0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       , -0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       , -0.        +0.j       ,\n",
            "             -0.        +0.j       ,  0.        +0.j       ,\n",
            "             -0.        +0.j       ,  0.        +0.j       ,\n",
            "             -0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ,\n",
            "             -0.        +0.j       ,  0.        +0.j       ,\n",
            "              0.        +0.j       ,  0.        +0.j       ],\n",
            "            dims=(2, 2, 2, 2, 2))\n",
            "--- 0.13690614700317383 seconds Elapsed time QX---\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Shots requested: 100\n",
              "Shots done: 100\n",
              "Results: {'00001': 4, '00010': 2, '00011': 8, '00100': 2, '00101': 4, '00110': 1, '00111': 1, '01000': 1, '01001': 1, '01010': 1, '01011': 6, '01100': 2, '01101': 6, '01110': 11, '01111': 25, '10000': 2, '10001': 6, '10010': 1, '10011': 5, '10100': 2, '10101': 1, '10110': 1, '10111': 2, '11000': 3, '11101': 2}\n",
              "State: {'00011': (-0.46860680227018026-0.8834068512673626j)}"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Quantum Algorithm comparisons\n",
        "\n",
        "Here we compare performances of QX versus Qiskit for different algorithms.\n",
        "For Bernstein-Vazirani of 5 and 10 qubits (`bern_5, bern_10`), QX is faster. Also, both QFT algorithms (`qft_5, qft_15`) are faster in QX but for more than 15 qubits (`25` for example) is slower.\n"
      ],
      "metadata": {
        "id": "k_YIhAW-tHC2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "range = 100 # interation times\n",
        "rang = [0]*range\n",
        "\n",
        "#Qiskit\n",
        "qc = QuantumCircuit.from_qasm_file(\"/content/extracted_folder/QuantumAlgorithms/openqasm/bern_10.qasm\") # qft_5, qft_15, qft_25, bern_5, bern_10\n",
        "elapsed = time.time()\n",
        "for i in rang:\n",
        "    simulator = Aer.get_backend(\"statevector_simulator\") # qasm_simulator, statevector_simulator\n",
        "    # Transpile the circuit for the simulator\n",
        "    compiled_circuit = transpile(qc, simulator)\n",
        "    # Run the simulation\n",
        "    result = simulator.run(compiled_circuit).result()\n",
        "print(\"--- %s seconds Elapsed time Qiskit---\" % (time.time() - elapsed))\n",
        "# Get the state vector from the results\n",
        "statevector = result.get_statevector()\n",
        "#counts = result.get_counts()\n",
        "#print(counts)\n",
        "print(statevector)\n",
        "\n",
        "# plot_state_qsphere(statevector)\n",
        "\n",
        "#QX\n",
        "with open(\"/content/extracted_folder/QuantumAlgorithms/cqasm/bern_10.qasm\", \"r\") as file: # qft_5, qft_15, qft_25, bern_5, bern_1\n",
        "    content = file.read()\n",
        "    elapsed = time.time()\n",
        "    result = qxelarator.execute_string(content,iterations = range)\n",
        "print(\"--- %s seconds Elapsed time QX---\" % (time.time() - elapsed))\n",
        "result\n"
      ],
      "metadata": {
        "id": "iQaPg4WN55B0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16171710-ec0b-4c0d-fdef-103b9b161945"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--- 14.064067125320435 seconds Elapsed time Qiskit---\n",
            "Statevector([ 4.25007252e-17-4.32978028e-17j,\n",
            "              3.55724073e-17-6.74824734e-33j,\n",
            "             -4.33680869e-18+7.20533824e-33j, ...,\n",
            "              0.00000000e+00+0.00000000e+00j,\n",
            "              0.00000000e+00+0.00000000e+00j,\n",
            "              0.00000000e+00+0.00000000e+00j],\n",
            "            dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2))\n",
            "--- 1.6668477058410645 seconds Elapsed time QX---\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Shots requested: 1000\n",
              "Shots done: 1000\n",
              "Results: {'00000000000': 1000}\n",
              "State: {'01101101011': (0.7071067811865464+0j), '11101101011': (-0.7071067811865464+0j)}"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    }
  ]
}