PlotQCircuit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simplified Plotting Routines for Quantum Circuits\n",
    "Rick Muller\n",
    "\n",
    "This program takes some of the circuit tricks that Brian Granger, Aaron Meurer and Ondrej Certik first developed in Sympy and [I subsequently updated](http://nbviewer.jupyter.org/gist/rpmuller/5843312).\n",
    "\n",
    "I pulled out all of the code into a set of standalone python functions because I wanted to:\n",
    "* have fewer dependencies for people to install;\n",
    "* make a simpler code base to experiment with;\n",
    "* separate the quantum circuit from the plotter from the simulator;\n",
    "* experiment with scheduling quantum operations rather than plotting one gate in each time step.\n",
    "\n",
    "There are lots of other tools you can do for circuit plotting.\n",
    "* [Qasm2circ](https://www.media.mit.edu/quanta/qasm2circ/)\n",
    "* [Q-circuit](http://physics.unm.edu/CQuIC/Qcircuit/)\n",
    "* The aforementioned [Sympy circuit plotter](http://nbviewer.jupyter.org/gist/rpmuller/5843312)\n",
    "and probably many more that I haven't used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_quantum_circuit(gates,inits={},labels=[],plot_labels=True,**kwargs):\n",
    "    \"\"\"Use Matplotlib to plot a quantum circuit.\n",
    "    gates     List of tuples for each gate in the quantum circuit.\n",
    "              (name,target,control1,control2...). Targets and controls initially\n",
    "              defined in terms of labels. \n",
    "    inits     Initialization list of gates, optional\n",
    "    \n",
    "    kwargs    Can override plot_parameters\n",
    "    \"\"\"\n",
    "    plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, \n",
    "                         control_radius = 0.05, not_radius = 0.15, \n",
    "                         swap_delta = 0.08, label_buffer = 0.0)\n",
    "    plot_params.update(kwargs)\n",
    "    scale = plot_params['scale']\n",
    "    \n",
    "    # Create labels from gates. This will become slow if there are a lot \n",
    "    #  of gates, in which case move to an ordered dictionary\n",
    "    if not labels:\n",
    "        labels = []\n",
    "        for i,gate in enumerate_gates(gates):\n",
    "            for label in gate[1:]:\n",
    "                if label not in labels:\n",
    "                    labels.append(label)\n",
    "    \n",
    "    nq = len(labels)\n",
    "    ng = len(gates)\n",
    "    wire_grid = np.arange(0.0, nq*scale, scale, dtype=float)\n",
    "    gate_grid = np.arange(0.0, ng*scale, scale, dtype=float)\n",
    "    \n",
    "    fig,ax = setup_figure(nq,ng,gate_grid,wire_grid,plot_params)\n",
    "\n",
    "    measured = measured_wires(gates,labels)\n",
    "    draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured)\n",
    "    \n",
    "    if plot_labels: \n",
    "        draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params)\n",
    "\n",
    "    draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured)\n",
    "    return ax\n",
    "\n",
    "def enumerate_gates(l,schedule=False):\n",
    "    \"Enumerate the gates in a way that can take l as either a list of gates or a schedule\"\n",
    "    if schedule:\n",
    "        for i,gates in enumerate(l):\n",
    "            for gate in gates:\n",
    "                yield i,gate\n",
    "    else:\n",
    "        for i,gate in enumerate(l):\n",
    "            yield i,gate\n",
    "    return\n",
    "\n",
    "def measured_wires(l,labels,schedule=False):\n",
    "    \"measured[i] = j means wire i is measured at step j\"\n",
    "    measured = {}\n",
    "    for i,gate in enumerate_gates(l,schedule=schedule):\n",
    "        name,target = gate[:2]\n",
    "        j = get_flipped_index(target,labels)\n",
    "        if name.startswith('M'):\n",
    "            measured[j] = i\n",
    "    return measured\n",
    "\n",
    "def draw_gates(ax,l,labels,gate_grid,wire_grid,plot_params,measured={},schedule=False):\n",
    "    for i,gate in enumerate_gates(l,schedule=schedule):\n",
    "        draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params)\n",
    "        if len(gate) > 2: # Controlled\n",
    "            draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured)\n",
    "    return\n",
    "\n",
    "def draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}):\n",
    "    linewidth = plot_params['linewidth']\n",
    "    scale = plot_params['scale']\n",
    "    control_radius = plot_params['control_radius']\n",
    "    \n",
    "    name,target = gate[:2]\n",
    "    target_index = get_flipped_index(target,labels)\n",
    "    controls = gate[2:]\n",
    "    control_indices = get_flipped_indices(controls,labels)\n",
    "    gate_indices = control_indices + [target_index]\n",
    "    min_wire = min(gate_indices)\n",
    "    max_wire = max(gate_indices)\n",
    "    line(ax,gate_grid[i],gate_grid[i],wire_grid[min_wire],wire_grid[max_wire],plot_params)\n",
    "    ismeasured = False\n",
    "    for index in control_indices:\n",
    "        if measured.get(index,1000) < i: \n",
    "            ismeasured = True\n",
    "    if ismeasured:\n",
    "        dy = 0.04 # TODO: put in plot_params\n",
    "        line(ax,gate_grid[i]+dy,gate_grid[i]+dy,wire_grid[min_wire],wire_grid[max_wire],plot_params)\n",
    "        \n",
    "    for ci in control_indices:\n",
    "        x = gate_grid[i]\n",
    "        y = wire_grid[ci]\n",
    "        if name in ['SWAP']:\n",
    "            swapx(ax,x,y,plot_params)\n",
    "        else:\n",
    "            cdot(ax,x,y,plot_params)\n",
    "    return\n",
    "\n",
    "def draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params):\n",
    "    target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CZ='Z')\n",
    "    name,target = gate[:2]\n",
    "    symbol = target_symbols.get(name,name) # override name with target_symbols\n",
    "    x = gate_grid[i]\n",
    "    target_index = get_flipped_index(target,labels)\n",
    "    y = wire_grid[target_index]\n",
    "    if not symbol: return\n",
    "    if name in ['CNOT','TOFFOLI']:\n",
    "        oplus(ax,x,y,plot_params)\n",
    "    elif name in ['CPHASE']:\n",
    "        cdot(ax,x,y,plot_params)\n",
    "    elif name in ['SWAP']:\n",
    "        swapx(ax,x,y,plot_params)\n",
    "    else:\n",
    "        text(ax,x,y,symbol,plot_params,box=True)\n",
    "    return\n",
    "\n",
    "def line(ax,x1,x2,y1,y2,plot_params):\n",
    "    Line2D = matplotlib.lines.Line2D\n",
    "    line = Line2D((x1,x2), (y1,y2),\n",
    "        color='k',lw=plot_params['linewidth'])\n",
    "    ax.add_line(line)\n",
    "\n",
    "def text(ax,x,y,textstr,plot_params,box=False):\n",
    "    linewidth = plot_params['linewidth']\n",
    "    fontsize = plot_params['fontsize']\n",
    "    if box:\n",
    "        bbox = dict(ec='k',fc='w',fill=True,lw=linewidth)\n",
    "    else:\n",
    "        bbox= dict(fill=False,lw=0)\n",
    "    ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize)\n",
    "    return\n",
    "\n",
    "def oplus(ax,x,y,plot_params):\n",
    "    Line2D = matplotlib.lines.Line2D\n",
    "    Circle = matplotlib.patches.Circle\n",
    "    not_radius = plot_params['not_radius']\n",
    "    linewidth = plot_params['linewidth']\n",
    "    c = Circle((x, y),not_radius,ec='k',\n",
    "               fc='w',fill=False,lw=linewidth)\n",
    "    ax.add_patch(c)\n",
    "    line(ax,x,x,y-not_radius,y+not_radius,plot_params)\n",
    "    return\n",
    "\n",
    "def cdot(ax,x,y,plot_params):\n",
    "    Circle = matplotlib.patches.Circle\n",
    "    control_radius = plot_params['control_radius']\n",
    "    scale = plot_params['scale']\n",
    "    linewidth = plot_params['linewidth']\n",
    "    c = Circle((x, y),control_radius*scale,\n",
    "        ec='k',fc='k',fill=True,lw=linewidth)\n",
    "    ax.add_patch(c)\n",
    "    return\n",
    "\n",
    "def swapx(ax,x,y,plot_params):\n",
    "    d = plot_params['swap_delta']\n",
    "    linewidth = plot_params['linewidth']\n",
    "    line(ax,x-d,x+d,y-d,y+d,plot_params)\n",
    "    line(ax,x-d,x+d,y+d,y-d,plot_params)\n",
    "    return\n",
    "\n",
    "def setup_figure(nq,ng,gate_grid,wire_grid,plot_params):\n",
    "    scale = plot_params['scale']\n",
    "    fig = matplotlib.pyplot.figure(\n",
    "        figsize=(ng*scale, nq*scale),\n",
    "        facecolor='w',\n",
    "        edgecolor='w'\n",
    "    )\n",
    "    ax = fig.add_subplot(1, 1, 1,frameon=True)\n",
    "    ax.set_axis_off()\n",
    "    offset = 0.5*scale\n",
    "    ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset)\n",
    "    ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset)\n",
    "    ax.set_aspect('equal')\n",
    "    return fig,ax\n",
    "\n",
    "def draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured={}):\n",
    "    scale = plot_params['scale']\n",
    "    linewidth = plot_params['linewidth']\n",
    "    xdata = (gate_grid[0] - scale, gate_grid[-1] + scale)\n",
    "    for i in range(nq):\n",
    "        line(ax,gate_grid[0]-scale,gate_grid[-1]+scale,wire_grid[i],wire_grid[i],plot_params)\n",
    "        \n",
    "    # Add the doubling for measured wires:\n",
    "    dy=0.04 # TODO: add to plot_params\n",
    "    for i in measured:\n",
    "        j = measured[i]\n",
    "        line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params)\n",
    "    return\n",
    "\n",
    "def draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params):\n",
    "    scale = plot_params['scale']\n",
    "    label_buffer = plot_params['label_buffer']\n",
    "    fontsize = plot_params['fontsize']\n",
    "    nq = len(labels)\n",
    "    xdata = (gate_grid[0] - scale, gate_grid[-1] + scale)\n",
    "    for i in range(nq):\n",
    "        j = get_flipped_index(labels[i],labels)\n",
    "        text(ax,xdata[0]-label_buffer,wire_grid[j],render_label(labels[i],inits),plot_params)\n",
    "    return\n",
    "\n",
    "def get_flipped_index(target,labels):\n",
    "    \"\"\"Get qubit labels from the rest of the line,and return indices\n",
    "\n",
    "    >>> get_flipped_index('q0', ['q0', 'q1'])\n",
    "    1\n",
    "    >>> get_flipped_index('q1', ['q0', 'q1'])\n",
    "    0\n",
    "    \"\"\"\n",
    "    nq = len(labels)\n",
    "    i = labels.index(target)\n",
    "    return nq-i-1\n",
    "\n",
    "def get_flipped_indices(targets,labels): return [get_flipped_index(t,labels) for t in targets]\n",
    "\n",
    "def render_label(label, inits={}):\n",
    "    \"\"\"Slightly more flexible way to render labels.\n",
    "\n",
    "    >>> render_label('q0')\n",
    "    '$|q0\\\\\\\\rangle$'\n",
    "    >>> render_label('q0', {'q0':'0'})\n",
    "    '$|0\\\\\\\\rangle$'\n",
    "    \"\"\"\n",
    "    if label in inits:\n",
    "        s = inits[label]\n",
    "        if s is None:\n",
    "            return ''\n",
    "        else:\n",
    "            return r'$|%s\\rangle$' % inits[label]\n",
    "    return r'$|%s\\rangle$' % label\n",
    "\n",
    "# Define symbols to simplify writing\n",
    "H,X,Y,Z,S,T,M = 'HXYZSTM'\n",
    "CNOT,CPHASE,CZ,CX,TOFFOLI,SWAP,NOP = 'CNOT','CPHASE','CZ','CX','TOFFOLI','SWAP','NOP'\n",
    "qa,qb,qc,qd,q0,q1,q2,q3 = 'q_a','q_b','q_c','q_d','q_0','q_1','q_2','q_3'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11cd5cdd0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG0AAABECAYAAACLW7uoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAADqUlEQVR4nO3aP0jrUBiH4V/stdZ0cRCHCiZYJ61WkA4uJYuWglBdRVHUycnBwc3VVUEpQqEu6qZnEhRRBAWhCq2lg+J/wVUQHBQ8d7qBXG81KbHlu34PdGianBzymrRNVaSUEoyUqkpPgDnH0QjiaARxNII4GkEcjSCORhBHI4ijEcTRCOJoBHE0gjgaQRyNII5GEEcjiKMRxNEI4mgEcTSCOBpBHI0gjgZA13UoiuLKQ9f1b5+vwv/3CCiKArcOg5tjFcNnGkEcjSBb0fb39129VqfTaRQKBdfG+2kqcqZlMhksLS1VYteOjI6Ooq+v78PyTCYDRVFwc3NT/kmhQtESiQSEEJXY9X+h5Gjn5+fo6emBz+dDMBjE1tYWampqsLu7++W2hmHg+fkZJycnpe7+Rysp2sXFBSKRCNra2pDP57GwsICJiQm8vr4iHA5/uX11dTXi8Tg2NzdL2T2TNuzt7UlN08znvb29cmhoyLLO2NiYbGxstDOclFLKtbU1GQqFbK//nYodhpGREenxeKTf77c8amtrJQB5fX1teyw3/XIa+f7+Htvb2x8ubV6v19ZZ9kc8Hsfg4CDu7u7Q1NTkdBplE41Gsby8bFmWz+cxMDBQoRkBjqOdnp7C4/EgFApZludyORiGYT5fXV3F/Pw8Xl5eEAgEsLGxAVVVzddvb2+hqioaGhpKnryiKCVva5eqqmhpabEse3p6+nQbN+YlP7mr4vg9raqqCu/v73h7ezOXHR4e4ujoCJ2dneayWCyG4+NjnJ2dIRgMYmdnxzKOEAKxWAw+n8/pFExSSlcebvvuOTmO1tXVBa/Xi5mZGVxdXUEIgfHxcQCwXB5TqRQikQjC4TDW19c/xBFCIJFION09QwnRAoEAUqkUhBDo6OhAOp3G5OQk/H6/eRlZWVlBoVDAwcEBstks6uvr0draao7x8PCAbDb7zy+uzAY7n1b+/vT4t9nZWdnd3W0+n56elslkUkopZTKZlHV1dZb1FxcXpWEYdnZdFjYPQ9nHKsaVOyK5XM5yaRweHsbc3Byi0SgeHx/R3t5uWV8Igf7+fjd2/TPZKfvVmdbc3GyeWRTZPAxlH6sYWx/5dV3H1NRU0dcvLy9d+hNidvAv1+BfrlkZcDSCHN/G+h9pmubaLTFN01wZ5zP8nkYQXx4J4mgEcTSCOBpBHI0gjkYQRyOIoxHE0QjiaARxNII4GkEcjSCORhBHI4ijEcTRCOJoBHE0gjgaQRyNoN8Vo/vOE7Z8DgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,qa)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d486110>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 324x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,q0),(CPHASE,q1,q0),(SWAP,q1,q0)],labels=[q0,q1],scale=1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Examples from [qasm2circ page](http://www.media.mit.edu/quanta/qasm2circ)\n",
    "## Example 1: EPR Creation\n",
    "\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test1.png\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d4d0d10>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKMAAAB7CAYAAAAYATDCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAJZElEQVR4nO3dWUhU/R/H8c+4O0O2WeQSyuOUuGBBCUoRY5tp5RhtF0lFmpUEJYkIRRHhRXRRBEoEkdhFN4GeKLOgsguVzCXFutDcxiW6KCzLosn5/S8envk3uc2Zzji/8vOCuZjlnN/X6d1xthqdEEKASAJenh6A6D+MkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEkajJGkwRgBREZGQqfTaXKKjIz09I/zx9Lx300DOp0OWt0NWu5rtuGRkaTBGEkaTsVYU1Oj6WOhsrIyvH79WrP90d/BI0fGxsZGlJaWemJpVQ4ePIht27aNu7yxsRE6nQ69vb0zP9RfzCMxms1mKIriiaVJYi7H2NHRgU2bNiEgIABRUVF48OAB/P398fjx42m3NZlMGBkZQVNTk6vL01/IpRg7OzuRmJiIuLg4tLe34+rVq8jJycH379+xYsWKabf39fVFWloaKisrXVmeNDA2NoYLFy5g0aJFMBgM2LNnD969e+fZoYQTnj59KiIiIuznN2/eLLKyshxuc+jQIREWFmY/f//+fbF8+XJhNBpFSUnJuH3evn1bxMfHO7O82012Nxw4cEB4e3sLg8HgcAoMDBQARE9Pj9P7kk1BQYHQ6/UCgAAgfHx8xLJly8TY2JjHZlIdo8ViEQBEU1OTw22OHj0q0tPThRBCWK1WYTQahcViEV++fBExMTFiaGjI4fbDw8NCp9OJvr4+DX6M3zNVjCkpKaKzs9PhVFFR8UfHaLVa7X+hfj7NmTNHPHnyxGNz+ag9kjY3N8Pb2xvx8fEOl7e1tcFkMgEAGhoaEBsbi6VLlwIAduzYgXv37uHw4cP22/f19UGv12Px4sVqR3Cg0+l+a/vp6PV6GI1Gh8uGh4en3MbdM7nLyMgI1q9f79Y1xBTvTql+zOjl5QWbzQar1Wq/rLa2FnV1dVi5ciUAYGhoyB4iAISHh2NwcNBhP4qiIDU1FQEBAWpHcCD+Pbr/1klrWszk7lNMTMy4uf39/TE4OOjWdaeiOsZVq1bBz88PRUVF6O7uhqIoyM7OBgD7k5eJFv31aKEoCsxms9rlSSPl5eUICgqCwWAAAAQGBqK4uBihoaEem0l1jKGhobhx4wYURUFCQgLKysqQl5cHg8Fg/3UWFhaG/v5++zYDAwMOP+TAwABaW1snfEGZZsbq1avR29uLK1euAABaWlpw6tQpzw7lzAPLX59N/+rcuXMiOTnZft5qtYqoqChhsVjE6OioiImJEYODg/brS0pKhMlkcmbpGeHk3TDj+5opssys+gnMRNra2hxeX/Tx8cHly5exYcMG2Gw2nDhxwuHIqCgKMjMztVia/iKaxNja2orCwkKHy7Zv347t27dPePuHDx9qsSz9ZZyKMTIyEidPnpz0+q6uLs0GotmLn/QGP+kty8z8cC1JgzGSNDR5AvOni4iI0OwtvIiICE32MxvxMSPxMSPRrxgjSYMxkjQYI0mDMZI0GCNJgzGSNBgjSYMxkjQYI0mDMZI0GCNJgzGSNBgjSYMxkjQYI0mDMZI0GCNJgzGSNBgjSYMxkjQYI0mDMZI0GCNJgzGSNBgjSYMxkjQYI0mDMZI0GCNJgzGSNBgjSYMxznI2m83TI9gxxlmoq6sLhYWFCAsLg5+fHwAgKCgIe/fuxbNnzzz2v9gyxlnk/fv3yMzMRFJSEoQQePLkCb59+wbg30DXrVuHY8eOIT4+Hs+fP5/5AZ35TrfpvjtQrZs3b4pXr15ptj+a3tDQkIiOjhYFBQVidHTU4bqfM7DZbOLOnTsiODhYVFdXz+iMHjkyNjY2orS01BNLz0qjo6PYunUr9u3bh0uXLiEwMHDS2+p0OuzcuROVlZXIysrCy5cvZ2xOj8RoNpuhKIonlp6Vbt26hZCQEJw5c8bpbdasWYPz58/j7NmzbpzMkcsxdnR0YNOmTQgICEBUVBQePHgAf39/PH78eNptTSYTRkZG0NTU5Ory5CQhBEpLS5Gfn6/6u24OHjyI2tpa9Pb2ume4X7gUY2dnJxITExEXF4f29nZcvXoVOTk5+P79u8NX/U7G19cXaWlpqKysdGV5UqG+vh7fvn3D+vXrVW+r1+uxf/9+XL9+3Q2TjedSjMePH0dGRgauXLkCo9GIrVu3YsuWLQgLC0NwcDAAICMjA/Pnz8euXbsm3IfZbGaMM6ChoQGbN2+Gl5drvwS3bNmCFy9eaDzVxFRP2N/fj0ePHiE/P9/hcj8/P4ejYn5+PsrLyyfdT1paGl69egWLxaJ2BFLh06dPmDt3rsvbz507Fx8/ftRwosmp/u7A5uZmeHt7Iz4+3uHytrY2mEwm+/mUlBTU1NRMup++vj7o9XosXrxY7QgOtPrOv79dcXHxlNdPdz9qdT+LKV5QV31k9PLygs1mg9VqtV9WW1uLuro6rFy50un9KIqC1NRUBAQEqB3BgRCCpylOlZWVWLdu3ZS3mep+vHjxInJycjSbZyqqY1y1ahX8/PxQVFSE7u5uKIqC7OxsAHDqyct/FEWB2WxWuzyplJ6ejjdv3qC9vV31tmNjY7h27Rpyc3PdMNl4qmMMDQ3FjRs3oCgKEhISUFZWhry8PBgMBhiNRqf2MTAwgNbWVmzbtk31wKSOr68vDh8+7NKbDNXV1Vi4cCESExPdMNl4Lj3F2rdvHywWCz5//oyKigp8+PABCQkJTj9ju3v3LtauXYsFCxa4sjypdOTIEVRUVKCqqsrpbYaGhpCXl4fTp0+7cTJHmrwD09bWNu5X9MaNG7F7925UVVUhPDwc9fX19usURUFmZqYWS5MTQkJCUFFRgQMHDjj1clp3dzdSUlJw7Nixmf1zmvRd659M90GJf/75R1y7ds2ZXZEHNTY2ivDwcJGamioURRE/fvwQQvz/gxItLS0iNzdXzJs3T5SUlMz4fE7F2NPTIy5fvuzuWWgGfP36VZSXl4ukpCSxZMkSkZycLACI6OhoER4eLi5cuCDevn3rkdl0Qnjok5Tkcd3d3Xj79i3Wrl2L1tZWxMbGwsdH9UvPmmGMJA1+0pukwRhJGoyRpMEYSRqMkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEkajJGkwRhJGoyRpMEYSRqMkaTBGEka/wMrNJXRWTE3ogAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,q0),(CNOT,q1,q0)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can also play with labeling, either turning them off, or selectively showing initializations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d52f7d0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHsAAAB7CAYAAABUx/9/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAEzElEQVR4nO3dyyt8fxzH8dcRqZOiRs0s3BpK2bgspMjCZqZcdhYKkShTNjZSVlP8AcqtpJRmx0KIlFLKwiXZTMgl0WShTDKmmPP5Lb6lH4bvlzlzzvfr/XrU2czMmfM2T2eOmdEcTSmlQCKk2D0AWYexBWFsQRhbEMYWhLEFYWxBGFsQxhaEsQVhbEEYWxDGFoSxBWFsQRhbEMYWhLEFYWxBGFsQxhaEsQWxJHZBQQE0TTNlKSgosGLkH0mz4v/GNU2DWZsx876k4dO4IIwtCGMLYmvsjo4ONDQ0vLt8d3cXmqbh4uLC+qF+MO7ZgjC2IIydJGdnZ/B6vdB1HTk5ORgbG7P9JWOqrVsHsLq6ioyMjFeXGYZh0zTmeHh4QFVVFW5vb2EYBq6vrzEwMABN0+Dz+Wyby/Y9u7a2FgcHB6+WQCBg91gJmZ+fx+Pj46tf2oeHB4yMjNg41W/2bE3Tkj6ArusoKip6ddnd3d2n61gxVzJcX18nffbPDhWf7tlKKVOWZPxAf/Oyt7cHXddfP9ApKfB4PEnf9mdsfxr/iSoqKtDV1QVd15GWlgYAcDgcGB8ft3Uuxk6S0dFRbG1tYXh4GABwfn4Ot9tt60z81MsCf8vM3LMFYWxBGFsQxhaEsQVhbEEs+SAkPz/ftLcJ8/PzTbkfiSx5nS0dX2eT5RhbEMYWhLEFYWxBGFsQxhaEsQVhbEEYWxDGFoSxBWFsQRhbEMYWhLEFYWxBGFsQxhaEsQVhbEEYWxDGFoSxBWFsQRhbEMYWhLEFYWxBGFsQxhaEsQVh7CR7fn62e4QXjG2yWCyGpaUl1NfXIyMjA+np6QAAt9sNv9+PUChk22yMbaKVlRUUFhbC7/ejubkZV1dXL3v2wsICQqEQSkpK0NnZiUgkYv2AikwxOzurXC6X2tjYeHfd/x/mcDisWltbVVVVlQqHw1aOqBjbBOvr68rpdKpgMBj3+rf7lGEYqqenR3k8HhWLxawY8dcclm3phzIMQ5WWlqrFxcUPbxPvCfTp6UmVlZWp5eXlZI73Co/ZCdre3kYkEkF9ff2X1ktNTUVfX5+lXzjP70FLUFtbG8rLy9Hf3//hbT76HrRIJIK8vDzs7u5acqpo7tkJ2tnZgdfr/da6uq6jpqYG+/v7Jk8VH2MnKBwOIzMz89vrZ2VlIRwOmzjRxz59Gv9XT6kk2WdHZUtO9fSTF4/Hg0Ag8NvTL8W7PBaLwe12Y29vj6d6+hd0d3djYmLiW+uura0hKysL5eXlJk8VH2MnqKmpCaenpzg8PPzyumNjY/D5fJYdLhk7QWlpaRgcHER7ezvu7+//eL3p6WkEg0G0tLQkcbo34r7VQl9iGIbq7e1VlZWV6ubm5t31bx/myclJ5XK51NHRkVUj/prD0q39YIZhqKGhIeVwOFR/f786Pj5+uQ6Aikajam5uTlVXV6vi4mJ1cnJi+Yx8B81k5+fnmJqawszMDJxOJxwOBzY3N5GdnY2ysjL4fD40NjYiNdX6U5czdpJEo1EEg0Hc3d2hrq4Ol5eXyM3NtXUmxhaEf40LwtiCMLYgjC0IYwvC2IIwtiCMLQhjC8LYgjC2IIwtCGMLwtiCMLYgjC0IYwvC2IIwtiCMLQhjC8LYgjC2IIwtyH+HC43n3z1IZwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,q0),(CNOT,q1,q0)],plot_labels=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d56dd50>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,q0),(CNOT,q1,q0)],{q0:0,q1:None})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Teleportation Gate\n",
    "\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test2.png\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d665890>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,q1),(CNOT,q2,q1),(CNOT,q1,q0),(H,q0),\n",
    "                      (M,q0),(M,q1),(CX,q2,q1),(CZ,q2,q0)],\n",
    "                     labels=[q0,q1,q2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Swap Gate\n",
    "\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test3.png\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d71f850>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(CNOT,q1,q0),(CNOT,q0,q1),(CNOT,q1,q0)],labels=[q0,q1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: QFT on 3 Qubits\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test4.png\" width=\"300\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d75ce10>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,'j_0'),(S,'j_0','j_1'),(T,'j_0','j_2'),(H,'j_1'),\n",
    "                     (S,'j_1','j_2'),(H,'j_2'),(SWAP,'j_0','j_2')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test6.png\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d855910>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(TOFFOLI,'j_2','j_0','j_1'),(X,'j_0'),('U','j_1','j_0','j_2','j_3'),\n",
    "                     (H,'j_2'),(M,'j_3')],\n",
    "                     labels=['j_0','j_1','j_2','j_3'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 7\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test7.png\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d6e98d0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,'q0'),('U','q1','q0'),(H,'q0'),(M,'q0'),('V','q1','q0')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 8\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test8.png\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d9cdf90>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit([(H,'b'),(CNOT,'b','a'),(CNOT,'c','b'),(CNOT,'b','a'),\n",
    "                     (CNOT,'c','b'),(H,'a'),(Z,'a','c'),(H,'a'),(H,'a')],\n",
    "                     labels='abc',inits=dict(a='\\psi',b='0',c='0'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 9\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test9.png\" width=\"300\" />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d855fd0>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rt = r'$\\sqrt{X}$'\n",
    "rtd = r'$\\sqrt{X^\\dagger}$'\n",
    "plot_quantum_circuit([(rt,q2,q1),(CNOT,q1,q0),(rtd,q2,q1),(CNOT,q1,q0),(rt,q2,q0)],\n",
    "    labels=[q0,q1,q2]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 13\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test13.png\" width=\"300\" />\n",
    "Can't do multitarget gates yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11dce42d0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "j0,j1,j2,s1,s2 = 'j_0','j_1','j_2','s_1','s_2'\n",
    "plot_quantum_circuit([(H,j0),(H,j1),(H,j2),(r'$U^4$',s1,j0),(r'$U^4$',s2,j0),\n",
    "                      (r'$U^2$',s1,j1),(r'$U^2$',s2,j1),(r'$U$',s1,j2),(r'$U$',s2,j2),\n",
    "                      (H,j0),(S,j1,j0),(H,j1),(T,j2,j0),(S,j2,j1),(H,j2),\n",
    "                      (M,j0),(M,j1),(M,j2)],\n",
    "    labels=(j0,j1,j2,s1,s2),inits={j0:0,j1:0,j2:0})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experimenting with plotting scheduled gates:\n",
    "The above scheme, like what's in Scipy, prints one gate per time step. What if we define a *schedule* as a sequence of steps, each of which can have multple gates. At some point we could write a *scheduler* that would take a sequence of gates and compress it as much as possible. In the meantime, we could manually schedule gates.\n",
    "\n",
    "We don't have to rewrite very much of the code to do this. We just define a custom enumerator *enumerate_gates* that can work with either a schedule or a gate list, and everything works as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_quantum_schedule(schedule,inits={},labels=[],plot_labels=True,**kwargs):\n",
    "    \"\"\"Use Matplotlib to plot a quantum circuit.\n",
    "    schedule  List of time steps, each containing a sequence of gates during that step.\n",
    "              Each gate is a tuple containing (name,target,control1,control2...). \n",
    "              Targets and controls initially defined in terms of labels. \n",
    "    inits     Initialization list of gates, optional\n",
    "    \n",
    "    kwargs    Can override plot_parameters\n",
    "    \"\"\"\n",
    "    plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, \n",
    "                         control_radius = 0.05, not_radius = 0.15, \n",
    "                         swap_delta = 0.08, label_buffer = 0.0)\n",
    "    plot_params.update(kwargs)\n",
    "    scale = plot_params['scale']\n",
    "    \n",
    "    # Create labels from gates. This will become slow if there are a lot \n",
    "    #  of gates, in which case move to an ordered dictionary\n",
    "    if not labels:\n",
    "        labels = []\n",
    "        for i,gate in enumerate_gates(schedule,schedule=True):\n",
    "            for label in gate[1:]:\n",
    "                if label not in labels:\n",
    "                    labels.append(label)\n",
    "    \n",
    "    nq = len(labels)\n",
    "    nt = len(schedule)\n",
    "    wire_grid = np.arange(0.0, nq*scale, scale, dtype=float)\n",
    "    gate_grid = np.arange(0.0, nt*scale, scale, dtype=float)\n",
    "    \n",
    "    fig,ax = setup_figure(nq,nt,gate_grid,wire_grid,plot_params)\n",
    "\n",
    "    measured = measured_wires(schedule,labels,schedule=True)\n",
    "    draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured)\n",
    "    \n",
    "    if plot_labels: \n",
    "        draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params)\n",
    "\n",
    "    draw_gates(ax,schedule,labels,gate_grid,wire_grid,plot_params,measured,schedule=True)\n",
    "    return ax\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11dc377d0>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAG0AAABECAYAAACLW7uoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAADxklEQVR4nO2av0v7ThjH37G11nYUBFs1wRZBLSqog4sERKUg1K4iKP5YXOro5p8gCBURhG6uBhRB8Meig1TBUhwUf7XWWRAcrPS+wxcCUatpTVuej88LMtw1uefhXneXS1JJCCHAkKKq0gkwhcPSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSCMLSACiKAkmSLDkURSl5vhL/7xGQJAlWdYOVbeWDZxpBWBpBTEk7OjqydK2OxWK4vLy0rL2/RkVmWjwex+rqaiVCF8TU1BRGR0c/1cfjcUiShPv7+/InhQpJC4VC0DStEqH/CYqWdnV1haGhITidTvh8Puzu7qKmpgb7+/s/XquqKl5eXnB2dlZs+D9NUdKur6/R19eHjo4OJJNJrKysYHZ2Fm9vb+jq6vrx+urqagSDQWxtbRUTnhEmODw8FLIs6+Xh4WExMTFhOGd6elp4vV69vLOzI1pbW4Xf7xfRaPRTm5ubmyIQCJgJX3LydcPk5KSw2WzC7XYbjtraWgFA3N3dmW7LSuyFSk6n09jb2/u0tDkcDn2Wvb+/IxKJ4ODgAHV1dejt7UU4HEZDQ4N+fjAYxPj4OFKpFJqbm38z7krKwMAA1tfXDXXJZBLhcLhCGQEFSzs/P4fNZkMgEDDUJxIJqKoKADg9PUV7ezuampoAAOFwGNvb25ibm9PPf3h4gMvlQn19/S/S//8NRClxuVzw+/2Guufn52+vsSIn8c1blYLvaVVVVcjlcshms3rd8fExTk5O0N3dDQB4enrShQFAY2MjMpmMoR1N0zAyMgKn01loCgaEEL8+rKbUORUsraenBw6HA4uLi7i9vYWmaZiZmQEAfXn8KujH0adpGkKhUKHhGRQhzePxYGNjA5qmobOzE7FYDPPz83C73foy4vV6kU6n9WseHx/h8XgM5YuLiy8fXBkTmNmtfNw9fmRpaUn09/fr5Ww2K3w+n0ilUuL19VW0tbWJTCaj/x6NRoWqqmZClwWT3VD2tvJR8EbkKxKJhOH5zG63Y3l5GYODg8jlcohEIoaZpmkaxsbGrAj9NzFj9qeZ1tLSItbW1qwaSGXHZDeUva18mJppiqJgYWEh7+83NzcWDSHGDPzlGvzlmikDLI0gluweqSPLsmWvw2RZtqSd7+B7GkF4eSQISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyMISyPIf1QK8dSMGB5kAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_schedule([[(H,q0)]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1158fef10>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_schedule([[(H,q0)],[(CNOT,q1,q0)]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now plot something that we can't do with the original code:\n",
    "\n",
    "## Example 13\n",
    "Goal:\n",
    "\n",
    "<img src=\"http://www.media.mit.edu/quanta/qasm2circ/test13.png\" width=\"300\" />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11dffd950>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 475.2x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "j0,j1,j2,s1,s2 = 'j_0','j_1','j_2','\\psi_1','\\psi_2' # labeler puts in the r$$ stuff\n",
    "plot_quantum_schedule([[(H,j0),(H,j1),(H,j2)],[(r'$U^4$',s1,j0),(r'$U^4$',s2,j0)],\n",
    "                      [(r'$U^2$',s1,j1),(r'$U^2$',s2,j1)],[(r'$U$',s1,j2),(r'$U$',s2,j2)],\n",
    "                      [(H,j0)],[(S,j1,j0)],[(H,j1)],[(T,j2,j0)],[(S,j2,j1)],[(H,j2)],\n",
    "                      [(M,j0),(M,j1),(M,j2)]],\n",
    "                      labels=(j0,j1,j2,s1,s2),inits={j0:0,j1:0,j2:0},scale=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_schedule(gates):\n",
    "    schedule = [[]]\n",
    "    current_tic = schedule[-1]\n",
    "    qubits_in_current_tic = set()\n",
    "    for gate in gates:\n",
    "        qubits = set(gate[1:])\n",
    "        if qubits_in_current_tic.intersection(qubits): \n",
    "            # Qubits already in tic, create new tic\n",
    "            current_tic = [gate]\n",
    "            qubits_in_current_tic = qubits\n",
    "            schedule.append(current_tic)\n",
    "        else:\n",
    "            # Add to current tic\n",
    "            current_tic.append(gate)\n",
    "            qubits_in_current_tic = qubits_in_current_tic.union(qubits)\n",
    "    return schedule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "gates = [(H,j0),(H,j1),(H,j2),(r'$U^4$',s1,j0),(r'$U^4$',s2,j0),\n",
    "         (r'$U^2$',s1,j1),(r'$U^2$',s2,j1),(r'$U$',s1,j2),(r'$U$',s2,j2),\n",
    "         (H,j0),(S,j1,j0),(H,j1),(T,j2,j0),(S,j2,j1),(H,j2),\n",
    "         (M,j0),(M,j1),(M,j2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11dde83d0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_circuit(gates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11e36b4d0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_quantum_schedule(make_schedule(gates))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not bad! Several things could be improved. The H|j0> in the QFT could be moved up a step. Would be nice to combine the C-U's a little more intelligently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Multiqubit Boxes\n",
    "Experimenting with rectangle code\n",
    "\n",
    "Todo:\n",
    "* Pass plot_params into rectangle.\n",
    "* Test multiqubit_box\n",
    "* get box to cover wires.\n",
    "* In order to wire these into circuits a little more intelligently, need a good way to put multitarget gates into circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiqubit_box(ax,istep,minq,maxq,labels,gate_grid,wire_grid,plot_params,label=''):\n",
    "    dx = 0.25\n",
    "    dy = 0.25\n",
    "    minwire = get_flipped_index(minq,labels)\n",
    "    maxwire = get_flipped_index(maxq,labels)\n",
    "    \n",
    "    rectangle(ax,gate_grid[istep]-dx,gate_grid[istep]+dx,\n",
    "              wire_grid[minwire]-dy,wire_grid[maxwire]+dy,label=label)\n",
    "    return\n",
    "\n",
    "\n",
    "def rectangle(ax,x1,x2,y1,y2,label=''):\n",
    "    Rectangle = matplotlib.patches.Rectangle\n",
    "    x = min(x1,x2)\n",
    "    y = min(y1,y2)\n",
    "    w = abs(x2-x1)\n",
    "    h = abs(y2-y1)\n",
    "    xm = x+w/2.\n",
    "    ym = y+h/2.\n",
    "    print (x,y,w,h,xm,ym)\n",
    "    rect = Rectangle((x,y),w,h,ec='k',fc='w',fill=True,lw=1,label=label)\n",
    "    ax.add_patch(rect)\n",
    "    if label:\n",
    "        ax.text(xm,ym,label,ha='center',color='k')\n",
    "    return\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.25 -0.25 0.5 1.5 0.0 0.5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, \n",
    "                   control_radius = 0.05, not_radius = 0.15, \n",
    "                   swap_delta = 0.08, label_buffer = 0.0)\n",
    "\n",
    "ax = plot_quantum_circuit([(H,q1),(CNOT,q1,q0)],labels=[q0,q1])\n",
    "#r = matplotlib.patches.Rectangle((-0.25,-0.25),0.5,1.5,ec='k',fc='w',fill=True,lw=1.0)\n",
    "#ax.add_patch(r)\n",
    "#ax.text(0,0.5,\"Hi\",ha=\"center\")\n",
    "\n",
    "#color='k',ha='center',va='center',bbox=bbox,size=fontsize\n",
    "rectangle(ax,-0.25,0.25,-0.25,1.25,'hi')\n",
    "#   ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize)\n",
    " "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}