Samples/PythonInterop/tomography-sample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Process Tomography with Q# and Python #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this sample, we will demonstrate interoperability between Q# and Python by using the QInfer and QuTiP libraries for Python to characterize and verify quantum processes implemented in Q#.\n",
    "In particular, this sample will use *quantum process tomography* to learn about the behavior of a \"noisy\" Hadamard operation from the results of random Pauli measurements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preamble ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with Q# from languages other than C#, we normally need to separate Q# operations and functions into their own project.\n",
    "We can then add the project containing our new operations as a *reference* to our interoperability project in order to run from within Visual Studio.\n",
    "For running from Jupyter, though, we must manually add the other project to `sys.path` so that Python.NET can find the assemblies containing our new operations, as well as the assemblies from the rest of the Quantum Development Kit that get included as dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "\n",
       "    .clr-repr-table td {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    div.output_area pre.simulator-output {\n",
       "        border-left: solid 12px #409AE1;\n",
       "        padding-left: 4px;\n",
       "        margin-left: -4px\n",
       "    }\n",
       "\n",
       "</style>"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qsharp \n",
    "from qsharp.tomography import single_qubit_process_tomography"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import warnings; warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('./bin/Debug/netstandard2.0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the new assemblies added to `sys.path`, we can reference them using the Python.NET `clr` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<System.Reflection.RuntimeAssembly at 0x178e093ccc0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import clr\n",
    "clr.AddReference(\"Microsoft.Quantum.Canon\")\n",
    "clr.AddReference(\"PythonInterop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we import plotting support and the QuTiP library, since these will be helpful to us in manipulating the quantum objects returned by the quantum process tomography functionality that we call later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import qutip as qt\n",
    "qt.settings.colorblind_safe = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up the Simulator ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This sample is provided along with a small Python package to help facilitate interoperability.\n",
    "We can import this package like any other Python package, provided that we have set `sys.path` correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In particular, the `qsharp` package provides a `QuantumSimulator` class which wraps the `Microsoft.Quantum.Simulation.Simulators.QuantumSimulator` .NET class provided with the Quantum Development Kit.\n",
    "This wrapper provides a few useful convienence features that we will use along the way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <strong>Quantum Simulator</strong>\n",
       "        <table class=\"clr-repr-table\">\n",
       "            \n",
       "                <tr>\n",
       "                    <td colspan=\"2\">\n",
       "                        <pre>Microsoft.Quantum.Simulation.Simulators.QuantumSimulator</pre>\n",
       "                    </td>\n",
       "                </tr>\n",
       "            \n",
       "            <tr>\n",
       "                <td>\n",
       "                    Python type\n",
       "                </td>\n",
       "                <td>\n",
       "                    qsharp.QuantumSimulator\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    CLR type\n",
       "                </td>\n",
       "                <td>\n",
       "                    Microsoft.Quantum.Simulation.Simulators.QuantumSimulator\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    Assembly name\n",
       "                </td>\n",
       "\n",
       "                <td>\n",
       "                    Microsoft.Quantum.Simulation.Simulators, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            \n",
       "                <tr>\n",
       "                    <td>\n",
       "                        Methods\n",
       "                    </td>\n",
       "\n",
       "                    <td><pre>UInt32 get_Seed()</pre></td>\n",
       "\n",
       "                    <tr><td></td><td><pre>String get_Name()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void Dispose()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void add_OnLog(Action`1<System.String> value)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void remove_OnLog(Action`1<System.String> value)</pre></td></tr>\n",
       "<tr><td></td><td><pre>IQubitManager get_QubitManager()</pre></td></tr>\n",
       "<tr><td></td><td><pre>I Get()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void Validate(AbstractOperation<> op)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Task`1 Run(I<> args)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void CheckQubit(Qubit<> q, String<> qubitName)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void CheckQubits(QArray`1<Microsoft.Quantum.Simulation.Core.Qubit> qubits, String<> arrayName)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void StartOperation(String<> operationName, OperationFunctor<> functor, Object<> inputValue)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void EndOperation(String<> operationName, OperationFunctor<> functor, Object<> resultValue)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Void Register(Type<> original, Type<> replace, Type<> signature)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Object GetInstance(Type<> t)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Boolean CanCache(AbstractOperation<> obj)</pre></td></tr>\n",
       "<tr><td></td><td><pre>String ToString()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Boolean Equals(Object<> obj)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Int32 GetHashCode()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Type GetType()</pre></td></tr>\n",
       "                </tr>\n",
       "            \n",
       "        </table>\n",
       "        "
      ],
      "text/plain": [
       "<QuantumSimulator(Microsoft.Quantum.Simulation.Simulators.QuantumSimulator) at 0x178e0986e80>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qsim = qsharp.QuantumSimulator()\n",
    "qsim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use our new simulator instance to run operations and functions defined in Q#.\n",
    "To do so, we import the operation and function names as though the Q# namespaces were Python packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from Microsoft.Quantum.Samples.Python import (\n",
    "    HelloWorld, NoisyHadamardChannel\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we've imported the new names, we can then ask our simulator to run each function and operation using the `run` method.\n",
    "Jupyter will denote messages emitted by the simulator with a blue sidebar to separate them from normal Python output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <strong>Microsoft.Quantum.Samples.Python.HelloWorld</strong>\n",
       "        <table class=\"clr-repr-table\">\n",
       "            \n",
       "            <tr>\n",
       "                <td>\n",
       "                    Python type\n",
       "                </td>\n",
       "                <td>\n",
       "                    qsharp.Callable\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    CLR type\n",
       "                </td>\n",
       "                <td>\n",
       "                    Microsoft.Quantum.Samples.Python.HelloWorld\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    Assembly name\n",
       "                </td>\n",
       "\n",
       "                <td>\n",
       "                    PythonInterop, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            \n",
       "        </table>\n",
       "        "
      ],
      "text/plain": [
       "<Callable(Microsoft.Quantum.Samples.Python.HelloWorld) at 0x178e09ca588>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_world = qsim.get(HelloWorld)\n",
    "hello_world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<pre class=\"simulator-output\">Hello, world! PauliZ</pre>\n"
      ],
      "text/plain": [
       "'Hello, world! PauliZ'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qsim.run(hello_world, qsharp.Pauli.Z).Wait()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain the output from a Q# operation or function, we must use the `result` function, since outputs are wrapped in .NET asynchronous tasks.\n",
    "These tasks are wrapped in a future-like object for convienence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <strong>Wrapped CLR Object</strong>\n",
       "        <table class=\"clr-repr-table\">\n",
       "            \n",
       "                <tr>\n",
       "                    <td colspan=\"2\">\n",
       "                        <pre>Microsoft.Quantum.Samples.Python.NoisyHadamardChannelImpl((0.1,_))</pre>\n",
       "                    </td>\n",
       "                </tr>\n",
       "            \n",
       "            <tr>\n",
       "                <td>\n",
       "                    Python type\n",
       "                </td>\n",
       "                <td>\n",
       "                    qsharp.clr_wrapper.WrappedCLRObject\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    CLR type\n",
       "                </td>\n",
       "                <td>\n",
       "                    Microsoft.Quantum.Simulation.Core.PartialUnitary`2[[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5],[System.ValueTuple`2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5]], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            <tr>\n",
       "                <td>\n",
       "                    Assembly name\n",
       "                </td>\n",
       "\n",
       "                <td>\n",
       "                    Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5\n",
       "                </td>\n",
       "            </tr>\n",
       "\n",
       "            \n",
       "                <tr>\n",
       "                    <td>\n",
       "                        Methods\n",
       "                    </td>\n",
       "\n",
       "                    <td><pre>Type[] get_Dependencies()</pre></td>\n",
       "\n",
       "                    <tr><td></td><td><pre>Operation`2 get_BaseOp()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Func`2 get_Mapper()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Func`2 get_Body()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Func`2 get_AdjointBody()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Func`2 get_ControlledBody()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Func`2 get_ControlledAdjointBody()</pre></td></tr>\n",
       "<tr><td></td><td><pre>List`1 GetQubits()</pre></td></tr>\n",
       "<tr><td></td><td><pre>String ToString()</pre></td></tr>\n",
       "<tr><td></td><td><pre>QVoid Apply(Qubit<> args)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Object Partial(Object<> partialTuple)</pre></td></tr>\n",
       "<tr><td></td><td><pre>IOperationFactory get_Factory()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Boolean Equals(Object<> obj)</pre></td></tr>\n",
       "<tr><td></td><td><pre>Int32 GetHashCode()</pre></td></tr>\n",
       "<tr><td></td><td><pre>Type GetType()</pre></td></tr>\n",
       "                </tr>\n",
       "            \n",
       "        </table>\n",
       "        "
      ],
      "text/plain": [
       "<WrappedCLRObject(Microsoft.Quantum.Simulation.Core.PartialUnitary`2[[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5],[System.ValueTuple`2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[Microsoft.Quantum.Simulation.Core.Qubit, Microsoft.Quantum.Simulation.Core, Version=0.2.1802.2202, Culture=neutral, PublicKeyToken=40866b40fd95c7f5]], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]) at 0x178e09d1160>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "noisy_h = qsim.run(NoisyHadamardChannel, 0.1).result()\n",
    "noisy_h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tomography ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `qsharp` interoperability package also comes with a `single_qubit_process_tomography` function which uses the QInfer library for Python to learn the channels corresponding to single-qubit Q# operations.\n",
    "Here, we ask for 10,000 measurements from the noisy Hadamard operation that we defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing tomography model...\n",
      "Performing tomography...\n"
     ]
    }
   ],
   "source": [
    "estimation_results = single_qubit_process_tomography(qsim, noisy_h, n_measurements=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize the results, it's helpful to compare to the actual channel, which we can find exactly in QuTiP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "depolarizing_channel = sum(map(qt.to_super, [qt.qeye(2), qt.sigmax(), qt.sigmay(), qt.sigmaz()])) / 4.0\n",
    "actual_noisy_h = 0.1 * qt.to_choi(depolarizing_channel) + 0.9 * qt.to_choi(qt.hadamard_transform())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then plot the estimated and actual channels as Hinton diagrams, showing how each acts on the Pauli operators $X$, $Y$ and $Z$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, <matplotlib.axes._subplots.AxesSubplot at 0x178e367f198>)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x178e361ec88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (left, right) = plt.subplots(ncols=2, figsize=(12, 4))\n",
    "plt.sca(left)\n",
    "plt.xlabel('Estimated', fontsize='x-large')\n",
    "qt.visualization.hinton(estimation_results['est_channel'], ax=left)\n",
    "plt.sca(right)\n",
    "plt.xlabel('Actual', fontsize='x-large')\n",
    "qt.visualization.hinton(actual_noisy_h, ax=right)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also obtain a wealth of other information as well, such as the covariance matrix over each parameter of the resulting channel.\n",
    "This shows us which parameters we are least certain about, as well as how those parameters are correlated with each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]),\n",
       " <a list of 16 Text xticklabel objects>)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x178e361e6a0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "estimation_results['posterior'].plot_covariance()\n",
    "plt.xticks(rotation=90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diagnostics ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Python version:                  3.6.4 | packaged by conda-forge | (default, Dec 24 2017, 10:11:43) [MSC v.1900 64 bit (AMD64)]\n",
      "Quantum Development Kit version: 0.2.1802.2202\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"\"\"\n",
    "Python version:                  {}\n",
    "Quantum Development Kit version: {}\n",
    "\"\"\".format(sys.version, qsharp.__version__))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:qsharp-samples]",
   "language": "python",
   "name": "conda-env-qsharp-samples-py"
  },
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}