task_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Circuit Compiler with Optimizer\n",
    "\n",
    "This is a quantum circuit compiler and optimizer which converts any given Cirq circuit made up of the basic gates: I, S, H, X, Y, Z, RX, RY, RZ, CNOT, CZ into a combination of our fundamental gates: RX, RZ, and CZ. It also optimizes if those combinations result in a net zero change in the state of qubit or if the application of multiple gates can be merged to a single gate, for example: `--RX(pi/2)-RX(pi/2)--` is effectively `--RX(pi)--`.\n",
    "\n",
    "Some of the supported features:\n",
    "* Compiler supports inclusion of more gates available in Cirq as long as they can be converted to a combination of the basic gates\n",
    "* Optimizer supports addition of custom optimizers and more quantum circuit identities\n",
    "* Optimizer supports replacement of a list of operations with another list of operations on a single qubit\n",
    "* Importing circuits from JSON files and URLs is also supported\n",
    "\n",
    "Information about how circuits and gates work in Cirq can be found [here](https://cirq.readthedocs.io/en/stable/).\n",
    "\n",
    "Even though this implementation is more function oriented than object oriented (because I feel like it allows for more customizations), it can be written in an object oriented manner whenever deemed appropriate.\n",
    "\n",
    "Note: I decided to perform this on a Jupyter Notebook as it will be easier to explain the steps than writing everything as comments in files. Also, this notebook can easily be converted to a python file but not the other way round, not without losing important information at least.\n",
    "\n",
    "Whew! Here we go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing required libraries\n",
    "\n",
    "Importing `cirq` as we will be using its various methods to create our compiler and optimizer.\n",
    "\n",
    "Importing `pi` from `math` as we are working with angles here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cirq\n",
    "from math import pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing/Creating a Circuit\n",
    "\n",
    "### Creating a cicruit\n",
    "\n",
    "We will be creating a list of `cirq.LineQubit()` qubits to apply the circuit upon and `N_QUBITS` is the total number of qubits that will be required by our sample circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Creating qubits for the sample circuit\n",
    "N_QUBITS = 5\n",
    "qubits = [cirq.LineQubit(i) for i in range(N_QUBITS)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a very basic circuit with Hadamard, RX, and CNOT gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0: ───H───@───Rx(0.5π)────────────────────────────────────\n          │\n1: ───H───X───@──────────Rx(0.5π)─────────────────────────\n              │\n2: ───H───────X──────────@──────────Rx(0.5π)──────────────\n                         │\n3: ──────────────────────X──────────@──────────Rx(0.5π)───\n                                    │\n4: ─────────────────────────────────X──────────Rx(0.5π)───",
      "text/html": "<pre style=\"overflow: auto; white-space: pre;\">0: ───H───@───Rx(0.5π)────────────────────────────────────\n          │\n1: ───H───X───@──────────Rx(0.5π)─────────────────────────\n              │\n2: ───H───────X──────────@──────────Rx(0.5π)──────────────\n                         │\n3: ──────────────────────X──────────@──────────Rx(0.5π)───\n                                    │\n4: ─────────────────────────────────X──────────Rx(0.5π)───</pre>"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "# Creat a new circuit\n",
    "input_circuit = cirq.Circuit()\n",
    "\n",
    "# Apply Hadamard Gate on first 3 qubits\n",
    "input_circuit.append([cirq.H(qubits[0])])\n",
    "input_circuit.append([cirq.H(qubits[1])])\n",
    "input_circuit.append([cirq.H(qubits[2])])\n",
    "\n",
    "# Apply CNOT Gate on consecutive qubits\n",
    "for i in range(N_QUBITS - 1):\n",
    "    input_circuit.append([cirq.CNOT(qubits[i], qubits[i + 1])])\n",
    "\n",
    "# Apply RX(pi/2) gate on all qubits\n",
    "rx = cirq.rx(pi / 2)\n",
    "for q in qubits:\n",
    "    input_circuit.append([rx(q)])                     \n",
    "\n",
    "# Print the circuit\n",
    "input_circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, in Cirq circuits are executed on a \"moment\" by \"moment\" basis where a `moment` is a time slice. All operations sharing a `moment` will be executed at once. So the first `moment`, in our sample circuit above, consists of a Hadamard gate operation on qubits `qubit[0], qubit[1], qubit[2]`. After executing that, the next `moment` made of a CNOT gate operation on `qubit[0]` as control qubit and `qubit[1]` as target qubit will be executed and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing a Circuit\n",
    "\n",
    "To import a circuit simply uncomment the appropriate line from the codeblock below, and provide the JSON or a url to the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import from JSON:\n",
    "# input_circuit = cirq.quirk_json_to_circuit(\"path/to/json/here\")\n",
    "\n",
    "# Import from a URL:\n",
    "# input_circuit = cirq.quirk_url_to_circuit(\"url/here\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compiling the Circuit\n",
    "Codeblock below contains the compiler functions for each supported gate. One can simply add a new gate by implementing a new compiler function `compile_GATE()` which takes in the qubits on which to apply the gate and theta if the gate changes a phase around any axis. It should return an equivalent combination of RX, RZ and CZ gates.\n",
    "\n",
    "For example, a CNOT Gate can be obtained by applying a CZ gate and surrounding the target qubit with Hadamard Gates. The function for that will be `compile_CNOT()` written below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Available gates for the compiled circuit\n",
    "def compile_rx(qubit, theta):\n",
    "    \"\"\"\n",
    "    --RX(theta)--\n",
    "    \"\"\"\n",
    "    rx = cirq.rx(theta)\n",
    "    return rx(qubit)\n",
    "\n",
    "\n",
    "def compile_rz(qubit, theta):\n",
    "    \"\"\"\n",
    "    --RZ(theta)--\n",
    "    \"\"\"\n",
    "    rz = cirq.rz(theta)\n",
    "    return rz(qubit)\n",
    "\n",
    "\n",
    "def compile_CZ(control_q, target_q):\n",
    "    \"\"\"\n",
    "    control_q: --@--\n",
    "                 |\n",
    "    target_q:  --@--\n",
    "    \"\"\"\n",
    "    return cirq.CZ(control_q, target_q)\n",
    "\n",
    "\n",
    "# Gates that were used by the input circuit \n",
    "# apart from the ones above\n",
    "def compile_ry(qubit, theta):\n",
    "    \"\"\"\n",
    "    --RY(theta)-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RX(pi/2)--RZ(theta)--RX(-pi/2)--\n",
    "    \"\"\"\n",
    "    return compile_rx(qubit, pi / 2),\\\n",
    "           compile_rz(qubit, theta),\\\n",
    "           compile_rx(qubit, -pi / 2)\n",
    "\n",
    "\n",
    "def compile_I(qubit):\n",
    "    \"\"\"\n",
    "    --I-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RX(2*pi)-- or\n",
    "    --RZ(2*pi)-- or\n",
    "    --RY(2*pi)--\n",
    "    \"\"\"\n",
    "    return compile_rx(qubit, 2 * pi)\n",
    "\n",
    "\n",
    "def compile_H(qubit):\n",
    "    \"\"\"\n",
    "    --H-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RZ(pi/2)--RX(pi/2)--RZ(pi/2)--\n",
    "    \"\"\"\n",
    "    return compile_rz(qubit, pi / 2),\\\n",
    "           compile_rx(qubit, pi / 2),\\\n",
    "           compile_rz(qubit, pi / 2)\n",
    "\n",
    "\n",
    "def compile_X(qubit):\n",
    "    \"\"\"\n",
    "    --X-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RX(pi)--\n",
    "    \"\"\"\n",
    "    return compile_rx(qubit, pi)\n",
    "\n",
    "\n",
    "def compile_Y(qubit):\n",
    "    \"\"\"\n",
    "    --Y-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RY(pi)--\n",
    "    \"\"\"\n",
    "    return compile_ry(qubit, pi)\n",
    "\n",
    "\n",
    "def compile_Z(qubit):\n",
    "    \"\"\"\n",
    "    --Z-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RZ(pi)--\n",
    "    \"\"\"\n",
    "    return compile_rz(qubit, pi)\n",
    "\n",
    "\n",
    "def compile_S(qubit):\n",
    "    \"\"\"\n",
    "    --S-- \n",
    "    \n",
    "    is equivalent to\n",
    "    \n",
    "    --RZ(pi/2)--\n",
    "    \"\"\"\n",
    "    return compile_rz(qubit, pi / 2)\n",
    "\n",
    "\n",
    "def compile_CNOT(control_q, target_q):\n",
    "    \"\"\"\n",
    "    control_q: --@--\n",
    "                 |\n",
    "    target_q:  --X--\n",
    "    \n",
    "    is equivalent to\n",
    "\n",
    "    control_q: ----@----\n",
    "                   |\n",
    "    target_q:  --H-@-H--\n",
    "    \"\"\"\n",
    "    return compile_H(target_q),\\\n",
    "           compile_CZ(control_q, target_q),\\\n",
    "           compile_H(target_q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method `get_compiled_ops()`, defined below, detects the gate operation being performed in a moment and calls the respective `compile_GATE()` function. It then returns the list of compiled operations. Explanation is written in the function's description.\n",
    "\n",
    "More gates can be added by adding an `elif` statement here and passing the required parameters to the new `compile_GATE()` function accordingly.\n",
    "\n",
    "Attributes of a gate operation `op` can be accessed as:\n",
    "\n",
    "* `op.gate` returns the gate that was applied to the qubit(s) by the operation `op`.\n",
    "\n",
    "* `op.qubits` returns the list of qubits upon which the operation `op` was performed. \n",
    "\n",
    "For more information on `cirq.GateOperation` objects click [here](https://cirq.readthedocs.io/en/stable/generated/cirq.GateOperation.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_compiled_ops(moment):\n",
    "    \"\"\"\n",
    "    input: \n",
    "        moment: cirq.Moment object\n",
    "    \n",
    "    return: \n",
    "        compiled_operations: list of cirq.GateOperation objects\n",
    "\n",
    "    Replaces the operations in given moment to\n",
    "    a combination of fundamental gates:\n",
    "    RX, RZ, and CZ \n",
    "    \"\"\"\n",
    "    compiled_operations = []\n",
    "    \n",
    "    # For each operation in a moment\n",
    "    for op in moment.operations:\n",
    "\n",
    "        # Retrieve which gate operation is being performed\n",
    "        gate = op.gate\n",
    "\n",
    "        # Compile gates accordingly:\n",
    "        \n",
    "        # Single qubit gates\n",
    "        if gate == cirq.I:\n",
    "            new_op = compile_I(op.qubits[0])\n",
    "\n",
    "        elif gate == cirq.H:\n",
    "            new_op = compile_H(op.qubits[0])\n",
    "\n",
    "        elif gate == cirq.X:\n",
    "            new_op = compile_X(op.qubits[0])\n",
    "\n",
    "        elif gate == cirq.Y:\n",
    "            new_op = compile_Y(op.qubits[0])\n",
    "\n",
    "        elif gate == cirq.Z:\n",
    "            new_op = compile_Z(op.qubits[0])\n",
    "        \n",
    "        elif gate == cirq.S:\n",
    "            new_op = compile_S(op.qubits[0])\n",
    "        \n",
    "        # Two qubit gates\n",
    "        elif gate == cirq.CNOT:\n",
    "            new_op = compile_CNOT(op.qubits[0], op.qubits[1])\n",
    "\n",
    "        elif gate == cirq.CZ:\n",
    "            new_op = compile_CZ(op.qubits[0], op.qubits[1])\n",
    "        \n",
    "        # Single qubit rotation gates around x, y, z axis\n",
    "        # on Bloch sphere with rotation by theta radians\n",
    "        else:\n",
    "\n",
    "            # Retrieve the value of theta\n",
    "            theta = gate.exponent * pi\n",
    "\n",
    "            if gate == cirq.rx(theta):\n",
    "                new_op = compile_rx(op.qubits[0], theta)\n",
    "\n",
    "            elif gate == cirq.ry(theta):\n",
    "                new_op = compile_ry(op.qubits[0], theta)\n",
    "\n",
    "            elif gate == cirq.rz(theta):\n",
    "                new_op = compile_rz(op.qubits[0], theta)\n",
    "            \n",
    "            else:\n",
    "                # If an unrecognized gate found then leave as is\n",
    "                new_op = op\n",
    "\n",
    "\n",
    "        # Add the new operation to the list of compiled operations\n",
    "        compiled_operations.append(new_op)\n",
    "        \n",
    "    return compiled_operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiling the circuit on a moment by moment basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)────────────────────────────────────@───Rx(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                        │\n1: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                                                             │\n2: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)─────────────────────────────────────────────────────────────────────────\n                                                                                                                                                  │\n3: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)────────────────────────────────────\n                                                                                                                                                                                       │\n4: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rx(0.5π)───",
      "text/html": "<pre style=\"overflow: auto; white-space: pre;\">0: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)────────────────────────────────────@───Rx(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                        │\n1: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                                                             │\n2: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)─────────────────────────────────────────────────────────────────────────\n                                                                                                                                                  │\n3: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)────────────────────────────────────\n                                                                                                                                                                                       │\n4: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rx(0.5π)───</pre>"
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "# Create a new circuit to store the compiled circuit\n",
    "compiled_circuit = cirq.Circuit()\n",
    "\n",
    "# For each moment in input circuit get compiled operations\n",
    "for moment in input_circuit:\n",
    "    compiled_circuit.append(get_compiled_ops(moment))\n",
    "\n",
    "# Print the compiled circuit\n",
    "compiled_circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the decreased visual appeal, our compiled circuit has a lot more moments than our input circuit. This increase in the number of moments can be considered as the overhead generated by our compiler. So, let's see how we can decrease this number to restrict its impact on performance when executing the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Number of moments in the input circuit:  6\nNumber of moments in the compiled output circuit:  23\n"
    }
   ],
   "source": [
    "print(\"Number of moments in the input circuit: \", len(input_circuit))\n",
    "print(\"Number of moments in the compiled output circuit: \", len(compiled_circuit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizing the Compiled Circuit\n",
    "\n",
    "Below are lists of operations which if applied in series to a qubit, result in either effectively doing nothing or another single qubit operation. Thus, that list of operations can be replaced with a single operation.\n",
    "\n",
    "For example, if our optimizer encountered similar gate operations occurring consecutively like `--RX(pi)--RX(pi/2)--`, then it will merge those two into a single gate operation `--RX(3*pi/2)--`, using `merge_similar_ops()` function defined below.\n",
    "\n",
    "Also, it is to be noted that the operations in the lists below are written in reverse order of their application wherever it matters, since the method that compares them to the operations in the circuit, uses a stack. So, for example, if the optimizer encountered the compiled equivalent of `--Y-Y--`:\n",
    "\n",
    "\n",
    "* `--RX(pi/2)--RZ(pi)--RX(-pi/2)--RX(pi/2)--RZ(pi)--RX(-pi/2)--`\n",
    "\n",
    "\n",
    "which after merging similar gates, becomes:\n",
    "\n",
    "* `--RX(pi/2)--RZ(pi)--RX(0)--RZ(pi)--RX(-pi/2)--`\n",
    "\n",
    "but when these are put in a stack, they will become:\n",
    "\n",
    "* `--RX(-pi/2)--RZ(pi)--RX(0)--RZ(pi)--RX(pi/2)--`\n",
    "\n",
    "So, if we compare this stack to the list of operations `[cirq.rx(-pi / 2), cirq.rz(pi), cirq.rx(0), cirq.rz(pi), cirq.rx(pi / 2)]` (which is compiled equivalent of `--Y-Y--` but reversed) it will then return `True`. This merging is performed by the function `merge_different_ops()` defined below.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since there are numerous quantum identities which allow replacement of multiple operations with a different set of operations, I have included the option to add more identities by simply adding a reverse ordered list of operations in the respective `can_be_merged_to_` list, or to the `can_be_merged_to_custom` list for customized replacement. Make sure to implement the corresponding `elif` condition in `merge_different_ops()` function.\n",
    "\n",
    "Some identities that have already been implemented (apart from the ones obtained by the definition of a unitary operation):\n",
    "\n",
    "* `--X-Y-Z--` is equivalent to `--I--`\n",
    "\n",
    "* `--H-Z-H--` is equivalent to `--X--`\n",
    "\n",
    "* `--H-X-H--` is equivalent to `--Z--`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gate combinations that can be merged to I, X, Z \n",
    "# in reversed order for comparison to a stack\n",
    "\n",
    "can_be_merged_to_i = [\n",
    "\n",
    "    # for --X-X--\n",
    "    [cirq.rx(2 * pi)],\n",
    "    \n",
    "    # for --Y-Y--\n",
    "    [cirq.rx(-pi / 2), cirq.rz(pi), \n",
    "     cirq.rx(0), cirq.rz(pi), cirq.rx(pi / 2)],\n",
    "    \n",
    "    # for --Z-Z--\n",
    "    [cirq.rz(2 * pi)],\n",
    "    \n",
    "    # for --X-Y-Z--\n",
    "    [cirq.rz(pi), cirq.rx(-pi / 2), \n",
    "     cirq.rz(pi), cirq.rx(3 * pi / 2)],\n",
    "    \n",
    "    # for --H-H--\n",
    "    [cirq.rz(pi / 2), cirq.rx(pi / 2), \n",
    "     cirq.rz(pi), cirq.rx(pi / 2), cirq.rz(pi / 2)],\n",
    "\n",
    "]\n",
    "\n",
    "can_be_merged_to_x = [\n",
    "    \n",
    "    # for --H-Z-H--\n",
    "    [cirq.rz(pi / 2), cirq.rx(pi), cirq.rz(pi / 2)]\n",
    "\n",
    "]\n",
    "\n",
    "can_be_merged_to_z = [\n",
    "\n",
    "    # for --H-X-H--\n",
    "    [cirq.rz(pi / 2), cirq.rx(pi / 2), \n",
    "     cirq.rz(pi / 2), cirq.rx(pi), \n",
    "     cirq.rz(pi / 2), cirq.rx(pi / 2), cirq.rz(pi / 2)]\n",
    "     \n",
    "]\n",
    "\n",
    "# More single qubit quantum circuit\n",
    "# identities can be added here\n",
    "can_be_merged_to_custom = [\n",
    "\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizer Definitions\n",
    "\n",
    "Descriptions about a particular optimizer can be found in their respective definitions.\n",
    "A custom optimizer can also be created by implementing the `custom_optimizer()` function then adding it to the `optimizers` list below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "def merge_similar_ops(input_ops):\n",
    "    \"\"\"\n",
    "    input: \n",
    "        input_ops: list of cirq.GateOperation objects\n",
    "    \n",
    "    return: \n",
    "        opt_ops: list of cirq.GateOperation objects\n",
    "\n",
    "    Attempts to combine consecutive rotation \n",
    "    operations which operate around the same axis and\n",
    "    return an equivalent single rotation operation.\n",
    "\n",
    "    For example,\n",
    "    \n",
    "    --RX(pi)-RX(pi)--\n",
    "    \n",
    "    will be combined to form\n",
    "    \n",
    "    --RX(2*pi)--\n",
    "    \"\"\"\n",
    "\n",
    "    # List of optimized operations\n",
    "    opt_ops = []\n",
    "    \n",
    "    # Retrieve the qubit on which \n",
    "    # the operations are being performed\n",
    "    q = input_ops[0].qubits[0]\n",
    "    \n",
    "    # Append the first input operation to \"opt_ops\"\n",
    "    opt_ops.append(input_ops[0])\n",
    "\n",
    "    # For each operation in the \"input_ops\" list \n",
    "    # after the first one\n",
    "    for operation in input_ops[1:]:\n",
    "\n",
    "        # Check whether the last gate in \"opt_ops\" is\n",
    "        # similar to the current operation's gate\n",
    "        if type(opt_ops[-1].gate) == type(operation.gate):      \n",
    "\n",
    "            # Retrieve theta from both operations\n",
    "            theta_1 = opt_ops[-1].gate.exponent * pi\n",
    "            theta_2 = operation.gate.exponent * pi\n",
    "            \n",
    "            # Merge two operations depending upon\n",
    "            # whether they are RX or RZ gates\n",
    "            if opt_ops[-1].gate == cirq.rx(theta_1):\n",
    "                opt_gate = cirq.rx(theta_1 + theta_2)\n",
    "                opt_ops[-1] = opt_gate(q)\n",
    "            \n",
    "            elif opt_ops[-1].gate == cirq.rz(theta_1):\n",
    "                opt_gate = cirq.rz(theta_1 + theta_2)\n",
    "                opt_ops[-1] = opt_gate(q)\n",
    "\n",
    "            \n",
    "            # If two CZ gates were found touching this qubit\n",
    "            # append current operation to \"opt_ops\"\n",
    "            else:\n",
    "                opt_ops.append(operation)\n",
    "        \n",
    "        \n",
    "        # If gates are not similar then \n",
    "        # append current operation to \"opt_ops\"\n",
    "        else:\n",
    "            opt_ops.append(operation)                           \n",
    "\n",
    "    return opt_ops\n",
    "\n",
    "\n",
    "def merge_different_ops(input_ops):\n",
    "    \"\"\"\n",
    "    input: \n",
    "        input_ops: list of cirq.GateOperation objects\n",
    "\n",
    "    return:\n",
    "        opt_ops: list of cirq.GateOperation objects\n",
    "\n",
    "    Attempts to replace the given\n",
    "    set of operations(input_ops) with a different\n",
    "    but equivalent set of operations(opt_ops)\n",
    "    in order to reduce their size, i.e, if optimized,\n",
    "    \n",
    "    len(opt_ops) < len(input_ops)\n",
    "    \n",
    "    For example, --H-Z-H-- after compilation,\n",
    "    \n",
    "    --RZ(pi/2)--RX(pi)--RZ(pi/2)--\n",
    "    \n",
    "    will be combined to form\n",
    "    \n",
    "    --RX(pi)--\n",
    "    \n",
    "    Note: Identity gates will be removed by\n",
    "          this optimizer as they effectively\n",
    "          have no impact on a qubit\n",
    "    \"\"\"\n",
    "\n",
    "    # List of optimized operations\n",
    "    opt_ops = []\n",
    "    \n",
    "    # Retrieve the qubit on which \n",
    "    # the operations are being performed\n",
    "    q = input_ops[0].qubits[0]\n",
    "    \n",
    "    # Stacks for comparing gate combinations\n",
    "    stack_gates = []\n",
    "    stack_ops = []\n",
    "\n",
    "    # For each operation in input operations\n",
    "    for operation in input_ops:\n",
    "        \n",
    "        # Append current operation to \"opt_ops\"\n",
    "        opt_ops.append(operation)\n",
    "\n",
    "        # Run until \"opt_ops\" is empty\n",
    "        while(len(opt_ops) > 0):\n",
    "            \n",
    "            # Transfer last operation in \"opt_ops\" to\n",
    "            # \"stack_ops\" and its gate to \"stack_gates\"\n",
    "            stack_ops.append(opt_ops.pop())\n",
    "            stack_gates.append(stack_ops[-1].gate)\n",
    "            \n",
    "            # Merge operations if the gate combination\n",
    "            # in \"stack_gate\" is mergeable\n",
    "            if stack_gates in can_be_merged_to_i:\n",
    "                stack_gates.clear()\n",
    "                stack_ops.clear()\n",
    "\n",
    "            elif stack_gates in can_be_merged_to_x:\n",
    "                stack_gates.clear()\n",
    "                stack_ops.clear()\n",
    "                X = cirq.rx(pi)\n",
    "                stack_ops.append(X(q))\n",
    "                stack_gates.append(X)\n",
    "                \n",
    "            elif stack_gates in can_be_merged_to_z:\n",
    "                stack_gates.clear()\n",
    "                stack_ops.clear()\n",
    "                Z = cirq.rz(pi)\n",
    "                stack_ops.append(Z(q))\n",
    "                stack_gates.append(Z)\n",
    "\n",
    "        # Empty \"stack_gates\" once comparison of gate\n",
    "        # combinations is complete upto current operation\n",
    "        stack_gates.clear()\n",
    "        \n",
    "        # Transfer merged operations back into \"opt_ops\"\n",
    "        while(len(stack_ops) > 0):\n",
    "            opt_ops.append(stack_ops.pop())\n",
    "\n",
    "\n",
    "    return opt_ops\n",
    "\n",
    "def custom_optimizer(input_ops):\n",
    "    \"\"\"\n",
    "    input: \n",
    "        input_ops: list of cirq.GateOperation objects\n",
    "    \n",
    "    return: \n",
    "        opt_ops: list of cirq.GateOperation objects\n",
    "\n",
    "    Implement a custom optimizer which replaces here.\n",
    "    By default it returns the list of operations as is.\n",
    "    \"\"\"\n",
    "    return input_ops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `optimize()` optimizes given circuit according to the `optimizers` passed to it. It manipulates the circuit in-place using `cirq.MergeSingleQubitGates` and `cirq.DropEmptyMoments`. For more information on how they work click [here](https://cirq.readthedocs.io/en/stable/api.html#optimization).\n",
    "\n",
    "Note: This function currently supports optimizing single qubit gates only. Support for multi-qubit gates can be added using a variety of methods provided by Cirq mentioned [here](https://cirq.readthedocs.io/en/stable/api.html#optimization)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def optimize(circuit, optimizers):\n",
    "    \"\"\"\n",
    "    input: \n",
    "        circuit: cirq.Circuit object\n",
    "        optimizers: list of optimizer functions\n",
    "    \n",
    "    return: \n",
    "        opt_circuit: cirq.Circuit object\n",
    "\n",
    "    This function will apply given optimizers\n",
    "    on the input circuit and drop any empty\n",
    "    moments if present.\n",
    "    \"\"\"\n",
    "\n",
    "    # Clone the input circuit to avoid\n",
    "    # in-place modifications to it\n",
    "    opt_circuit = cirq.Circuit(circuit)\n",
    "    \n",
    "    # For each optimizer in optimizers\n",
    "    for opt in optimizers:\n",
    "\n",
    "        # Merge single qubit operations as specified in \"opt\"\n",
    "        cirq.MergeSingleQubitGates(rewriter=opt).optimize_circuit(opt_circuit)\n",
    "    \n",
    "    # Drop empty moments, if present, from the optimized circuit\n",
    "    cirq.DropEmptyMoments().optimize_circuit(opt_circuit)\n",
    "    \n",
    "    return opt_circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optimizing our compiled circuit according to optimizers provided in the list below.\n",
    "\n",
    "Note: The order of elements in `optimizers` matters as they will be applied sequentially to the circuit. Also, it is highly recommended that `merge_similar_op` remains the first element for best results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "0: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                       │\n1: ────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                            │\n2: ─────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)─────────────────────────────────────────────────────────────────────────\n                                                                                                                 │\n3: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)─────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)────────────────────────────────────\n                                                                                                                                                      │\n4: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rx(0.5π)───",
      "text/html": "<pre style=\"overflow: auto; white-space: pre;\">0: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                       │\n1: ────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────\n                                                                            │\n2: ─────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)─────────────────────────────────────────────────────────────────────────\n                                                                                                                 │\n3: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)─────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───@───Rx(0.5π)────────────────────────────────────\n                                                                                                                                                      │\n4: ───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)──────────────────────────────────────────────────────────────────────────────────────────────────────────────────@───Rz(0.5π)───Rx(0.5π)───Rz(0.5π)───Rx(0.5π)───</pre>"
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "# List of optimizers to be used\n",
    "optimizers = [merge_similar_ops, merge_different_ops]\n",
    "\n",
    "# Obtain the optimized circuit\n",
    "optimized_circuit = optimize(compiled_circuit, optimizers)\n",
    "\n",
    "# Print the optimized circuit\n",
    "optimized_circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Now, after optimization we can observe an improvement in the overhead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Number of Moments in the input circuit:  6\nNumber of Moments in the compiled output circuit:  23\nNumber of Moments in the optimized circuit:  20\n"
    }
   ],
   "source": [
    "print(\"Number of Moments in the input circuit: \", len(input_circuit))\n",
    "print(\"Number of Moments in the compiled output circuit: \", len(compiled_circuit))\n",
    "print(\"Number of Moments in the optimized circuit: \", len(optimized_circuit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "After basic optimizations we were able to reduce the overhead generated by our compiled circuit. The optimized circuit also looks less involved than before.\n",
    "\n",
    "Keep in mind that not all circuits can be improved like this, for example if a circuit is already simplified by optimizer's standards then it will not result in a better circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Number of moments in the optimized circuit:  20\nNumber of moments in the double optimized circuit:  20\n"
    }
   ],
   "source": [
    "print(\"Number of moments in the optimized circuit: \", len(optimized_circuit))\n",
    "print(\"Number of moments in the double optimized circuit: \", len(optimize(optimized_circuit, optimizers)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Future Work\n",
    "\n",
    "There are some things which I believe can be implemented in future iterations to improve upon the current implementation:\n",
    "\n",
    "* Organize the code in different files appropriately to scale\n",
    "* Optimizations for multi-qubit operations\n",
    "* Add more quantum circuit identities\n",
    "* Add support for more gates\n",
    "* Add support for more kinds of qubits other than `cirq.LineQubit()`\n",
    "* Look for more optimizations that can further reduce overhead generated by the compiler\n",
    "* Compile given circuit into a combination of any given set of gates, i.e, implement `compile(input_circuit, list_of_fundamental_gates_to_be_used)`\n",
    "\n",
    "Apart from these, feel free to open a PR to suggest more features that you think will be great!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('qc': conda)",
   "language": "python",
   "name": "python_defaultSpec_1600394479467"
  },
  "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-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}