blqs_cirq/hello_blqs_cirq.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "37b27f5f-4011-46e2-b767-7f042c108b53",
   "metadata": {},
   "source": [
    "# Hello Blqs_cirq\n",
    "\n",
    "In this notebook you will find a simple explanation for the motivation for blqs_cirq.  First make sure blqs_cirq is installed (it will install blqs and cirq as dependencies)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7c6d8a71-ea9c-424b-9f2d-6e15880509ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import blqs_cirq\n",
    "except ImportError:\n",
    "    print(\"installing blqs_cirq...\")\n",
    "    !pip install --quiet blqs\n",
    "    print(\"installed blqs_cirq.\")\n",
    "\n",
    "import blqs_cirq as bc\n",
    "import blqs\n",
    "import cirq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bb97a19-add4-4d5e-93c6-0b825ef48c08",
   "metadata": {},
   "source": [
    "This is an example of how to create a circuit using Cirq.  One sees that one has a base object upon which you append the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1d34cfd2-966f-45f2-822a-d058ae84a8b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───@───\n",
      "          │\n",
      "1: ───H───X───\n"
     ]
    }
   ],
   "source": [
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "circuit = cirq.Circuit()\n",
    "circuit.append(cirq.H(q0))\n",
    "circuit.append([cirq.H(q1), cirq.CX(q0, q1)])\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "056b9b51-327b-4180-a61b-3473aa2da290",
   "metadata": {},
   "source": [
    "Blqs_cirq allows one to do this in a more imperative manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "31827194-bcd3-48d9-b9b8-3d5bfe735f0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───@───\n",
      "          │\n",
      "1: ───H───X───\n"
     ]
    }
   ],
   "source": [
    "from blqs_cirq import H, CX\n",
    "\n",
    "\n",
    "@bc.build\n",
    "def my_circuit():\n",
    "    H(0)\n",
    "    H(1)\n",
    "    CX(0, 1)\n",
    "\n",
    "\n",
    "circuit = my_circuit()\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e6ac8d8-6167-4c32-9d88-95eb9aaee9e0",
   "metadata": {},
   "source": [
    "The object we produce is a `cirq.Circuit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2e880ccf-46bf-4b34-a63c-d3a3cef64644",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cirq.circuits.circuit.Circuit"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2320f3d1-a5d7-416c-ae09-ee8ba1826279",
   "metadata": {},
   "source": [
    "Notice that we have used the decorator `bc.build` on the method. This turns the method into a builder of `cirq.Circuit`s. \n",
    "\n",
    "Second notice that we have used the `blqs_cirq` version of the cirq gates (every gate in cirq exists in blqs_cirq) as the statements in our method.\n",
    "\n",
    "Finally notice that we have used integers instead of `cirq.LineQubit`s. Blqs_cirq automatically converts `int`s to `cirq.LineQubit`s with the int as the coordinate."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f74e3e4-1e86-49d1-9ea8-2d99a9450da2",
   "metadata": {},
   "source": [
    "Blqs_cirq makes it easier to write imperative cirq circuits. As cirq adds control statement, it will also make it easier to write these in native python.  An example of that which exists today is for Cirq's `CircuitOperation`.  A `CircuitOperation` in cirq is an operation on qubits that represents a subcircuit. In particular it is a subcircuit that can be repeated.\n",
    "\n",
    "In cirq you might do something like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4b68e65f-6e97-4de1-b3ac-0d988e35b35a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          Circuit_0x4a76efd01f755f9a:\n",
      "0: ───H───[ 0: ───H───@───          ]─────────────\n",
      "          [           │             ]\n",
      "          [ 1: ───────X───          ](loops=10)\n",
      "          │\n",
      "1: ───────#2──────────────────────────────────────\n"
     ]
    }
   ],
   "source": [
    "sub_circuit = cirq.Circuit()\n",
    "sub_circuit.append(cirq.H(q0))\n",
    "sub_circuit.append(cirq.CX(q0, q1))\n",
    "\n",
    "circuit = cirq.Circuit()\n",
    "circuit.append(cirq.H(q0))\n",
    "circuit.append(cirq.CircuitOperation(sub_circuit.freeze(), repetitions=10))\n",
    "\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d4a8ab3-c7cb-4213-8891-74b258883d8e",
   "metadata": {},
   "source": [
    "In blqs_cirq we can do the same thing using the `Repeat` context manager."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b968f264-7541-4ddc-b027-5ef7bfbfec94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          Circuit_0x4a76efd01f755f9a:\n",
      "0: ───H───[ 0: ───H───@───          ]─────────────\n",
      "          [           │             ]\n",
      "          [ 1: ───────X───          ](loops=10)\n",
      "          │\n",
      "1: ───────#2──────────────────────────────────────\n"
     ]
    }
   ],
   "source": [
    "@bc.build\n",
    "def my_circuit():\n",
    "    H(0)\n",
    "    with bc.Repeat(repetitions=10):\n",
    "        H(0)\n",
    "        CX(0, 1)\n",
    "\n",
    "\n",
    "circuit = my_circuit()\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae928bd-50bc-495a-b2f6-6a64d08ca51a",
   "metadata": {},
   "source": [
    "As more control flow is added to Cirq, eventually these will end up in blqs_cirq as python native constructs.\n",
    "\n",
    "Finally we can also build explicit `Moment` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b2fea84b-92a8-413a-a987-697602f00b23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───────\n",
      "\n",
      "1: ───────H───\n"
     ]
    }
   ],
   "source": [
    "@bc.build\n",
    "def my_circuit():\n",
    "    with bc.Moment():\n",
    "        H(0)\n",
    "    with bc.Moment():\n",
    "        H(1)\n",
    "\n",
    "\n",
    "circuit = my_circuit()\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa3d216-7c2a-40a4-940f-d10dfe78c98e",
   "metadata": {},
   "source": [
    "To learn more, see the [introduction to blqs_cirq](docs/intro.md)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}