From 34d545152393794fabc97c2c3b822f5994683986 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Fri, 24 May 2019 17:07:58 +1000 Subject: [PATCH 01/16] # This is a combination of 12 commits. # This is the 1st commit message: starting pyquil support # This is the commit message #1: pyquil support added # This is the commit message #2: first version of pyquil notebook added # This is the commit message #3: pyquil dependency added to setup # This is the commit message #4: trying gcc install for pyquil # This is the commit message #5: replacing gcc install with build-essential # This is the commit message #6: forcing yes to install anything # This is the commit message #7: ignoring blocks in pyquil notebook for tests # This is the commit message #8: linted; unnecessary import removed from notebook # This is the commit message #9: removed all references of circuits and replaced those with programs; pyquil removed from method names # This is the commit message #10: notebook rerun after changes # This is the commit message #11: pyquil program conversion removes unnecessary method --- .circleci/config.yml | 1 + examples/export_a_dds_to_program.ipynb | 829 ++++++++++++++++++ qctrlopencontrols/__init__.py | 1 + qctrlopencontrols/pyquil/__init__.py | 21 + qctrlopencontrols/pyquil/program.py | 209 +++++ setup.py | 2 +- ...cirq_circuits.py => test_cirq_sequence.py} | 0 tests/test_pyquil_sequence.py | 67 ++ 8 files changed, 1129 insertions(+), 1 deletion(-) create mode 100755 examples/export_a_dds_to_program.ipynb create mode 100644 qctrlopencontrols/pyquil/__init__.py create mode 100644 qctrlopencontrols/pyquil/program.py rename tests/{test_cirq_circuits.py => test_cirq_sequence.py} (100%) create mode 100644 tests/test_pyquil_sequence.py diff --git a/.circleci/config.yml b/.circleci/config.yml index aa955f37..f7799b20 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -6,6 +6,7 @@ jobs: docker: - image: continuumio/anaconda3 steps: + - run: apt-get -y install build-essential - checkout - run: python3 setup.py install - run: pytest diff --git a/examples/export_a_dds_to_program.ipynb b/examples/export_a_dds_to_program.ipynb new file mode 100755 index 00000000..9e32cf63 --- /dev/null +++ b/examples/export_a_dds_to_program.ipynb @@ -0,0 +1,829 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Export a Dynamical Decoupling Sequence to Program\n", + "\n", + "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported to a Program defined in Pyquil. We also show how a DDS can decrease the number of errors, when executing a quantum program on a noisy device (simulated by Pyquil).\n", + "\n", + "Note: To create a quantum program, you need to install `pyquil` package. Follow the [instruction](http://docs.rigetti.com/en/stable/start.html) to install `pyquil`. Moreover, in order to simulate the quantum program, you will require the [FOrestSDK](https://www.rigetti.com/forest). Follow the [instruction] (http://docs.rigetti.com/en/stable/start.html) to obtain and install ForestSDK on your computer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#General\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.gridspec import GridSpec\n", + "\n", + "#Q-CTRL Open Controls\n", + "from qctrlopencontrols import new_predefined_dds, convert_dds_to_program\n", + "\n", + "#pyquil\n", + "from pyquil.api import get_qc\n", + "from pyquil.noise import dephasing_kraus_map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running a DDS on a Pyquil Quantum Virtual Machine (QVM)\n", + "\n", + "This section demonstrates how a DDS can be prepared and a corresponding Pyquil program made and executed on a Quantum Virtual Simulator (QVM).\n", + "\n", + "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", + "\n", + "Pyquil implements quantum computation through `Program` that contains a series of [gates](http://docs.rigetti.com/en/stable/apidocs/gates.html). How these gates are physically implemented will depend on the device that it is run on. Rigetti's documentation gives an oversight on Rigetti's [native gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#native-gates-for-rigetti-qpus)] and other [physically realizable gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#all-gates-and-instructions).\n", + "\n", + "If a user wants to add pauses (in time) during a computation they can use identity gates. However, executing a quantum program with identity gates cause the compiler to remove the gates before execution to increase efficiency. This can be avoided by using `Pragma PRESERVE` blocks (see [documentation](http://docs.rigetti.com/en/stable/basics.html#pragmas) for more detail and other usages of `Pragma`).All of $I$ (identity gate), $RX$ (X-rotation gates) and $RY$ (Y-rotation gates) take a fixed time (`gate_time`).\n", + "\n", + "Converting a DDS into a Pyquil program is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](XXXX).\n", + "\n", + "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We also create a Ramsey DDS of the same duration to compare as a benchmark. For both the sequences, we add a $X_{\\pi/2}$ rotation on either end of the sequence." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preparing the Sequences" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadratic sequence:\n", + "Duration = 5e-06\n", + "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", + "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", + "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", + "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", + "Ramsey sequence:\n", + "Duration = 5e-06\n", + "Offsets = [0.0,1.0] x 5e-06\n", + "Rabi Rotations = [0.5,0.5] x pi\n", + "Azimuthal Angles = [0.0,0.0] x pi\n", + "Detuning Rotations = [0.0,0.0] x pi\n" + ] + } + ], + "source": [ + "## Quadratic sequence, total duration: 20us\n", + "quadratic_sequence = new_predefined_dds(\n", + " scheme='quadratic',\n", + " duration=5e-6, \n", + " number_inner_offsets=2,\n", + " number_outer_offsets=2,\n", + " pre_post_rotation=True,\n", + " name='Quadratic sequence')\n", + "\n", + "# Ramsey sequence, total duration: 20us\n", + "ramsey_sequence = new_predefined_dds(\n", + " scheme='Ramsey',\n", + " duration=5e-6,\n", + " pre_post_rotation=True,\n", + " name='Ramsey sequence')\n", + "\n", + "print(quadratic_sequence)\n", + "print(ramsey_sequence)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing the Program Using Q-CTRL Open Controls\n", + "\n", + "To construct a `Program` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`.\n", + "\n", + "In this example, we will use $0$th qubit and specify the `gate_time` to be $50$ $n$s (see [noise specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "## Prepare the Pyquil related parameters\n", + "'''\n", + "target_qubits : list\n", + " A list of integers specifying the target qubits within the set of qubit registers\n", + "'''\n", + "target_qubits = [0]\n", + "\n", + "'''\n", + "gate_time : float\n", + " Time delay (in seconds) introduced by identity gate\n", + "'''\n", + "gate_time = 50e-9\n", + "\n", + "'''\n", + "add_measurement : bool\n", + " Indicates if the program requires a measurement step.\n", + "'''\n", + "add_measurement = True\n", + "\n", + "## convert the quadratic sequence to program\n", + "quadratic_program = convert_dds_to_program(\n", + " dynamic_decoupling_sequence=quadratic_sequence,\n", + " target_qubits=target_qubits,\n", + " gate_time=gate_time,\n", + " add_measurement=add_measurement,\n", + ")\n", + "\n", + "## convert the ramsey sequence to program\n", + "ramsey_program = convert_dds_to_program(\n", + " dynamic_decoupling_sequence=ramsey_sequence,\n", + " target_qubits=target_qubits,\n", + " gate_time=gate_time,\n", + " add_measurement=add_measurement\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the DDS\n", + "\n", + "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", + "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", + " formatted_plot_data['rabi_rotations'],\n", + " formatted_plot_data['azimuthal_angles'],\n", + " formatted_plot_data['detuning_rotations'],\n", + " formatted_plot_data['times']\n", + ")\n", + "\n", + "# prepare the axes\n", + "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", + " 3, 1, figsize=(20,5))\n", + "\n", + "rabi_plot_axis.plot(times, rabi_rotations)\n", + "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "rabi_plot_axis.set_xlabel('Time (sec)')\n", + "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", + "\n", + "azimuth_plot_axis.plot(times, azimuthal_angles)\n", + "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "azimuth_plot_axis.set_xlabel('Time (sec)')\n", + "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", + "\n", + "detuning_plot_axis.plot(times, detuning_rotations)\n", + "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "detuning_plot_axis.set_xlabel('Time (sec)')\n", + "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", + "\n", + "plt.suptitle('Quadratic Sequence')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJIAAAFhCAYAAAAr04APAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzs3XmYJVV9//H3h0XACAKCigzjEAXNYHBJAyYSgyIKRhijgKAQiOLkFzUhGhVQAwgmaoxbFJdRCYgJaFxwVJTFsGgUZVhEQJAJigwBGXZEQIHv749brZe2p7tmuu+t7pn363nu07dOnVv16f5jau63zjmVqkKSJEmSJEmazFpdB5AkSZIkSdLsYCFJkiRJkiRJrVhIkiRJkiRJUisWkiRJkiRJktSKhSRJkiRJkiS1YiFJkiRJkiRJrVhIkiRJkiRJUisWkiRJ0ipL8tMk9yT5RZIbk5yQ5BFd51pVSeYk+UKSm5PckeSyJAd3nUuSJGmmsJAkSZKmas+qegTwNODpwBEd55mKk4DrgMcDjwIOBH7eaSJJkqQZxEKSJEmaFlV1I3A6vYISAEn+PMnFSe5Mcl2So/v2zUtSSf6q2Xdbkv+XZIcklya5PcmH+/o/Mcm5zUihm5N8tm/fk5OcmeTWJFcl2bdp3yHJz5Os3df3JUl+sIJfYwfghKq6u6rur6qLq+rrfZ99ZpLvNNl+kGSXvn1bN/nuarJ8OMlnmn27JFnWf6JmNNfzmvdrJTk8yf8muSXJ55JsOubvdFCSnzW/+1v7jrN2krc0n70ryYVJtpro7yJJkrSqLCRJkqRpkWQOsAewtK/5buAvgY2BPwf+JsmLx3x0J2Ab4GXAB4C3As8DtgP2TfJnTb9jgTOATYA5wIea8/4ecCbwn8Cjgf2AjySZX1UXALcAz+8734HAp1fwa5wPHJdkvyRzx/x+WwJfA94BbAq8EfhCks2bLv8JXAhs1mQ9aAXnGM/fAi8G/gx4HHAbcNyYPjsDTwJ2BY5M8gdN+xuA/YEXAhsBrwR+OdHfZSVySZIkPYSFJEmSNFWnJrmL3pSwm4CjRndU1TlV9cOqerCqLgVOplcs6XdsVd1bVWfQKzydXFU3VdX1wLfoTZcD+DW9KWePa/p/u2l/EfDTqvr30VFEwBeAfZr9JwIHADSjfF5Ar7gynn2ac/4j8JMklyTZodl3AHBaVZ3W/D5nAkuAFzZFpx2Af6yq+6rqPOAr7f+E/D/grVW1rKruA44G9k6yTl+ft1fVPVX1A+AHwFOb9kOAt1XVVdXzg6q6pcXfRZIkaaVZSJIkSVP14qraENgFeDK9ETkAJNkpydlJlie5g17BZLMxn+9fg+iecbZHF+9+MxDg+0kuT/LKpv3xwE7NdLPbk9wOvAJ4bLP/M8CezQidfYFvVdUN4/0iVXVbVR1eVdsBjwEuoVcoS3OefcacZ2dgC5pRRFV1d9/hrl3xn+x3PB74Ut9xfwQ80GQYdWPf+1/2/V22Av53Bcec6O8iSZK00taZvIskSdLkqurcJCcA/0pvmhb0Rv58GNijqu5N8gF+t5DU9vg3Aq8GSLIzcFaS8+iNhDq3qnZbweeuT/Jd4CX0prV9tOX5bk7yr/SmqG3anOekqnr12L5JHg9skuT3+opJc4Fq3t8NPLyv/9rA5n2HuA54ZVX9zzjHnjdJ1OuAJwCXjdO+wr+LJEnSqnBEkiRJmk4fAHZLMjrtakPg1qaItCPw8lU9cJJ9mnWYoLeGUAEPAl8Ftk1yYJJ1m9cOfWsIQW9NpDcDfwh8cYJzvDvJU5Ksk2RD4G+Apc1UsdGRTS9oFrhev1lEe05VXUtvmtvbkzysKXTt2XfoHwPrp7f4+LrA24D1+vZ/DPinpiBFks2TLGj5p/kkcGySbdKzfZJHtfy7SJIkrRQLSZIkadpU1XJ6RZsjm6bXAMc0aygdCXxuCoffAfhekl8Ai4FDq+qaqrqL3mLa+wH/R28K2Lt5aKHmSzTTx6rqlxOc4+FN39uBa5rP7NX8btcBC4C3AMvpjfh5E7/9/9TL6S0cfiu9daJ+s6B3Vd1B72/xSeB6eiOU+p/i9sHmdzqj+Vud3xyrjffR+7ueAdwJfArYoOXfRZIkaaWkqibvJUmSNMsl+V/gr6vqrCGd72jgiVV1wDDOJ0mSNAyOSJIkSau9JC+lNxXuv7vOIkmSNJu52LYkSVqtJTkHmA8cWFUPdhxHkiRpVnNqmyRJkiRJklpxapskSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkVtbpOsDK2myzzWrevHldx5CkGefCCy+8uao27zpH17xOSNL4vE70eJ2QpPG1vU7MukLSvHnzWLJkSdcxJGnGSXJt1xlmAq8TkjQ+rxM9XickaXxtrxNObZMkSZIkSVIrFpIkSZIkSZLUysAKSUmOT3JTkssm6LNLkkuSXJ7k3EFlkSRJkiRJ0tQNckTSCcDuK9qZZGPgI8BeVbUdsM8As0iSJEmSJGmKBlZIqqrzgFsn6PJy4ItV9bOm/02DyiJJkiRJkqSp63KNpG2BTZKck+TCJH/ZYRZJkiRJkiRNYp2Oz/1HwK7ABsB3k5xfVT8e2zHJQmAhwNy5c4caUpIkSZIkST1djkhaBpxeVXdX1c3AecBTx+tYVYuqaqSqRjbffPOhhpQkSZIkSVJPl4WkLwM7J1knycOBnYAfdZhHkiRJkiRJExjY1LYkJwO7AJslWQYcBawLUFUfq6ofJfkGcCnwIPDJqrpsUHkO+OT3APjMITsN6hSSNGX+WyVJkiRpJhtYIamq9m/R5z3AewaVod+3l948jNNI0pT4b5UkSZKkmazLqW2SJEmSJEmaRSwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSZIkSZKkViwkSZIkSZIkqRULSZIkSZIkSWrFQpIkSZIkSZJasZAkSRq4JLsnuSrJ0iSHj7N/vSSfbfZ/L8m8MfvnJvlFkjcOK7MkaXi8TkjS7GEhSZI0UEnWBo4D9gDmA/snmT+m26uA26rqicD7gXeP2f8+4OuDzipJGj6vE5I0uwyskJTk+CQ3Jblskn47JLk/yd6DyiJJ6tSOwNKquqaqfgWcAiwY02cBcGLz/vPArkkCkOTFwE+Ay4eUV5I0XF4nJGkWGeSIpBOA3Sfq0Nx9eDdwxgBzSJK6tSVwXd/2sqZt3D5VdT9wB/CoJI8ADgPePoSckqRueJ2QpFlkYIWkqjoPuHWSbn8LfAG4aVA5JEmz2tHA+6vqFxN1SrIwyZIkS5YvXz6cZJKkmeBovE5I0lCt09WJk2wJ/AXwHGCHrnJIkgbuemCrvu05Tdt4fZYlWQd4JHALsBOwd5J/ATYGHkxyb1V9uP/DVbUIWAQwMjJSA/ktJEmD4nVCkmaRzgpJwAeAw6rqwWZ68wolWQgsBJg7d+4QokmSptEFwDZJtqb3RWA/4OVj+iwGDgK+C+wN/HdVFfCnox2SHA38YuyXA0nSrOd1QpJmkS4LSSPAKU0RaTPghUnur6pTx3b0DoIkzV5VdX+S1wGnA2sDx1fV5UmOAZZU1WLgU8BJSZbSmxa9X3eJJUnD5HVCkmaXzgpJVbX16PskJwBfHa+IJEma/arqNOC0MW1H9r2/F9hnkmMcPZBwkqTOeZ2QpNljYIWkJCcDuwCbJVkGHAWsC1BVHxvUeSVJkiRJkjQYAyskVdX+K9H34EHlkCRJkiRJ0vRYq+sAkiRJkiRJmh0sJEmSJEmSJKkVC0mSJEmSJElqxUKSJEmSJEmSWrGQJEmSJEmSpFYsJEmSJEmSJKkVC0mSJEmSJElqxUKSJEmSJEmSWrGQJEmSJEmSpFYsJEmSJEmSJKkVC0mSJEmSJElqxUKSJEmSJEmSWrGQJEmSJEmSpFYsJEmSJEmSJKkVC0mSJEmSJElqxUKSJEmSJEmSWrGQJEmSJEmSpFYsJEmSJEmSJKkVC0mSJEmSJElqxUKSJEmSJEmSWrGQJEmSJEmSpFYsJEmSJEmSJKkVC0mSJEmSJElqZWCFpCTHJ7kpyWUr2P+KJJcm+WGS7yR56qCySJIkSZIkaeoGOSLpBGD3Cfb/BPizqvpD4Fhg0QCzSJIkSZIkaYrWGdSBq+q8JPMm2P+dvs3zgTmDyiJJkiRJkqSpmylrJL0K+HrXISRJkiRJkrRiAxuR1FaS59ArJO08QZ+FwEKAuXPnDimZJEmSJEmS+nU6IinJ9sAngQVVdcuK+lXVoqoaqaqRzTfffHgBJUmSJEmS9BudFZKSzAW+CBxYVT/uKockSZIkSZLaGdjUtiQnA7sAmyVZBhwFrAtQVR8DjgQeBXwkCcD9VTUyqDySJEmSJEmamkE+tW3/SfYfAhwyqPNLkiRJkiRpes2Up7ZJkiRJkiRphrOQJEmSJEmSpFYGNrVNkiRJ0uyX5I+BA4A/BbYA7gEuA74GfKaq7ugwniRpyByRJEmSJGlcSb5Ob13T04Hd6RWS5gNvA9YHvpxkr+4SSpKGzRFJkiRJklbkwKq6eUzbL4CLmtd7k2w2/FiSpK44IkmSJEnSuMYpIq1SH0nS6sMRSZIkSZLGleQuoFa0v6o2GmIcSdIM4IgkSRIASUaSvD7Je5Ick2TfJJtM07F3T3JVkqVJDh9n/3pJPtvs/16SeU37bkkuTPLD5udzpyOPJKmdqtqwKRZ9EDgc2BKYAxwGfGA6zuE1QpJmFwtJkrSGS/JXSS4CjgA2AK4CbgJ2Bs5KcmKSuVM4/trAccAe9BZo3T/J/DHdXgXcVlVPBN4PvLtpvxnYs6r+EDgIOGlVc0iSpmSvqvpIVd1VVXdW1UeBBVM9qNcISZp9nNomSXo48Kyqume8nUmeBmwD/GwVj78jsLSqrmmOdwq9Lx9X9PVZABzdvP888OEkqaqL+/pcDmyQZL2qum8Vs0iSVs3dSV4BnEJvqtv+wN3TcFyvEZI0yzgiSZLWcFV13IqKSM3+S6rqm1M4xZbAdX3by5q2cftU1f3AHcCjxvR5KXDReF8QkixMsiTJkuXLl08hqiRpBV4O7Av8vHnt07RN1cCvEeB1QpKmU+sRSc06GY8D7gF+WlUPDiyVJGlokvzbRPur6u+GlWVFkmxHbyrD88fbX1WLgEUAIyMjK1wUVpK0aqrqp0zDVLZBmOwaAV4nJGk6TVhISvJI4LX0hq4+DFgOrA88Jsn5wEeq6uyBp5QkDdKFzc9n0Vuf4rPN9j48dGrBqroe2Kpve07TNl6fZUnWAR4J3AKQZA7wJeAvq+p/pyGPJGklJVmf3lpF29H7PgBAVb1yiof2GiFJs8xkU9s+T28Y6Z9W1ZOqaueqGqmqrYB3AQuSvGrgKSVJA1NVJ1bVicD2wC5V9aGq+hCwK/C0aTjFBcA2SbZO8jBgP2DxmD6L6S2UCrA38N9VVUk2Br4GHF5V/zMNWSRJq+Yk4LHAC4Bz6RV87pqG43qNkKRZZsIRSVW12wT7LuS3d7ElSbPfJsBGwK3N9iOatimpqvuTvA44HVgbOL6qLk9yDLCkqhYDnwJOSrK0Of9+zcdfBzwRODLJkU3b86vqpqnmkiStlCdW1T5JFlTViUn+E/jWVA/qNUKSZp/JprY9Y6L9VXXR9MaRJHXoXcDFSc4GAjyb3z4lZ0qq6jTgtDFtR/a9v5feVLqxn3sH8I7pyCBJmpJfNz9vT/IU4Ebg0dNxYK8RkjS7TLbY9nubn+sDI8AP6H252B5YAvzx4KJJkoapqv49ydeBnZqmw6rqxi4zSZJmjEXNw3feRm+q2SOAf+w2kiSpC5NNbXsOQJIvAs+oqh82209hmu5SS5JmlPuAG+jdQNg2ybZVdV7HmSRJHUqyFnBnVd0GnAf8fseRJEkdmmxE0qgnjRaRAKrqsiR/MKBMkqQOJDkEOJTeAqqXAM8Evgs8t8tckqRuVdWDSd4MfK7rLJKk7k321LZRlyb5ZJJdmtcngEsHGUySNHSHAjsA1zYjUp8O3N5tJEnSDHFWkjcm2SrJpqOvrkNJkoav7YikvwL+ht6XDOgNaf3oQBJJkrpyb1Xdm4Qk61XVlUme1HUoSdKM8LLm52v72gqnuUnSGqdVIal5UsL7m5ckafW0LMnGwKnAmUluA67tOJMkaQaoqq27ziBJmhlaTW1Lsk2Szye5Isk1o69JPnN8kpuSXLaC/Unyb0mWJrk0yTNW5ReQJE2PqvqLqrq9qo6m9ySeTwEv7jaVJKlLSXaeZP9GzYN4JElriLZT2/4dOIreiKTn0JvqNlkR6gTgw8CnV7B/D2Cb5rUTvalyO62gryRpgJKsDVxeVU8GqKpzO44kSZoZXprkX4BvABcCy+k92fOJ9L4XPB74h+7iSZKGrW0haYOq+maSVNW1wNFJLgSOXNEHquq8JPMmOOYC4NNVVcD5STZOskVV3dA2vCRpelTVA0muSjK3qn7WdR5J0sxQVa9vFtV+KbAPsAVwD/Aj4ONV9e0u80mShq9tIem+JGsBVyd5HXA98IgpnntL4Lq+7WVNm4UkSerGJsDlSb4P3D3aWFV7dRdJktS1qroV+ETzkiSt4doWkg4FHg78HXAsvWGsBw0q1FhJFgILAebOnTus00rSmuYfuw4gSZIkaWabtJDUrJvxsqp6I/ALeusjTYfrga36tuc0bb+jqhYBiwBGRkZqms4vSaL38IPqWeG6SKN9hplLkiRJ0swz6VPbquoBYMKnNayixcBfNk9veyZwh+sjSVInzk7yt0keMuQzycOSPDfJiQxxFKokSZKkmavt1LaLkywG/ouHrpvxxRV9IMnJwC7AZkmW0Xvq27rN5z4GnAa8EFgK/JLpG+kkSVo5uwOvBE5OsjVwO7ABvZsNZwAfqKqLO8wnSZoBkvwJMI++7xBVtaInNEuSVlNtC0nrA7cAz+1rK2CFhaSq2n+iAzZTJF7b8vySpAGpqnuBjwAfSbIusBlwT1Xd3m0ySdJMkeQk4AnAJcADTXMBFpIkaQ3TqpBUVY4WkqQ1QFX9Gp+eKUn6XSPAfNfLkyRNuEZSkrcl2XSC/c9N8qLpjyVJkiRpBrkMeGzXISRJ3ZtsRNIPga8kuRe4CFhOb5rbNsDTgLOAfx5oQkmSJEld2wy4Isn3gftGG6tqr+4iSZK6MGEhqaq+DHw5yTbAs4AtgDuBzwALq+qewUeUJA1LkscD21TVWUk2ANapqru6ziVJ6tzRXQeQJM0MbddIuhq4esBZJEkdSvJqYCGwKb0FVecAHwN27TKXJKl7VXVukscAOzRN36+qm7rMJEnqxoRrJEmS1iivpTf69E74zU2ER3eaSJI0IyTZF/g+sA+wL/C9JHt3m0qS1IVWI5IkSWuE+6rqV0kASLIOvUc7S5L0VmCH0VFISTant17q5ztNJUkaOkckSZJGnZvkLcAGSXYD/gv4SseZJEkzw1pjprLdgt8lJGmN1Oof/yT/kmSjJOsm+WaS5UkOGHQ4SdJQHU7v6Zw/BP4aOA14W6eJJEkzxTeSnJ7k4CQHA1+jd52QJK1h2k5te35VvTnJXwA/BV4CnEfv6W2SpNVAVT0IfKJ5SZL0G1X1piQvpbeWHsCiqvpSl5kkSd1oW0ga7ffnwH9V1R2ja2hIkma3JD9kgrWQqmr7IcaRJM1QVfUF4Atd55AkdattIemrSa4E7gH+pllc797BxZIkDdGLug4gSZqZkny7qnZOchcPvekQoKpqo46iSZI60qqQVFWHJ/kX4I6qeiDJ3cCCwUaTJA1DVV3bdQZJ0sxUVTs3PzfsOoskaWZoOyIJ4MnAvOZx0KM+Pc15JEkdGeduM8AdwBLgH6rqmuGnkiTNBElOqqoDJ2uTJK3+WhWSkpwEPAG4BHigaS4sJEnS6uQDwDLgP+lNWdiP3r/9FwHHA7t0lkyS1LXt+jeam8t/1FEWSVKH2o5IGgHmV9UKF2OVJM16e1XVU/u2FyW5pKoOS/KWzlJJkjqT5AjgLcAGSe4cbQZ+BSzqLJgkqTNrtex3GfDYQQaRJHXul0n2TbJW89qX3z5YwRsJkrQGqqp3NusjvaeqNmpeG1bVo6rqiK7zSZKGr+2IpM2AK5J8H7hvtLGq9hpIKklSF14BfBD4CL3C0fnAAUk2AF7XZTBJUreq6ogkmwDbAOv3tZ/XXSpJUhfaFpKOHmQISVL3msW091zB7m8PM4skaWZJcghwKDCH3rqpzwS+Czy3y1ySpOFrVUiqqnOTPAbYoWn6flXdNLhYkqRhS7I58GpgHn3Xh6p6ZVeZJEkzxqH0vgucX1XPSfJk4J87ziRJ6kDbp7btC7wHOIfe4nofSvKmqvr8ALNJkobry8C3gLP47RM6JUkCuLeq7k1CkvWq6sokT+o6lCRp+NpObXsrsMPoKKTmrvVZgIUkSVp9PLyqDus6hCRpRlqWZGPgVODMJLcB13acSZLUgbaFpLXGTGW7hfZPfJMkzQ5fTfLCqjqt6yCSpJmlqv6ieXt0krOBRwJf7zCSJKkjbYtB30hyepKDkxwMfA2Y9ItGkt2TXJVkaZLDx9k/N8nZSS5OcmmSF65cfEnSNDqUXjHpniR3JrkryZ1dh5IkdS/JSaPvq+rcqloMHN9hJElSR9outv2mJC8FntU0LaqqL030mSRrA8cBuwHLgAuSLK6qK/q6vQ34XFV9NMl8esWpeSv5O0iSpkFVbdh1BknSjLVd/0bzf/0/6iiLJKlDraenVdUXquoNzWvCIlJjR2BpVV1TVb8CTgEWjD0ssFHz/pHA/7XNI0kanCRPSPK2JJdP0/EmG6G6XpLPNvu/l2Re374jmvarkrxgOvJIktpp/g2+C9i+b7TqXcBN9B7SMF3n8TohSbPEhIWkJN9uft7VXDjuTPvpDlsC1/VtL2va+h0NHJBkGb3RSH+7UuklSdMmyeOSvCHJBcDlwNrAftNw3NERqnsA84H9m1Go/V4F3FZVTwTeD7y7+ez8JsN2wO7AR5rjSZKGoKre2YxYfU9VbVRVGzavR1XVEdNxDq8TkjS7TFhIqqqdm58bNheOjfouIBtN9NmW9gdOqKo5wAuBk5L8TqYkC5MsSbJk+fLl03BaSdKo5t/Ys4FzgE3p/Wf9hqp6e1X9cBpO0WaE6gLgxOb954Fdk6RpP6Wq7quqnwBLm+NJkoaoqo5IsleSf21eL5rGw3udkKRZpNUaSUlOqqoDJ2sb43pgq77tOU1bv1fRu3NAVX03yfrAZvSGyv5GVS0CFgGMjIxUm8ySpNY+DHwXeHlVLQFIMp3/1o43QnWnFfWpqvuT3AE8qmk/f8xnx45unRZv/8rlXPF/ri0uaWab/7iNOGrP7SbvOM2SvJNegeY/mqZDk/xJVb1lGg7vdUKSpskwrhNt10gau7jeOky+uN4FwDZJtk7yMHpDTheP6fMzYNfmmH8ArA845EiShmsL4GTgvc36EscC63acaaU4clWSBu7Pgd2q6viqOp7ezeDpHJU0UF4nJGn6TDgiKckRwFuADfrWRArwK5oRQivS3Cl4HXA6vXU2jq+qy5McAyxpHhn6D8Ankrye3sLbB1eVI44kaYiq6hbgY8DHkswBXgb8PMmPgC9Nw93mNiNUR/ssa25WPBK4peVnp2Xkahd3+CVpltkYuLV5/8hpPK7XCUmaRSZbI2ns4nqj6yO1Wlyvqk6rqm2r6glV9U9N25FNEYmquqKqnlVVT62qp1XVGdPyW0mSVklVLauq91bVCL11J+6dhsO2GaG6GDioeb838N/NjYXFwH7N03q2BrYBvj8NmSRJK+edwMVJTkhyInAh8M/TdGyvE5I0i7RaI6lZXG8Tev8wr9/Xft6ggkmSulVVPwaOmYbjtBmh+il6D1xYSu9u937NZy9P8jngCuB+4LVV9cBUM0mSVk5VnZzkHGCHpumwqrpxmo7tdUKSZpG2i20fAhxKb6joJcAz6S3M+tzBRZMkrS6q6jTgtDFtR/a9vxfYZwWf/SfgnwYaUJI0qaq6gWakUJJtkxxbVa+epmN7nZCkWaLtYtuH0rv7cG1VPQd4OnD7wFJJkiRJ6lyS7ZOckeSyJO9IskWSLwD/TW8UkCRpDdNqRBJwb1Xdm4Qk61XVlUmeNNBkkqShSPKMifZX1UXDyiJJmnE+AXyU3myE3enNTjgReEUzSkiStIZpW0halmRj4FTgzCS3AdcOLpYkaYjeO8G+wmnMkrQmW6+qTmjeX5Xk0Kp6c5eBJEndarvY9l80b49Ocja9x21+fWCpJElD00xZliRpPOsneTqQZvu+/m1HrUrSmqftYtsnVdWBAFV17mgbcOAAs0mShizJU4D5PPQJnZ/uLpEkqWM3AO/r276xb9tRq5K0Bmo7tW27/o0kawN/NP1xJEldSXIUsAu9QtJpwB7AtwELSZK0hnLUqiRprAmf2pbkiCR3AdsnuTPJXc32TcCXh5JQkjQsewO7AjdW1V8BT6U3lVmSJEmSgEkKSVX1zqraEHhPVW1UVRs2r0dV1RFDyihJGo57qupB4P4kG9G7abBVx5kkSZIkzSBtF9s+IslewLObpnOq6quDiyVJ6sCS5gmdnwAuBH5B73HPkiRJkgS0X2z7ncCOwH80TYcm+ZOqesvAkkmShqqqXtO8/ViSbwAbVdWlXWaSJM0MSZ4xTvMdwLVVdf+w80iSutN2se0/B57WTHkgyYnAxYCFJElajSTZEng8zfUhybOr6rxuU0mSZoCPAM8ALgUCPAWLuq4tAAAamElEQVS4HHhkkr+pqjO6DCdJGp62hSSAjYFbm/cuvipJq5kk7wZeBlwBPNA0F2AhSZL0f8CrqupygCTzgWOANwNfBCwkSdIaom0h6Z3AxUnOpncH4tmAi21L0urlxcCTquq+roNIkmacbUeLSABVdUWSJ1fVNUm6zCVJGrK2i22fnOQcYIem6bCqunFgqSRJXbgGWBewkCRJGuvyJB8FTmm2XwZckWQ94NfdxZIkDVvrqW1VdQOwGCDJtkmOrapXDyyZJGkoknyI3hS2XwKXJPkmfcWkqvq7rrJJkmaMg4HXAH/fbP8P8EZ6RaTndJRJktSBCQtJSbYH/hV4HHAqcBzwYWAn4L0DTydJGoYlzc8LaW4Y9KkhZ5EkzUBVdQ+9//+P9x3gF0OOI0nq0GQjkj4BfBT4LrA7cAlwIvCKqrp3wNkkSUNQVScCJDm0qj7Yvy/Jod2kkiTNJEmeBRxN35M9Aarq97vKJEnqxlqT7F+vqk6oqquaLxd3V9WbLSJJ0mrpoHHaDh52CEnSjPQp4H3AzvTWTR19SZLWMJONSFo/ydPpPakN4L7+7aq6aJDhJEmDl2R/4OXA1kn6p7ZtCNzaTSpJ0gxzR1V9vesQkqTuTVZIuoHenYdRN/ZtF/DcQYSSJA3Vd+j9e78ZD1374i7g0k4SSZJmmrOTvAf4Ig99IIM3liVpDTNhIamqpvQEhiS7Ax8E1gY+WVXvGqfPvvTmWxfwg6p6+VTOKUlaOVV1LXAt8MddZ5EkzVg7NT9H+tq8sSxJa6DJRiStsiRr03vK227AMuCCJIur6oq+PtsARwDPqqrbkjx6UHkkSRNLche/fUrbw4B16a2Nt1F3qSRJM8FUbzBLklYfAyskATsCS6vqGoAkpwALgCv6+rwaOK6qbgOoqpsGmEeSNIGq2nD0fZLQ+zf7md0lkiR1LckBVfWZJG8Yb39VvW+8dknS6muyp7ZNxZbAdX3by5q2ftsC2yb5nyTnN1PhJEkdq55TgRd0nUWS1Knfa35uuIKXJGkNM+GIpCRPrqorkzxjvP3TsLjeOsA2wC7AHOC8JH9YVbePybEQWAgwd+7cKZ5SkjSeJC/p21yL3joY93YUR5I0A1TVx5ufb+86iyRpZphsatsb6BVw3jvOvskW17se2Kpve07T1m8Z8L2q+jXwkyQ/pldYuuAhJ6paBCwCGBkZKSRJg7Bn3/v7gZ/Sm94mSVrDJdmc3rIU8+j7DlFVr+wqkySpG5M9tW1h83NVFte7ANgmydb0Ckj7AWOfyHYqsD/w70k2ozfV7ZpVOJckaYqq6q+6ziBJmrG+DHwLOAt4oOMskqQOtVpsO8n6wGuAnemNRPoW8LGqWuGUh6q6P8nrgNOBtYHjq+ryJMcAS6pqcbPv+UmuoHdBelNV3TKl30iStEqawv/f8rt3m/fqKpMkacZ4eFUd1nUISVL32j617dPAXcCHmu2XAycB+0z0oao6DThtTNuRfe+L3vS5cZ8CIUkaqlOBTwFfAR7sOIskaWb5apIXNv+/lyStwdoWkp5SVfP7ts9uRhFJklYf91bVv3UdQpI0Ix0KvCXJfcCvgdC7L7xRt7EkScPWtpB0UZJnVtX5AEl2ApYMLpYkqQMfTHIUcAZw32jjNDyhU5I0y1XVhl1nkCTNDBMWkpL8kN6aSOsC30nys2b78cCVg48nSRqiPwQOpPdEztGpbZM9oVOStAZI8uzx2qvqvGFnkSR1a7IRSS8aSgpJ0kywD/D7VfWrroNIkmacN/W9Xx/YEbgQbzZI0hpnwkJSVV3bv53k0fQuHJKk1c9lwMbATV0HkSTNLFW1Z/92kq2AD3QUR5LUoVZrJCXZC3gv8Dh6XzAeD/wI2G5w0SRJQ7YxcGWSC3joGkl7dRdJkjRDLQP+oOsQkqTha7vY9rHAM4GzqurpSZ4DHDC4WJKkDhzVdQBJ0syU5EP01s0DWAt4GuDDGCRpDdS2kPTrqrolyVpJ1qqqs5M4lFWSViNVdW7XGSRJM1b/E5vvB06uqv/pKowkqTttC0m3J3kEcB7wH0luAu4eXCxJ0rAk+XZV7ZzkLn57txkgQFXVRh1FkyTNHBtX1Qf7G5IcOrZNkrT6W6tlvwXAL4HXA98A/hfYc8JPSJJmharaufm5YVVt1Pfa0CKSJKlx0DhtBw87hCSpe60KSVV1d1U9WFX3V9WJwIeB3QcbTZI0TEk+leRpY9qO7iiOJGkGSLJ/kq8AWydZ3Pc6G7i163ySpOGbcGpbko2A1wJbAouBM5vtNwI/AP5j0AElSUPzAmAkyfuamwYAewFHdxdJktSx7wA3AJvRe4rzqLuASztJJEnq1GQjkk4CngT8EDgEOBvYB3hxVS0YcDZJ0nDdBDwb2DvJcUnWobdO0ipLsmmSM5Nc3fzcZAX9Dmr6XJ3koKbt4Um+luTKJJcneddUskiSVl5VXVtV51TVHwM/BdZtHs7wI2CDqR7f64QkzT6TFZJ+v6oOrqqPA/sD84EXVNUlg48mSRqyVNUdVbUnsBw4B3jkFI95OPDNqtoG+Gaz/dCTJpsCRwE7ATsCR/V9kfjXqnoy8HTgWUn2mGIeSdIqSPJq4PPAx5umOcCp03BorxOSNMtMVkj69eibqnoAWFZV9w42kiSpI4tH31TV0cC7gZ9M8ZgLgNFpcicCLx6nzwuAM6vq1qq6jd406t2r6pdVdXaT51fARfS+uEiShu+1wLOAOwGq6mrg0dNwXK8TkjTLTFZIemqSO5vXXcD2o++T3DmMgJKk4aiqo8Y03QZcOcXDPqaqbmje3wg8Zpw+WwLX9W0va9p+I8nG9J4W+s3xTpJkYZIlSZYsX758ipElSeO4rynWANBMf65pOK7XCUmaZSZcbLuq1h5WEElS95I8HXg5vfXwfgJ8ocVnzgIeO86ut/ZvVFUlWekvHc2XlZOBf6uqa8brU1WLgEUAIyMj0/HFRpL0UOcmeQuwQZLdgNcAX2nzQa8TkrR6mbCQJEla/SXZlt46ePsDNwOfpbde0nPafL6qnjfBsX+eZIuquiHJFvQW9B7remCXvu059NZnGrUIuLqqPtAmjyRpIA4HXkXvITx/DZwGfLLNB71OSNLqZbKpbZKk1d+VwHOBF1XVzlX1IeCBaTr2YuCg5v1BwJfH6XM68PwkmzSLpz6/aSPJO+gt+P3305RHkrQKqupBeotrv6aq9q6qT1TVdIzs8TohSbOMhSRJ0kuAG4Czk3wiya5ApunY7wJ2S3I18LxmmyQjST4JUFW3AscCFzSvY6rq1iRz6E17mA9clOSSJIdMUy5JUgvpOTrJzcBVwFVJlic5cppO4XVCkmYZp7ZJ0hquqk4FTk3ye/SenvP3wKOTfBT4UlWdMYVj3wLsOk77EuCQvu3jgePH9FnG9BW0JEmr5vX0nta2Q1X9BCDJ7wMfTfL6qnr/VA7udUKSZh9HJEmSAKiqu6vqP6tqT3rrT1wMHNZxLElStw4E9h8tIgE0C1ofAPxlZ6kkSZ2xkCRJ+h1VdVtVLaqq37lLLElao6xbVTePbayq5cC6HeSRJHVsoIWkJLsnuSrJ0iSHT9DvpUkqycgg80iSJElaKb9axX2SpNXUwNZISrI2cBywG7AMuCDJ4qq6Yky/DYFDge8NKoskSZKkVfLUJHeO0x5g/WGHkSR1b5AjknYEllbVNVX1K+AUeou4jnUs8G7g3gFmkSRJkrSSqmrtqtponNeGVeXUNklaAw2ykLQlcF3f9rKm7TeSPAPYqqq+NsAckiRJkiRJmgadLbadZC3gfcA/tOi7MMmSJEuWL18++HCSJEmSJEn6HYMsJF0PbNW3PadpG7Uh8BTgnCQ/BZ4JLB5vwe3myUEjVTWy+eabDzCyJEmSJEmSVmSQhaQLgG2SbJ3kYcB+wOLRnVV1R1VtVlXzqmoecD6wV1UtGWAmSZIkSZIkraKBFZKq6n7gdcDpwI+Az1XV5UmOSbLXoM4rSZIkSZKkwVhnkAevqtOA08a0HbmCvrsMMoskSZIkSZKmprPFtiVJkiRJkjS7WEiSJEmSJElSKxaSJEmSJEmS1IqFJEmSJEmSJLViIUmSJEmSJEmtWEiSJEmSJElSKxaSJEmSJEmS1IqFJEmSJEmSJLViIUmSJEmSJEmtWEiSJEmSJElSKxaSJEmSJEmS1IqFJEmSJEmSJLViIUmSJEmSJEmtWEiSJEmSJElSKxaSJEmSJEmS1IqFJEmSJEmSJLViIUmSJEmSJEmtWEiSJEmSJElSKxaSJEmSJEmS1IqFJEmSJEmSJLViIUmSJEmSJEmtWEiSJEmSJElSKwMtJCXZPclVSZYmOXyc/W9IckWSS5N8M8njB5lHkiRJkiRJq25ghaQkawPHAXsA84H9k8wf0+1iYKSqtgc+D/zLoPJIkiRJkiRpagY5ImlHYGlVXVNVvwJOARb0d6iqs6vql83m+cCcAeaRJEmSJEnSFAyykLQlcF3f9rKmbUVeBXx9gHkkSZIkSZI0Bet0HQAgyQHACPBnK9i/EFgIMHfu3CEmkyRJkiRJ0qhBjki6Htiqb3tO0/YQSZ4HvBXYq6ruG+9AVbWoqkaqamTzzTcfSFhJkiRJkiRNbJCFpAuAbZJsneRhwH7A4v4OSZ4OfJxeEemmAWaRJEmSJEnSFA2skFRV9wOvA04HfgR8rqouT3JMkr2abu8BHgH8V5JLkixeweEkSbNQkk2TnJnk6ubnJivod1DT5+okB42zf3GSywafWJI0TF4nJGn2GegaSVV1GnDamLYj+94/b5DnlyR17nDgm1X1riSHN9uH9XdIsilwFL218gq4MMniqrqt2f8S4BfDjS1JGhKvE5I0ywxyapskSQuAE5v3JwIvHqfPC4Azq+rW5kvBmcDuAEkeAbwBeMcQskqShs/rhCTNMhaSJEmD9JiquqF5fyPwmHH6bAlc17e9rGkDOBZ4L/DLgSWUJHXJ64QkzTIDndomSVr9JTkLeOw4u97av1FVlaRW4rhPA55QVa9PMm+SvguBhQBz585tewpJ0hB4nZCk1YuFJEnSlEy03l2SnyfZoqpuSLIFMN4TOq8HdunbngOcA/wxMJLkp/SuV49Ock5V7TLm81TVImARwMjISOsvIZKkwfM6IUmrF6e2SZIGaTEw+nSdg4Avj9PndOD5STZpntbzfOD0qvpoVT2uquYBOwM/Hu/LgSRpVvM6IUmzjIUkSdIgvQvYLcnVwPOabZKMJPkkQFXdSm+Niwua1zFNmyRp9ed1QpJmGae2SZIGpqpuAXYdp30JcEjf9vHA8RMc56fAUwYQUZLUIa8TkjT7OCJJkiRJkiRJrVhIkiRJkiRJUisWkiRJkiRJktSKhSRJkiRJkiS1YiFJkiRJkiRJrVhIkiRJkiRJUisWkiRJkiRJktSKhSRJkiRJkiS1YiFJkiRJkiRJrVhIkiRJkiRJUisWkiRJkiRJktSKhSRJkiRJkiS1YiFJkiRJkiRJrVhIkiRJkiRJUisWkiRJkiRJktSKhSRJkiRJkiS1MtBCUpLdk1yVZGmSw8fZv16Szzb7v5dk3iDzSJIkSZIkadUNrJCUZG3gOGAPYD6wf5L5Y7q9Critqp4IvB9496DySJIkSZIkaWrWGeCxdwSWVtU1AElOARYAV/T1WQAc3bz/PPDhJKmqGlSol338u4M6tCRJkiRJ0mptkFPbtgSu69te1rSN26eq7gfuAB419kBJFiZZkmTJ8uXLVynM+uu6HJSk2cF/ryRJkiTNVIMckTRtqmoRsAhgZGRklUYrXXnsHtOaSZIkSZIkaU0zyNve1wNb9W3PadrG7ZNkHeCRwC0DzCRJkiRJkqRVNMhC0gXANkm2TvIwYD9g8Zg+i4GDmvd7w/9v725DJa3LOI5/f5ql+ZCUW4kPGT6LqFvLIj6VUmYlGYGQqCFZEahpYlFQoZJkFFYvLDD1hSZa4lZiloqaoliuD7tuqxZmVivCaiK6mIZ69WJu8Wim4565555z398PDGdmzpn/ua7ZM/M7e53/PcMNbb4+kiRJkiRJktZfa4e2VdVzSU4ErgE2BC6sqtVJzgTuqKorgQuAi5M8ADzOaNgkSZIkSZKkGdTqayRV1dXA1a+47ltzzj8DHNlmDZIkSZIkSZoM3xpIkiRJkiRJY3GQJEmSJEmSpLE4SJIkSZIkSdJYHCRJkiRJkiRpLA6SJEmSJEmSNBYHSZIkSZIkSRqLgyRJkiRJkiSNJVXVdQ1vSJJHgb+v5823Ah6bYDmzbkj9DqlXsN++W99+31NViyZdzEJjTrwhQ+p3SL2C/fbZfHo1JzAn3qAh9TukXsF++6z1nFhwg6T5SHJHVS3puo5pGVK/Q+oV7LfvhtbvLBnafT+kfofUK9hvnw2p11k0tPt/SP0OqVew3z6bRq8e2iZJkiRJkqSxOEiSJEmSJEnSWIY2SDqv6wKmbEj9DqlXsN++G1q/s2Ro9/2Q+h1Sr2C/fTakXmfR0O7/IfU7pF7Bfvus9V4H9RpJkiRJkiRJWn9D25EkSZIkSZKk9TSYQVKSw5L8OckDSb7WdT1tSnJhkrVJ/tR1LW1Lsl2SG5Pcm2R1kpO7rqlNSTZOcnuSlU2/Z3RdU9uSbJjk7iRXdV1L25I8lGRVkhVJ7ui6nqExJ/rJnDAn+sSc6M6QMgLMia5rapM50W/TyolBHNqWZEPgL8CHgTXAcuCoqrq308JakuQgYB1wUVXt2XU9bUqyNbB1Vd2VZHPgTuCTPf63DbBpVa1LshFwC3ByVf2h49Jak+RUYAmwRVUd3nU9bUryELCkqh7rupahMSf6y5wwJ/rEnOjG0DICzAnMiV4xJyZvKDuSlgIPVNWDVfUf4DLgiI5rak1V3Qw83nUd01BVj1TVXc35p4D7gG26rao9NbKuubhRc+rtNDjJtsDHgfO7rkW9Z070lDlhTkgTMKiMAHMCc6I3zIl2DGWQtA3wzzmX19DjJ4ehSrIDsBj4Y7eVtKvZmrkCWAtcV1V97veHwFeBF7ouZEoKuDbJnUm+0HUxA2NODIA50UvmhKbBjBgIc6KXzIkWDGWQpJ5LshlwBXBKVT3ZdT1tqqrnq2ofYFtgaZJebjdOcjiwtqru7LqWKTqgqt4HfBQ4odlWLmkCzIn+MSfMCWmSzIn+MSfay4mhDJIeBrabc3nb5jr1QHNs7xXAJVW1rOt6pqWqngBuBA7rupaW7A98ojnO9zLgkCQ/67akdlXVw83HtcAvGW2l13SYEz1mTpgTfWFOdMaM6Dlzwpzoi2nlxFAGScuBnZO8N8mbgU8DV3ZckyagebG4C4D7quqcrutpW5JFSbZszm/C6EUf7++2qnZU1deratuq2oHRY/aGqjqm47Jak2TT5gUeSbIpcCjQ+3dKmSHmRE+ZE+ZEX5gTnTIjesycMCf6Ypo5MYhBUlU9B5wIXMPoxdN+UVWru62qPUkuBW4Ddk2yJsnxXdfUov2BYxlNl1c0p491XVSLtgZuTHIPo19qrquq3r+N5UC8C7glyUrgduA3VfW7jmsaDHPCnOgRc6K/zImODC0jwJwwJ7RATS0nUtXbF2iXJEmSJEnSBA1iR5IkSZIkSZLmz0GSJEmSJEmSxuIgSZIkSZIkSWNxkCRJkiRJkqSxOEiSpJYluTDJ2iQTefvNJNsnuTbJfUnuTbLDJNaVJHXDnJAkvZZZywnftU29lOQdwPXNxXcDzwOPNpefrqr9Wviei4ETq2oib4+a5ERGtV44ifXUnSQHAeuAi6pqzwms93vgrKq6LslmwAtV9fR815WGxJzQLDEnpNljTmiWzFpOOEhS7yU5HVhXVd9v+ftcDny7qlZOaL23ArdW1eJJrKduNVP+q1584k+yI3AusAh4Gvh8Vd0/xjp7AOdV1QHtVSsNizmhWWBOSLPLnNAsmKWc8NA2DU6Sdc3HDya5KcmvkzyY5OwkRye5Pcmq5oFJkkVJrkiyvDnt/yprbg7s9eKTfpIPJFnRnO5uPk+SrzRr3JPkjDm3/0xz3cokFwM0E+GHkixt/15RB84DTqqq9wOnAT8e83a7AE8kWdb8bH0vyYatVSkNkDmhGWFOSDPKnNCM6Cwn3vQGC5X6Zm9gd+Bx4EHg/KpamuRk4CTgFOBHwA+q6pYk2wPXNLeZawkw93jV04ATqurWZqvgM0kOBXYGlgIBrsxoi+K/gG8A+1XVY0nePmedO4ADgdsn2rU61fxM7AdcnuTFq9/SfO5TwJmvcrOHq+ojjJ63DwQWA/8Afg4cB1zQbtXSYJkTmjpzQlpQzAlNXdc54SBJQ7e8qh4BSPJX4Nrm+lXAwc35DwF7zHmAbpFks6paN2edrXnpmGmAW4FzklwCLKuqNc0T/6HA3c3XbMYoCPYGLq+qxwCq6vE566wFdpt/m5oxGwBPVNU+r/xEVS0Dlr3GbdcAK6rqQYAkvwL2xf8gSG0xJ9QFc0JaOMwJdaHTnPDQNg3ds3POvzDn8gu8NGjdANi3qvZpTtu84kkf4N/Axi9eqKqzgc8BmwC3JtmN0V8NvjNnnZ2q6vUerBs3a6tHqupJ4G9JjgTIyN5j3nw5sGWSRc3lQ4B7WyhT0og5oakzJ6QFxZzQ1HWdEw6SpNd3LaNtqQAk+Z+pL3AfsNOcr9mxqlZV1XcZPVB3Y7SF9bPNNkSSbJPkncANwJEZvTMEr9iKugsv3+KqBSjJpcBtwK5J1iQ5HjgaOD7JSmA1cMQ4a1XV84y2Ol+fZBWjXyh+2k7lksZkTmhezAmp98wJzcus5YSHtkmv70vAuUnuYfSYuRn44twvqKr7k7wtyeZV9RRwSpKDGf0lYjXw26p6NsnuwG3NttZ1wDFVtTrJWcBNSZ5ntFX1uGbp/YHTW+9Qraqqo/7Ppw5bz/WuA/Za/4okTZg5oXkxJ6TeMyc0L7OWE6mq9b2tpDmSfBl4qqrOn9B6i4FTq+rYSawnSeqWOSFJei3mhBYKD22TJucnvPwY6fnaCvjmBNeTJHXLnJAkvRZzQguCO5IkSZIkSZI0FnckSZIkSZIkaSwOkiRJkiRJkjQWB0mSJEmSJEkai4MkSZIkSZIkjcVBkiRJkiRJksbiIEmSJEmSJElj+S+7jmtcVPtm5gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", + "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", + " formatted_plot_data['rabi_rotations'],\n", + " formatted_plot_data['azimuthal_angles'],\n", + " formatted_plot_data['detuning_rotations'],\n", + " formatted_plot_data['times']\n", + ")\n", + "\n", + "# prepare the axes\n", + "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", + " 1, 3, figsize=(20,5))\n", + "\n", + "rabi_plot_axis.plot(times, rabi_rotations)\n", + "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "rabi_plot_axis.set_xlabel('Time (sec)')\n", + "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", + "\n", + "azimuth_plot_axis.plot(times, azimuthal_angles)\n", + "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "azimuth_plot_axis.set_xlabel('Time (sec)')\n", + "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", + "\n", + "detuning_plot_axis.plot(times, detuning_rotations)\n", + "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "detuning_plot_axis.set_xlabel('Time (sec)')\n", + "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", + "\n", + "plt.suptitle('Ramsey Sequence')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compiling and running the pograms\n", + "\n", + "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;1-qubit device in this case.\n", + "\n", + "NOTE: You will require ForestSDK to run the following segments. You need to start the the Quil Compiler and QVM in server mode. Execute the following commands in separate prompts.\n", + "\n", + "```\n", + "$ quilc -S\n", + "$ qvm -S\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "# create a noiseless quantum device with 1-qubit\n", + "quantum_device = get_qc(\"1q-qvm\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Compiling the Quadratic DDS Program\n", + "\n", + "Note that both DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 20]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", + "\n", + "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", + "\n", + "The `I()` in the compiled program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", + "\n", + "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", + "\n", + "At the end of each program, we place a `measurement` operator to read out the result." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DECLARE qubit-0 BIT[1]\n", + "RX(pi/2) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi/2) 0\n", + "MEASURE 0 qubit-0[0]\n", + "HALT\n", + "\n" + ] + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "##Compiling the quadratic program\n", + "executable_quadratic_program = quantum_device.compile(quadratic_program)\n", + "## print the compiled program\n", + "print(executable_quadratic_program.program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Compiling the Ramsey program\n", + "\n", + "Compiling the program for Ramsey sequence is similar." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DECLARE qubit-0 BIT[1]\n", + "RX(pi/2) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi/2) 0\n", + "MEASURE 0 qubit-0[0]\n", + "HALT\n", + "\n" + ] + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "\n", + "##Compiling the quadratic program\n", + "executable_ramsey_program = quantum_device.compile(ramsey_program)\n", + "## print the compiled program\n", + "print(executable_ramsey_program.program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here we count 100 `Id` operations, implementing a total delay of $100 \\times 50 ns = 5 \\mu s$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the programs using Pyquil's QVM\n", + "\n", + "Here, we will use the quantum device we created earlier to run the program. The experiment consists of `trials` repeats of the program on a qubit. Each run collects the state of the qubit as measurement. The result is displayed as a histogram. We here define small utility method to plot the trial results for QVM." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_trial_outcomes(trial_result, qubit = 0):\n", + " \"\"\"Plots the trial result as probabilities.\n", + " Parameters\n", + " ----------\n", + " trial_result : dict\n", + " A dict where the key is the target qubits and value is a numy array of size\n", + " containing outcome of each trial in computational basis.\n", + " qubit: int\n", + " An interger corresponding to the target qubit.\n", + " \"\"\"\n", + " \n", + " qubit_trial_result = trial_result[qubit]\n", + " \n", + " number_of_trials = qubit_trial_result.shape[0]\n", + " \n", + " outcome = np.array([number_of_trials-np.sum(qubit_trial_result), np.sum(qubit_trial_result)])\n", + " outcome_probabilities = outcome / number_of_trials\n", + " \n", + " ##plotting the outcome probabilities\n", + " #ax = plt.subplots(1,1)\n", + " #ax.bar([0, 1], outcome_probabilities)\n", + " #ax.xlabel('States')\n", + " #ax.xticks(ticks=[0, 1])\n", + " #ax.ylabel('Probabilities')\n", + " plt.bar(np.array([0, 1]), outcome_probabilities)\n", + " plt.xticks(np.array([0, 1]), [0, 1])\n", + " plt.ylabel('Probabilities')\n", + " plt.xlabel('States')\n", + " \n", + "'''\n", + "trials : int\n", + " An integer denoting the number of repeats of the program on quantum device\n", + "'''\n", + "trials=100" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "quadratic_result = quantum_device.run_and_measure(quadratic_program, trials=trials)\n", + "plot_trial_outcomes(quadratic_result)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAEEtJREFUeJzt3XuwnVV9xvHvQyICcmtNrEoSQiVqUeulR8A6o3jn0sKMWks6TsUypjeqlmqLVVHRmXqljg5VMwWh2HLxMm2qUbQUcLxgCWDRROkcqZagU4IiolQg9tc/9svq5nA4ex8879mB8/3MnDnvZe13//ZM5jxZa717vakqJEkC2G3SBUiSdh2GgiSpMRQkSY2hIElqDAVJUmMoSJIaQ0GS1BgKkqTGUJAkNcsnXcB8rVixotauXTvpMiTpfuXKK6+8qapWjmp3vwuFtWvXsmXLlkmXIUn3K0m+M047h48kSY2hIElqDAVJUmMoSJIaQ0GS1PQWCknOSnJjkq/fy/kkeV+S6STXJHlKX7VIksbTZ0/hbODIOc4fBazrfjYAH+ixFknSGHoLhar6PPCDOZocB/xdDVwO7J/kEX3VI0kabZJzCgcA1w/tb++OSZIm5H7xjeYkGxgMMbFmzZoJVyP1Z+0pn5p0CdqFffvtx/T+HpPsKdwArB7aX9Udu4eq2lhVU1U1tXLlyKU7JEn30SRDYRPwu91dSIcDt1TV9yZYjyQteb0NHyU5DzgCWJFkO/Am4EEAVfVBYDNwNDAN3Aa8vK9aJEnj6S0Uqmr9iPMF/HFf7y9Jmj+/0SxJagwFSVJjKEiSGkNBktQYCpKkxlCQJDWGgiSpMRQkSY2hIElqDAVJUmMoSJIaQ0GS1BgKkqTGUJAkNYaCJKkxFCRJjaEgSWoMBUlSYyhIkhpDQZLUGAqSpMZQkCQ1hoIkqTEUJEmNoSBJagwFSVJjKEiSGkNBktQYCpKkxlCQJDWGgiSpMRQkSU2voZDkyCTXJplOcsos59ckuSTJ1UmuSXJ0n/VIkubWWygkWQacARwFHAKsT3LIjGZvAC6sqicDxwN/01c9kqTR+uwpHApMV9V1VXUHcD5w3Iw2Bezbbe8HfLfHeiRJIyzv8doHANcP7W8HDpvR5s3AZ5P8CfAQ4Lk91iNJGmHSE83rgbOrahVwNHBuknvUlGRDki1JtuzYsWPRi5SkpaLPULgBWD20v6o7NuxE4EKAqvoysAewYuaFqmpjVU1V1dTKlSt7KleS1GcoXAGsS3JQkt0ZTCRvmtHmv4DnACT5FQahYFdAkiakt1Coqp3AScBFwDcY3GW0NclpSY7tmv0Z8Iok/w6cB5xQVdVXTZKkufU50UxVbQY2zzh26tD2NuDpfdYgSRrfpCeaJUm7EENBktQYCpKkxlCQJDWGgiSpMRQkSY2hIElqDAVJUmMoSJIaQ0GS1BgKkqTGUJAkNYaCJKkxFCRJjaEgSWoMBUlSYyhIkhpDQZLUGAqSpMZQkCQ1hoIkqTEUJEmNoSBJagwFSVIzVigkeWeSfZM8KMnFSXYkeWnfxUmSFte4PYXnV9WPgN8Avg0cDLy2r6IkSZMxbigs734fA3y0qm7pqR5J0gQtH90EgE8m+SbwP8AfJlkJ/LS/siRJkzBWT6GqTgF+HZiqqjuB24Dj+ixMkrT4xp1o3gv4I+AD3aFHAlN9FSVJmoxx5xQ+DNzBoLcAcAPwtl4qkiRNzLih8KiqeidwJ0BV3Qakt6okSRMxbijckWRPoACSPAq4vbeqJEkTMW4ovAn4DLA6yd8DFwN/PupFSY5Mcm2S6SSn3EublyTZlmRrkn8Yu3JJ0oIb65bUqvpckquAwxkMG72qqm6a6zVJlgFnAM8DtgNXJNlUVduG2qwDXgc8vapuTvKw+/g5JEkLYM6eQpLHdr+fAhwIfA/4LrCmOzaXQ4Hpqrququ4Azueet7G+Ajijqm4GqKob5/8RJEkLZVRP4WRgA/CeWc4V8Ow5XnsAcP3Q/nbgsBltHg2Q5IvAMuDNVfWZETVJknoyZyhU1YZu86iquts3mJPssUDvvw44AlgFfD7JE6rqhzPeawODcGLNmjUL8LaSpNmMO9H8pTGPDbsBWD20v6o7Nmw7sKmq7qyq/wT+g0FI3E1VbayqqaqaWrly5ZglS5Lma86eQpKHMxgG2jPJk/n/7ybsC+w14tpXAOuSHMQgDI4HfmdGm38E1gMfTrKCwXDSdfP6BJKkBTNqTuEFwAkM/pd/+tDxW4G/nOuFVbUzyUnARQzmC86qqq1JTgO2VNWm7tzzk2wDfga8tqq+f58+iSTp5zZqTuEc4JwkL6qqj8/34lW1Gdg849ipQ9vFYDL75PleW5K08EYNH720qj4CrE1yjz/cVXX6LC+TJN1PjRo+ekj3e+++C5EkTd6o4aMPdb/fsjjlSJImadTw0fvmOl9Vr1zYciRJkzRq+OjKRalCkrRLGOfuI0nSEjFq+Oi9VfXqJP9M9yyFYVV1bG+VSZIW3ajho3O73+/uuxBJ0uSNGj66svt9WZLdgccy6DFc2y2HLUl6ABnrITtJjgE+CHyLwfpHByX5/ar6dJ/FSZIW11ihwOB5Cs+qqmloz2j+FGAoSNIDyLhLZ996VyB0rmOwKJ4k6QFk1N1HL+w2tyTZDFzIYE7htxgsjS1JegAZNXz0m0Pb/w08s9veAezZS0WSpIkZdffRyxerEEnS5I1799EewInA44D2bOaq+r2e6pIkTcC4E83nAg9n8CS2yxg8ic2JZkl6gBk3FA6uqjcCP+nWQzoGOKy/siRJkzBuKNzZ/f5hkscD+wEP66ckSdKkjPvltY1JfgF4I7CJwZPY3thbVZKkiRgrFKrqb7vNy4Bf7q8cSdIkjTV8lOShSd6f5KokVyZ5b5KH9l2cJGlxjTuncD5wI/Ai4MXATcAFfRUlSZqMcecUHlFVbx3af1uS3+6jIEnS5IzbU/hskuOT7Nb9vAS4qM/CJEmLb9SCeLcyWAAvwKuBj3SndgN+DLym1+okSYtq1NpH+yxWIZKkyRt3ToEkxwLP6HYvrapP9lOSJGlSxr0l9e3Aq4Bt3c+rkvxVn4VJkhbfuD2Fo4EnVdX/AiQ5B7gaeF1fhUmSFt+4dx8B7D+0vd9CFyJJmrxxewp/BVyd5BIGdyI9Azilt6okSRMxsqeQJMAXgMOBTwAfB55WVSO/0ZzkyCTXJplOcq8hkuRFSSrJ1DxqlyQtsJE9haqqJJur6gkMVkgdS5JlwBnA84DtwBVJNlXVthnt9mEwif2VeVUuSVpw484pXJXkqfO89qHAdFVdV1V3MFg/6bhZ2r0VeAfw03leX5K0wMYNhcOAy5N8K8k1Sb6W5JoRrzkAuH5of3t3rEnyFGB1VX1q7IolSb0Zd6L5BQv9xkl2A04HThij7QZgA8CaNWsWuhRJUmfU2kd7AH8AHAx8DTizqnaOee0bgNVD+6u6Y3fZB3g8cOlgLpuHA5uSHFtVW4YvVFUbgY0AU1NTNeb7S5LmadTw0TnAFINAOAp4zzyufQWwLslBSXYHjmdoorqqbqmqFVW1tqrWApcD9wgESdLiGTV8dEh31xFJzgT+bdwLV9XOJCcxWGJ7GXBWVW1NchqwparGvpNJkrQ4RoXCnXdtdH/k53XxqtoMbJ5x7NR7aXvEvC4uSVpwo0LhiUl+1G0H2LPbD4OvMOzba3WSpEU16nkKyxarEEnS5M1nQTxJ0gOcoSBJagwFSVJjKEiSGkNBktQYCpKkxlCQJDWGgiSpMRQkSY2hIElqDAVJUmMoSJIaQ0GS1BgKkqTGUJAkNYaCJKkxFCRJjaEgSWoMBUlSYyhIkhpDQZLUGAqSpMZQkCQ1hoIkqTEUJEmNoSBJagwFSVJjKEiSGkNBktQYCpKkxlCQJDW9hkKSI5Ncm2Q6ySmznD85ybYk1yS5OMmBfdYjSZpbb6GQZBlwBnAUcAiwPskhM5pdDUxV1a8CHwPe2Vc9kqTR+uwpHApMV9V1VXUHcD5w3HCDqrqkqm7rdi8HVvVYjyRphD5D4QDg+qH97d2xe3Mi8OnZTiTZkGRLki07duxYwBIlScN2iYnmJC8FpoB3zXa+qjZW1VRVTa1cuXJxi5OkJWR5j9e+AVg9tL+qO3Y3SZ4LvB54ZlXd3mM9kqQR+uwpXAGsS3JQkt2B44FNww2SPBn4EHBsVd3YYy2SpDH0FgpVtRM4CbgI+AZwYVVtTXJakmO7Zu8C9gY+muSrSTbdy+UkSYugz+EjqmozsHnGsVOHtp/b5/tLkuZnl5holiTtGgwFSVJjKEiSGkNBktQYCpKkxlCQJDWGgiSpMRQkSY2hIElqDAVJUmMoSJIaQ0GS1BgKkqTGUJAkNYaCJKkxFCRJjaEgSWoMBUlSYyhIkhpDQZLUGAqSpMZQkCQ1hoIkqTEUJEmNoSBJagwFSVJjKEiSGkNBktQYCpKkxlCQJDWGgiSpMRQkSU2voZDkyCTXJplOcsos5x+c5ILu/FeSrO2zHknS3HoLhSTLgDOAo4BDgPVJDpnR7ETg5qo6GPhr4B191SNJGq3PnsKhwHRVXVdVdwDnA8fNaHMccE63/THgOUnSY02SpDn0GQoHANcP7W/vjs3apqp2ArcAD+2xJknSHJZPuoBxJNkAbOh2f5zk2knW8wCyArhp0kVIc/Df6JD8fAPsB47TqM9QuAFYPbS/qjs2W5vtSZYD+wHfn3mhqtoIbOypziUryZaqmpp0HdK98d/o4utz+OgKYF2Sg5LsDhwPbJrRZhPwsm77xcC/VlX1WJMkaQ699RSqameSk4CLgGXAWVW1NclpwJaq2gScCZybZBr4AYPgkCRNSPyP+dKVZEM3NCftkvw3uvgMBUlS4zIXkqTGUFiCRi0/Ik1akrOS3Jjk65OuZakxFJaYMZcfkSbtbODISRexFBkKS884y49IE1VVn2dwR6IWmaGw9Iyz/IikJcpQkCQ1hsLSM87yI5KWKENh6Rln+RFJS5ShsMR0S5TftfzIN4ALq2rrZKuS7i7JecCXgcck2Z7kxEnXtFT4jWZJUmNPQZLUGAqSpMZQkCQ1hoIkqTEUJEmNoSDNkOT1SbYmuSbJV5McluTVSfYa47VjtZN2Vd6SKg1J8jTgdOCIqro9yQpgd+BLwFRV3TTi9d8ep520q7KnIN3dI4Cbqup2gO6P+4uBRwKXJLkEIMkHkmzpehRv6Y69cpZ2z0/y5SRXJflokr27429Psq3rjbx78T+mNDt7CtKQ7o/2F4C9gH8BLqiqy2b2AJL8YlX9oHs+xcXAK6vqmuF2XS/jE8BRVfWTJH8BPJjB8yy+BDy2qirJ/lX1w8X+rNJs7ClIQ6rqx8CvARuAHcAFSU6YpelLklwFXA08jsEDi2Y6vDv+xSRfBV4GHAjcAvwUODPJC4HbFvpzSPfV8kkXIO1qqupnwKXApUm+xuCPeZPkIOA1wFOr6uYkZwN7zHKpAJ+rqvX3OJEcCjyHwdDUScCzF/IzSPeVPQVpSJLHJFk3dOhJwHeAW4F9umP7Aj8BbknySwwebXqX4XaXA09PcnB37YckeXQ3RLVfVW0G/hR4Ym8fSJonewrS3e0NvD/J/sBOYJrBUNJ64DNJvltVz0pyNfBNBk+x++LQ6zfOaHcCcF6SB3fn38AgOP4pyR4MehMnL8YHk8bhRLMkqXH4SJLUGAqSpMZQkCQ1hoIkqTEUJEmNoSBJagwFSVJjKEiSmv8DsR4BO1g0D8wAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "ramsey_result = quantum_device.run_and_measure(ramsey_program, trials=trials)\n", + "plot_trial_outcomes(ramsey_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the programs with noise\n", + "\n", + "We use the same DDS and program defined above. However, in this case, we define a dephasing noise for the identity gates through appropriate Kraus Operator with specific dephasing probability. We introduce the noise to the programs. We then run the programs with noisy gates on the same device created above. Outcome of these experiments are plotted and compared with that obtained from ideal gates." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# define a one-shot dephasing probability\n", + "p = 0.02\n", + "\n", + "# define a dephasing with probability p\n", + "kraus_operators = dephasing_kraus_map(p=p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Running the quadratic sequence program with noisy identity gates\n", + "\n", + "Here we will introduce the noisy identity gates to the quadratic sequence program, run it on the virtual device and plot the outcome." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "#add noise to the identity gates\n", + "noisy_quadratic_program = quadratic_program.define_noisy_gate(\"I\", [1], kraus_operators)\n", + "#obtain the noisy result\n", + "noisy_quadratic_result = quantum_device.run_and_measure(noisy_quadratic_program, trials=trials)\n", + "#plot the noisy results\n", + "plot_trial_outcomes(noisy_quadratic_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Running the ramsey sequence program with noisy identity gates\n", + "\n", + "Here we will introduce the noisy identity gates to the ramsey sequence program, run it on the virtual device and plot the outcome." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "#add noise to the identity gates\n", + "noisy_ramsey_program = ramsey_program.define_noisy_gate(\"I\", target_qubits, kraus_operators)\n", + "#obtain the noisy result\n", + "noisy_ramsey_result = quantum_device.run_and_measure(noisy_ramsey_program, trials=trials)\n", + "#plot the noisy results\n", + "plot_trial_outcomes(noisy_ramsey_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reducing Errors by Increasing the Coherence Time\n", + "\n", + "In the ideal noiseless simulator, both the Ramsey DDS and Quadratic DDS produced exactly the same outcome, the $|1 \\rangle$ state with probability 1. However, in the case of noisy channels, we can see a marked difference. The Quadratic DDS produced a probability distribution closer to the expected outcome. This is because the Quadratic DDS is able to cancel the effects of magnetic noise in the environment - extending the [T2 time](https://en.wikipedia.org/wiki/Spin–spin_relaxation), and effectively increasing the coherence of the qubit." + ] + } + ], + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/qctrlopencontrols/__init__.py b/qctrlopencontrols/__init__.py index e586f815..de58ca4a 100644 --- a/qctrlopencontrols/__init__.py +++ b/qctrlopencontrols/__init__.py @@ -25,3 +25,4 @@ from .qiskit import convert_dds_to_quantum_circuit from .cirq import (convert_dds_to_cirq_circuit, convert_dds_to_cirq_schedule) +from .pyquil import convert_dds_to_program diff --git a/qctrlopencontrols/pyquil/__init__.py b/qctrlopencontrols/pyquil/__init__.py new file mode 100644 index 00000000..2392f289 --- /dev/null +++ b/qctrlopencontrols/pyquil/__init__.py @@ -0,0 +1,21 @@ +# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +============= +pyquil module +============= +""" + +from .program import convert_dds_to_program diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py new file mode 100644 index 00000000..68901d04 --- /dev/null +++ b/qctrlopencontrols/pyquil/program.py @@ -0,0 +1,209 @@ +# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +============== +pyquil.program +============== +""" + +import numpy as np + +from pyquil import Program +from pyquil.gates import I, RX, RY, RZ, MEASURE +from pyquil.quil import Pragma + +from qctrlopencontrols.dynamic_decoupling_sequences import DynamicDecouplingSequence +from qctrlopencontrols.exceptions import ArgumentsValueError +from qctrlopencontrols.globals import ( + FIX_DURATION_UNITARY, INSTANT_UNITARY) + + +def convert_dds_to_program( + dynamic_decoupling_sequence, + target_qubits=None, + gate_time=0.1, + add_measurement=True, + algorithm=INSTANT_UNITARY): + + """Converts a Dynamic Decoupling Sequence into quantum program + as defined in Pyquil + + Parameters + ---------- + dynamic_decoupling_sequence : DynamicDecouplingSequence + The dynamic decoupling sequence + target_qubits : list, optional + List of integers specifying target qubits for the sequence operation; + defaults to None + gate_time : float, optional + Time (in seconds) delay introduced by a gate; defaults to 0.1 + add_measurement : bool, optional + If True, the circuit contains a measurement operation for each of the + target qubits and a set of ClassicalRegister objects created with length + equal to `len(target_qubits)` + algorithm : str, optional + One of 'fixed duration unitary' or 'instant unitary'; In the case of + 'fixed duration unitary', the sequence operations are assumed to be + taking the amount of gate_time while 'instant unitary' assumes the sequence + operations are instantaneous (and hence does not contribute to the delay between + offsets). Defaults to 'instant unitary'. + + Returns + ------- + pyquil.Program + The Pyquil program containting gates specified by the rotations of + dynamic decoupling sequence + + + Raises + ------ + ArgumentsValueError + If any of the input parameters are invalid + + Notes + ----- + + Dynamic Decoupling Sequences (DDS) consist of idealized pulse operation. Theoretically, + these operations (pi-pulses in X,Y or Z) occur instantaneously. However, in practice, + pulses require time. Therefore, this method of converting an idealized sequence + results to a circuit that is only an approximate implementation of the idealized sequence. + + In idealized definition of DDS, `offsets` represents the instances within sequence + `duration` where a pulse occurs instantaneously. A series of appropriate gatges + is placed in order to represent these pulses. The `gaps` or idle time in between active + pulses are filled up with `identity` gates. Each identity gate introduces a delay of + `gate_time`. In this implementation, the number of identity gates is determined by + :math:`np.int(np.floor(offset_distance / gate_time))`. As a consequence, the duration of + the real-circuit is :math:`gate_time \\times number_of_identity_gates + + pulse_gate_time \\times number_of_pulses`. + + Q-CTRL Open Controls support operation resulting in rotation around at most one axis at + any offset. + """ + + if dynamic_decoupling_sequence is None: + raise ArgumentsValueError('No dynamic decoupling sequence provided.', + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence}) + + if not isinstance(dynamic_decoupling_sequence, DynamicDecouplingSequence): + raise ArgumentsValueError('Dynamical decoupling sequence is not recognized.' + 'Expected DynamicDecouplingSequence instance', + {'type(dynamic_decoupling_sequence)': + type(dynamic_decoupling_sequence)}) + + if target_qubits is None: + target_qubits = [0] + + if gate_time <= 0: + raise ArgumentsValueError( + 'Time delay of identity gate must be greater than zero.', + {'gate_time': gate_time}) + + if np.any(target_qubits) < 0: + raise ArgumentsValueError( + 'Every target qubits index must be positive.', + {'target_qubits': target_qubits}) + + if algorithm not in [FIX_DURATION_UNITARY, INSTANT_UNITARY]: + raise ArgumentsValueError('Algorithm must be one of {} or {}'.format( + INSTANT_UNITARY, FIX_DURATION_UNITARY), {'algorithm': algorithm}) + + unitary_time = 0. + if algorithm == FIX_DURATION_UNITARY: + unitary_time = gate_time + + rabi_rotations = dynamic_decoupling_sequence.rabi_rotations + azimuthal_angles = dynamic_decoupling_sequence.azimuthal_angles + detuning_rotations = dynamic_decoupling_sequence.detuning_rotations + + if len(rabi_rotations.shape) == 1: + rabi_rotations = rabi_rotations[np.newaxis, :] + if len(azimuthal_angles.shape) == 1: + azimuthal_angles = azimuthal_angles[np.newaxis, :] + if len(detuning_rotations.shape) == 1: + detuning_rotations = detuning_rotations[np.newaxis, :] + + operations = np.vstack((rabi_rotations, azimuthal_angles, detuning_rotations)) + offsets = dynamic_decoupling_sequence.offsets + + time_covered = 0 + program = Program() + program += Pragma('PRESERVE_BLOCK') + + for operation_idx in range(operations.shape[1]): + + offset_distance = offsets[operation_idx] - time_covered + + if np.isclose(offset_distance, 0.0): + offset_distance = 0.0 + + if offset_distance < 0: + raise ArgumentsValueError("Offsets cannot be placed properly", + {'sequence_operations': operations}) + + if offset_distance > 0: + while (time_covered+gate_time) <= offsets[operation_idx]: + for qubit in target_qubits: + program += I(qubit) + time_covered += gate_time + + rabi_rotation = operations[0, operation_idx] + azimuthal_angle = operations[1, operation_idx] + x_rotation = rabi_rotation * np.cos(azimuthal_angle) + y_rotation = rabi_rotation * np.sin(azimuthal_angle) + z_rotation = operations[2, operation_idx] + + rotations = np.array([x_rotation, y_rotation, z_rotation]) + zero_pulses = np.isclose(rotations, 0.0).astype(np.int) + nonzero_pulse_counts = 3 - np.sum(zero_pulses) + if nonzero_pulse_counts > 1: + raise ArgumentsValueError( + 'Open Controls support a sequence with one ' + 'valid pulse at any offset. Found sequence ' + 'with multiple rotation operations at an offset.', + {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), + 'offset': dynamic_decoupling_sequence.offsets[operation_idx], + 'rabi_rotation': dynamic_decoupling_sequence.rabi_rotations[ + operation_idx], + 'azimuthal_angle': dynamic_decoupling_sequence.azimuthal_angles[ + operation_idx], + 'detuning_rotaion': dynamic_decoupling_sequence.detuning_rotations[ + operation_idx]} + ) + + for qubit in target_qubits: + if nonzero_pulse_counts == 0: + program += I(qubit) + else: + if not np.isclose(rotations[0], 0.0): + program += RX(rotations[0], qubit) + elif not np.isclose(rotations[1], 0.0): + program += RY(rotations[1], qubit) + elif not np.isclose(rotations[2], 0.): + program += RZ(rotations[2], qubit) + + if np.isclose(np.sum(rotations), 0.0): + time_covered = offsets[operation_idx] + else: + time_covered = offsets[operation_idx] + unitary_time + + if add_measurement: + for qubit in target_qubits: + bit_name = 'qubit-{}'.format(qubit) + measurement_bit = program.declare(bit_name, 'BIT', 1) + program += MEASURE(qubit, measurement_bit) + program += Pragma('END_PRESERVE_BLOCK') + + return program diff --git a/setup.py b/setup.py index ee781d59..23a593e0 100644 --- a/setup.py +++ b/setup.py @@ -47,7 +47,7 @@ def main(): tests_require=['pytest'], install_requires=['numpy', 'scipy', 'pytest', 'nbval', 'qiskit-terra', 'qiskit-ibmq-provider', - 'cirq'], + 'cirq', 'pyquil'], author='Q-CTRL', author_email='support@q-ctrl.com', description='Q-CTRL Open Controls', diff --git a/tests/test_cirq_circuits.py b/tests/test_cirq_sequence.py similarity index 100% rename from tests/test_cirq_circuits.py rename to tests/test_cirq_sequence.py diff --git a/tests/test_pyquil_sequence.py b/tests/test_pyquil_sequence.py new file mode 100644 index 00000000..12ab78f9 --- /dev/null +++ b/tests/test_pyquil_sequence.py @@ -0,0 +1,67 @@ +# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +=================================== +Tests converstion to Pyquil program +=================================== +""" + +import numpy as np + +from pyquil.gates import RX, RY, RZ, I +from pyquil.quil import Pragma + +from qctrlopencontrols import ( + DynamicDecouplingSequence, + convert_dds_to_program) + +def test_pyquil_program(): + + """Tests if the Dynamic Decoupling Sequence gives rise to Identity + operation in Qiskit + """ + _duration = 5e-6 + _offsets = [0, 1e-6, 2.5e-6, 4e-6, 5e-6] + _rabi_rotations = [np.pi / 2, np.pi / 2, np.pi, 0, np.pi / 2] + _azimuthal_angles = [0, 0, np.pi / 2, 0, 0] + _detuning_rotations = [0, 0, 0, np.pi, 0] + + sequence = DynamicDecouplingSequence( + duration=_duration, + offsets=_offsets, + rabi_rotations=_rabi_rotations, + azimuthal_angles=_azimuthal_angles, + detuning_rotations=_detuning_rotations) + + program = convert_dds_to_program( + sequence, + [0], + gate_time=1e-6) + + assert len(program) == 13 + assert program[0] == Pragma("PRESERVE_BLOCK") + assert program[-1] == Pragma("END_PRESERVE_BLOCK") + assert program[1] == RX(np.pi/2, 0) + assert program[2] == I(0) + assert program[3] == RX(np.pi / 2, 0) + assert program[4] == I(0) + assert program[5] == RY(np.pi, 0) + assert program[6] == I(0) + assert program[7] == RZ(np.pi, 0) + assert program[8] == I(0) + assert program[9] == RX(np.pi / 2, 0) + +if __name__ == '__main__': + pass From b9505f5cb028e3430e6d1aaeb308bc1c258c7055 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Wed, 12 Jun 2019 14:21:04 +1000 Subject: [PATCH 02/16] # This is a combination of 15 commits. # This is the 1st commit message: starting pyquil support # This is the commit message #1: pyquil support added # This is the commit message #2: first version of pyquil notebook added # This is the commit message #3: pyquil dependency added to setup # This is the commit message #4: trying gcc install for pyquil # This is the commit message #5: replacing gcc install with build-essential # This is the commit message #6: forcing yes to install anything # This is the commit message #7: ignoring blocks in pyquil notebook for tests # This is the commit message #8: linted; unnecessary import removed from notebook # This is the commit message #9: removed all references of circuits and replaced those with programs; pyquil removed from method names # This is the commit message #10: notebook rerun after changes # This is the commit message #11: pyquil program conversion removes unnecessary method # This is the commit message #12: Public methods are bundled as __all__; changed ported over to notebooks; base object removed; repr method created # This is the commit message #13: additional error handling for new repr method # This is the commit message #14: repr method updated with class instance as input --- examples/export_a_dds_to_qiskit.ipynb | 6 +- qctrlopencontrols/__init__.py | 27 ++- qctrlopencontrols/base/__init__.py | 4 +- qctrlopencontrols/base/qctrl_object.py | 107 --------- qctrlopencontrols/base/utils.py | 77 +++++++ qctrlopencontrols/cirq/__init__.py | 3 + qctrlopencontrols/driven_controls/__init__.py | 31 ++- .../driven_controls/constants.py | 4 +- .../driven_controls/driven_control.py | 42 +++- .../driven_controls/predefined.py | 36 +-- .../dynamic_decoupling_sequences/__init__.py | 14 ++ .../dynamic_decoupling_sequences/constants.py | 6 +- .../driven_controls.py | 6 +- .../dynamic_decoupling_sequence.py | 54 +++-- .../predefined.py | 102 ++++----- qctrlopencontrols/exceptions/__init__.py | 2 + qctrlopencontrols/globals/__init__.py | 3 + qctrlopencontrols/qiskit/__init__.py | 4 +- qctrlopencontrols/qiskit/quantum_circuit.py | 2 +- tests/test_driven_controls.py | 2 +- tests/test_dynamical_decoupling.py | 11 +- tests/test_predefined_driven_controls.py | 71 +++--- tests/test_predefined_dynamical_decoupling.py | 209 ++++++++++-------- tests/test_qctrl_object.py | 66 ------ tests/test_qiskit_sequence.py | 4 +- 25 files changed, 473 insertions(+), 420 deletions(-) delete mode 100644 qctrlopencontrols/base/qctrl_object.py create mode 100644 qctrlopencontrols/base/utils.py delete mode 100644 tests/test_qctrl_object.py diff --git a/examples/export_a_dds_to_qiskit.ipynb b/examples/export_a_dds_to_qiskit.ipynb index a5c254fd..7b07491a 100755 --- a/examples/export_a_dds_to_qiskit.ipynb +++ b/examples/export_a_dds_to_qiskit.ipynb @@ -31,7 +31,7 @@ "from matplotlib.gridspec import GridSpec\n", "\n", "#Q-CTRL Open Controls\n", - "from qctrlopencontrols import new_predefined_dds, convert_dds_to_quantum_circuit\n", + "from qctrlopencontrols import new_predefined_dds, convert_dds_to_qiskit_quantum_circuit\n", "\n", "#Qiskit\n", "##To define a backend (simulated or real)\n", @@ -166,7 +166,7 @@ "\n", "## convert the quadratic sequence to QuantumCircuit\n", "\n", - "quadratic_quantum_circuit = convert_dds_to_quantum_circuit(\n", + "quadratic_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(\n", " dynamic_decoupling_sequence=quadratic_sequence,\n", " target_qubits=target_qubits,\n", " gate_time=gate_time,\n", @@ -176,7 +176,7 @@ "\n", "## convert the ramsey sequence to QuantumCircuit\n", "circuit_name = 'ramsey-sequence-circuit'\n", - "ramsey_quantum_circuit = convert_dds_to_quantum_circuit(\n", + "ramsey_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(\n", " dynamic_decoupling_sequence=ramsey_sequence,\n", " target_qubits=target_qubits,\n", " gate_time=gate_time,\n", diff --git a/qctrlopencontrols/__init__.py b/qctrlopencontrols/__init__.py index de58ca4a..9061dd4d 100644 --- a/qctrlopencontrols/__init__.py +++ b/qctrlopencontrols/__init__.py @@ -14,15 +14,24 @@ """ ================= -qcrtlopencontrols +qctrlopencontrols ================= """ -from .dynamic_decoupling_sequences import (DynamicDecouplingSequence, - new_predefined_dds, - convert_dds_to_driven_control) -from .driven_controls import DrivenControl, new_predefined_driven_control -from .qiskit import convert_dds_to_quantum_circuit -from .cirq import (convert_dds_to_cirq_circuit, - convert_dds_to_cirq_schedule) -from .pyquil import convert_dds_to_program +from . import dynamic_decoupling_sequences +from .dynamic_decoupling_sequences import * +from . import driven_controls +from .driven_controls import * +from . import qiskit +from .qiskit import * +from . import cirq +from .cirq import * +from . import pyquil +from .pyquil import * + +__all__ = [] +__all__.extend(dynamic_decoupling_sequences.__all__) +__all__.extend(driven_controls.__all__) +__all__.extend(qiskit.__all__) +__all__.extend(cirq.__all__) +__all__.extend(pyquil.__all__) diff --git a/qctrlopencontrols/base/__init__.py b/qctrlopencontrols/base/__init__.py index 705fccab..68a2205d 100644 --- a/qctrlopencontrols/base/__init__.py +++ b/qctrlopencontrols/base/__init__.py @@ -18,4 +18,6 @@ =========== """ -from .qctrl_object import QctrlObject +from .utils import create_repr_from_attributes + +__all__ = ['create_repr_from_attributes'] diff --git a/qctrlopencontrols/base/qctrl_object.py b/qctrlopencontrols/base/qctrl_object.py deleted file mode 100644 index baf276a7..00000000 --- a/qctrlopencontrols/base/qctrl_object.py +++ /dev/null @@ -1,107 +0,0 @@ -# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -================= -base.qctrl_object -================= -""" - -from qctrlopencontrols.exceptions import ArgumentsValueError - - -class QctrlObject(object): - """Base class for all classes in QCtrl library. - - Parameters - ---------- - base_attributes : list, optional - List of names of attributes. Defaults to None - - Raises - ------ - ArgumentsValueError - If base_attributes is not list type or empty list - If any of the base_attributes is not str type - - Notes - ----- - If the base_attributes is None, __repr__ and __str__ - return a default string "No attributes provided for object - of class self.__class__.__name__" - """ - - def __init__(self, base_attributes=None): - - self.base_attributes = base_attributes - - if self.base_attributes is not None: - - if not isinstance(base_attributes, list): - - raise ArgumentsValueError('Attributes must be provided as a list object', - {'base_attributes': self.base_attributes}, - extras={'base_attributes_type': type(base_attributes)}) - - if not self.base_attributes: - raise ArgumentsValueError('No attributes provided', - {'base_attributes': self.base_attributes}) - - for attribute in self.base_attributes: - - if not isinstance(attribute, str): - raise ArgumentsValueError('Each attribute must be a string. Found ' - '{0} type.'.format(type(attribute)), - {'attribute': attribute, - 'attribute_type': type(attribute)}, - extras={'base_attributes': self.base_attributes}) - - def __repr__(self): - """The returned string looks like a valid Python expression that could be used - to recreate the object, including default arguments. - - - Returns - ------- - str - String representation of the object including the values of the arguments. - However, if the base_attributes is None, return a fixed string "No attributes - provided for object of class self.__class__.__name__" - """ - - if self.base_attributes is None: - - return "No attributes provided for object of class {0.__class__.__name__!s}".format( - self) - - repr_string = '{0.__class__.__name__!s}('.format(self) - - attributes_string = ','.join('{0}={1}'.format(attribute, - repr(getattr(self, attribute))) - for attribute in self.base_attributes) - repr_string += attributes_string - repr_string += ')' - - return repr_string - - def __str__(self): - """Returns a string representation of the object. - - Returns - ------- - str - The object definition as a string - """ - - return str(self.__repr__()) diff --git a/qctrlopencontrols/base/utils.py b/qctrlopencontrols/base/utils.py new file mode 100644 index 00000000..34a9f275 --- /dev/null +++ b/qctrlopencontrols/base/utils.py @@ -0,0 +1,77 @@ +# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +========== +base.utils +========== +""" + +from qctrlopencontrols.exceptions import ArgumentsValueError + + +def create_repr_from_attributes(class_instance=None, attributes=None): + + """Returns a string representation of an object + + Parameters + ---------- + class_instance : object, optional + The instance of a class (object)l defaults to None + attributes : list, optional + A list of string where each entry is the name of the attribute to collect + from the class instance. + + Returns + ------- + str + A string representing the attributes; If no attribute is provided + a constant string is returned + 'No attributes provided for object of class {0.__class__.__name__}". + format(class_instance)' + + Raises + ------ + ArgumentsValueError + If class name is not a string or any of the attribute name is not string type + """ + + if class_instance is None: + raise ArgumentsValueError('Class instance must be a valid object.', + {'class_instance': class_instance}) + + class_name = '{0.__class__.__name__}'.format(class_instance) + + if attributes is None: + raise ArgumentsValueError('Attributes must be a list of string', + {'attributes': attributes}) + + if not attributes: + return "No attributes provided for object of class {0}".format(class_name) + + for attribute in attributes: + if not isinstance(attribute, str): + raise ArgumentsValueError('Each attribute name must be a string. Found ' + '{0} type.'.format(type(attribute)), + {'attribute': attribute, + 'type(attribute)': type(attribute)}) + + repr_string = '{0}('.format(class_name) + attributes_string = ','.join('{0}={1}'.format(attribute, + repr(getattr(class_instance, attribute))) + for attribute in attributes) + repr_string += attributes_string + repr_string += ')' + + return repr_string diff --git a/qctrlopencontrols/cirq/__init__.py b/qctrlopencontrols/cirq/__init__.py index b003e992..524f0c0d 100644 --- a/qctrlopencontrols/cirq/__init__.py +++ b/qctrlopencontrols/cirq/__init__.py @@ -20,3 +20,6 @@ from .circuit import convert_dds_to_cirq_circuit from .schedule import convert_dds_to_cirq_schedule + +__all__ = ['convert_dds_to_cirq_circuit', + 'convert_dds_to_cirq_schedule'] diff --git a/qctrlopencontrols/driven_controls/__init__.py b/qctrlopencontrols/driven_controls/__init__.py index 779ff29a..c74d48d7 100644 --- a/qctrlopencontrols/driven_controls/__init__.py +++ b/qctrlopencontrols/driven_controls/__init__.py @@ -13,9 +13,9 @@ # limitations under the License. """ -============= +====================== driven_controls module -============= +====================== """ from .driven_control import DrivenControl @@ -31,12 +31,21 @@ SCROFULOUS, CORPSE_IN_SCROFULOUS) -from .predefined import ( - new_predefined_driven_control, - new_primitive_control, new_wimperis_1_control, new_solovay_kitaev_1_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control, - new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control, - new_walsh_amplitude_modulated_filter_1_control, - new_corpse_in_scrofulous_control) +from .predefined import new_predefined_driven_control + +__all__ = ['BB1', + 'CORPSE', + 'CORPSE_IN_BB1', + 'CORPSE_IN_SCROFULOUS', + 'CORPSE_IN_SK1', + 'LOWER_BOUND_DURATION', + 'PRIMITIVE', + 'SCROFULOUS', + 'SK1', + 'UPPER_BOUND_DETUNING_RATE', + 'UPPER_BOUND_DURATION', + 'UPPER_BOUND_RABI_RATE', + 'UPPER_BOUND_SEGMENTS', + 'WAMF1', + 'DrivenControl', + 'new_predefined_driven_control'] diff --git a/qctrlopencontrols/driven_controls/constants.py b/qctrlopencontrols/driven_controls/constants.py index 5ef657a8..6952a751 100644 --- a/qctrlopencontrols/driven_controls/constants.py +++ b/qctrlopencontrols/driven_controls/constants.py @@ -13,9 +13,9 @@ # limitations under the License. """ -================ +========================== driven_controls.constants -================ +========================== """ #maximum and minimum values diff --git a/qctrlopencontrols/driven_controls/driven_control.py b/qctrlopencontrols/driven_controls/driven_control.py index 874de8b6..222a346b 100644 --- a/qctrlopencontrols/driven_controls/driven_control.py +++ b/qctrlopencontrols/driven_controls/driven_control.py @@ -21,7 +21,7 @@ import numpy as np from qctrlopencontrols.exceptions import ArgumentsValueError -from qctrlopencontrols.base import QctrlObject +from qctrlopencontrols.base import create_repr_from_attributes from qctrlopencontrols.globals import ( QCTRL_EXPANDED, CSV, JSON, CARTESIAN, CYLINDRICAL) @@ -31,7 +31,7 @@ UPPER_BOUND_DURATION, LOWER_BOUND_DURATION) -class DrivenControl(QctrlObject): #pylint: disable=too-few-public-methods +class DrivenControl(object): #pylint: disable=too-few-public-methods """ Creates a driven control. A driven is a set of segments made up of amplitude vectors and corresponding durations. @@ -136,17 +136,12 @@ def __init__(self, + ' than zero.', {'durations': self.durations}) - self.number_of_segments = rabi_rates.shape[0] if self.number_of_segments > UPPER_BOUND_SEGMENTS: raise ArgumentsValueError( 'The number of segments must be smaller than the upper bound:' + str(UPPER_BOUND_SEGMENTS), {'number_of_segments': self.number_of_segments}) - super(DrivenControl, self).__init__( - base_attributes=['rabi_rates', 'azimuthal_angles', 'detunings', - 'durations', 'name']) - if self.maximum_rabi_rate > UPPER_BOUND_RABI_RATE: raise ArgumentsValueError( 'Maximum rabi rate of segments must be smaller than the upper bound: ' @@ -169,6 +164,19 @@ def __init__(self, + str(LOWER_BOUND_DURATION), {'minimum_duration': self.minimum_duration}) + @property + def number_of_segments(self): + + """Returns the number of segments + + Returns + ------- + int + The number of segments in the driven control + """ + + return self.rabi_rates.shape[0] + @property def maximum_rabi_rate(self): """Returns the maximum rabi rate of the control @@ -594,6 +602,26 @@ def __str__(self): return driven_control_string + def __repr__(self): + + """Returns a string representation for the object. The returned string looks like a valid + Python expression that could be used to recreate the object, including default arguments. + + Returns + ------- + str + String representation of the object including the values of the arguments. + """ + + attributes = [ + 'rabi_rates', + 'azimuthal_angles', + 'detunings', + 'durations', + 'name'] + + return create_repr_from_attributes(self, attributes) + if __name__ == '__main__': pass diff --git a/qctrlopencontrols/driven_controls/predefined.py b/qctrlopencontrols/driven_controls/predefined.py index c47d9b6e..748f33be 100644 --- a/qctrlopencontrols/driven_controls/predefined.py +++ b/qctrlopencontrols/driven_controls/predefined.py @@ -73,30 +73,30 @@ def new_predefined_driven_control( # Forced to import here to avoid cyclic imports, need to review # Raise error if the input driven_control_type is not known if scheme == PRIMITIVE: - driven_control = new_primitive_control(**kwargs) + driven_control = _new_primitive_control(**kwargs) elif scheme == BB1: - driven_control = new_wimperis_1_control(**kwargs) + driven_control = _new_wimperis_1_control(**kwargs) elif scheme == SK1: - driven_control = new_solovay_kitaev_1_control(**kwargs) + driven_control = _new_solovay_kitaev_1_control(**kwargs) elif scheme == WAMF1: - driven_control = new_walsh_amplitude_modulated_filter_1_control(**kwargs) + driven_control = _new_walsh_amplitude_modulated_filter_1_control(**kwargs) elif scheme == CORPSE: - driven_control = new_compensating_for_off_resonance_with_a_pulse_sequence_control( + driven_control = _new_compensating_for_off_resonance_with_a_pulse_sequence_control( **kwargs) elif scheme == CORPSE_IN_BB1: driven_control = \ - new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( + _new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( **kwargs) elif scheme == \ CORPSE_IN_SK1: driven_control = \ - new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( + _new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( **kwargs) elif scheme == SCROFULOUS: driven_control = \ - new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control(**kwargs) + _new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control(**kwargs) elif scheme == CORPSE_IN_SCROFULOUS: - driven_control = new_corpse_in_scrofulous_control(**kwargs) + driven_control = _new_corpse_in_scrofulous_control(**kwargs) else: raise ArgumentsValueError( 'Unknown predefined pulse type. See help(new_predefined_driven_control) to display all' @@ -204,7 +204,7 @@ def _derive_segments(angles, amplitude=2. * np.pi): return segments -def new_primitive_control( +def _new_primitive_control( rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -240,7 +240,7 @@ def new_primitive_control( **kwargs) -def new_wimperis_1_control( +def _new_wimperis_1_control( rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -285,7 +285,7 @@ def new_wimperis_1_control( durations=durations, **kwargs) -def new_solovay_kitaev_1_control( +def _new_solovay_kitaev_1_control( rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -330,7 +330,7 @@ def new_solovay_kitaev_1_control( **kwargs) -def new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( # pylint: disable=invalid-name +def _new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -410,7 +410,7 @@ def degrees_to_radians(angle_in_degrees): **kwargs) -def new_compensating_for_off_resonance_with_a_pulse_sequence_control( # pylint: disable=invalid-name +def _new_compensating_for_off_resonance_with_a_pulse_sequence_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -455,7 +455,7 @@ def new_compensating_for_off_resonance_with_a_pulse_sequence_control( # pylint: **kwargs) -def new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( # pylint: disable=invalid-name +def _new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -505,7 +505,7 @@ def new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_contr **kwargs) -def new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( # pylint: disable=invalid-name +def _new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -554,7 +554,7 @@ def new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev **kwargs) -def new_corpse_in_scrofulous_control( # pylint: disable=invalid-name +def _new_corpse_in_scrofulous_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, @@ -647,7 +647,7 @@ def degrees_to_radians(angle_in_degrees): **kwargs) -def new_walsh_amplitude_modulated_filter_1_control( # pylint: disable=invalid-name +def _new_walsh_amplitude_modulated_filter_1_control( # pylint: disable=invalid-name rabi_rotation=None, azimuthal_angle=0., maximum_rabi_rate=2. * np.pi, diff --git a/qctrlopencontrols/dynamic_decoupling_sequences/__init__.py b/qctrlopencontrols/dynamic_decoupling_sequences/__init__.py index a71c2aa7..30a359ab 100644 --- a/qctrlopencontrols/dynamic_decoupling_sequences/__init__.py +++ b/qctrlopencontrols/dynamic_decoupling_sequences/__init__.py @@ -27,3 +27,17 @@ from .dynamic_decoupling_sequence import DynamicDecouplingSequence from .predefined import new_predefined_dds from .driven_controls import convert_dds_to_driven_control + +__all__ = ['CARR_PURCELL', + 'CARR_PURCELL_MEIBOOM_GILL', + 'UPPER_BOUND_OFFSETS', + 'PERIODIC_SINGLE_AXIS', + 'QUADRATIC', + 'SPIN_ECHO', + 'UHRIG_SINGLE_AXIS', + 'WALSH_SINGLE_AXIS', + 'X_CONCATENATED', + 'XY_CONCATENATED', + 'DynamicDecouplingSequence', + 'convert_dds_to_driven_control', + 'new_predefined_dds'] diff --git a/qctrlopencontrols/dynamic_decoupling_sequences/constants.py b/qctrlopencontrols/dynamic_decoupling_sequences/constants.py index d4404887..2fa06ff7 100644 --- a/qctrlopencontrols/dynamic_decoupling_sequences/constants.py +++ b/qctrlopencontrols/dynamic_decoupling_sequences/constants.py @@ -13,9 +13,9 @@ # limitations under the License. """ -=================== -sequences.constants -=================== +====================================== +dynamic_decoupling_sequences.constants +====================================== """ UPPER_BOUND_OFFSETS = 10000 diff --git a/qctrlopencontrols/dynamic_decoupling_sequences/driven_controls.py b/qctrlopencontrols/dynamic_decoupling_sequences/driven_controls.py index 228dc192..092c9e4e 100644 --- a/qctrlopencontrols/dynamic_decoupling_sequences/driven_controls.py +++ b/qctrlopencontrols/dynamic_decoupling_sequences/driven_controls.py @@ -13,9 +13,9 @@ # limitations under the License. """ -========================= -sequences.driven_controls -========================= +============================================= +dynamic_decoupling_sequences.driven_controls +============================================= """ import numpy as np diff --git a/qctrlopencontrols/dynamic_decoupling_sequences/dynamic_decoupling_sequence.py b/qctrlopencontrols/dynamic_decoupling_sequences/dynamic_decoupling_sequence.py index 61f13e0c..9b5c097c 100644 --- a/qctrlopencontrols/dynamic_decoupling_sequences/dynamic_decoupling_sequence.py +++ b/qctrlopencontrols/dynamic_decoupling_sequences/dynamic_decoupling_sequence.py @@ -13,14 +13,14 @@ # limitations under the License. """ -=================== -sequences.sequences -=================== +======================================================== +dynamic_decoupling_sequences.dynamic_decoupling_sequence +======================================================== """ import numpy as np -from qctrlopencontrols.base import QctrlObject +from qctrlopencontrols.base import create_repr_from_attributes from qctrlopencontrols.exceptions import ArgumentsValueError from qctrlopencontrols.globals import ( @@ -30,7 +30,7 @@ from .driven_controls import convert_dds_to_driven_control -class DynamicDecouplingSequence(QctrlObject): #pylint: disable=too-few-public-methods +class DynamicDecouplingSequence(object): #pylint: disable=too-few-public-methods """ Create a dynamic decoupling sequence. Can be made of perfect operations, or realistic pulses. @@ -73,14 +73,6 @@ def __init__(self, name=None ): - super(DynamicDecouplingSequence, self).__init__([ - 'duration', - 'offsets', - 'rabi_rotations', - 'azimuthal_angles', - 'detuning_rotations', - 'name']) - self.duration = duration if self.duration <= 0.: raise ArgumentsValueError( @@ -117,8 +109,6 @@ def __init__(self, self.azimuthal_angles = np.array(azimuthal_angles, dtype=np.float) self.detuning_rotations = np.array(detuning_rotations, dtype=np.float) - self.number_of_offsets = len(self.offsets) - if len(self.rabi_rotations) != self.number_of_offsets: raise ArgumentsValueError( 'rabi rotations must have the same length as offsets. ', @@ -143,6 +133,19 @@ def __init__(self, if self.name is not None: self.name = str(self.name) + @property + def number_of_offsets(self): + + """Returns the number of offsets + + Returns + ------ + int + The number of offsets in the dynamic decoupling sequence + """ + + return len(self.offsets) + def get_plot_formatted_arrays(self, plot_format=MATPLOTLIB): """Gets arrays for plotting a pulse. @@ -206,6 +209,27 @@ def get_plot_formatted_arrays(self, plot_format=MATPLOTLIB): return plot_data + def __repr__(self): + + """Returns a string representation for the object. The returned string looks like a valid + Python expression that could be used to recreate the object, including default arguments. + + Returns + ------- + str + String representation of the object including the values of the arguments. + """ + + attributes = [ + 'duration', + 'offsets', + 'rabi_rotations', + 'azimuthal_angles', + 'detuning_rotations', + 'name'] + + return create_repr_from_attributes(self, attributes) + def __str__(self): """Prepares a friendly string format for a Dynamic Decoupling Sequence """ diff --git a/qctrlopencontrols/dynamic_decoupling_sequences/predefined.py b/qctrlopencontrols/dynamic_decoupling_sequences/predefined.py index b4d2e375..27b4a6bd 100644 --- a/qctrlopencontrols/dynamic_decoupling_sequences/predefined.py +++ b/qctrlopencontrols/dynamic_decoupling_sequences/predefined.py @@ -13,9 +13,9 @@ # limitations under the License. """ -=================== -sequence.predefined -=================== +======================================== +dynamic_decoupling_sequences.predefined +======================================== """ import numpy as np @@ -69,25 +69,25 @@ def new_predefined_dds(scheme=SPIN_ECHO, **kwargs): """ if scheme == RAMSEY: - sequence = new_ramsey_sequence(**kwargs) + sequence = _new_ramsey_sequence(**kwargs) elif scheme == SPIN_ECHO: - sequence = new_spin_echo_sequence(**kwargs) + sequence = _new_spin_echo_sequence(**kwargs) elif scheme == CARR_PURCELL: - sequence = new_carr_purcell_sequence(**kwargs) + sequence = _new_carr_purcell_sequence(**kwargs) elif scheme == CARR_PURCELL_MEIBOOM_GILL: - sequence = new_carr_purcell_meiboom_gill_sequence(**kwargs) + sequence = _new_carr_purcell_meiboom_gill_sequence(**kwargs) elif scheme == UHRIG_SINGLE_AXIS: - sequence = new_uhrig_single_axis_sequence(**kwargs) + sequence = _new_uhrig_single_axis_sequence(**kwargs) elif scheme == PERIODIC_SINGLE_AXIS: - sequence = new_periodic_single_axis_sequence(**kwargs) + sequence = _new_periodic_single_axis_sequence(**kwargs) elif scheme == WALSH_SINGLE_AXIS: - sequence = new_walsh_single_axis_sequence(**kwargs) + sequence = _new_walsh_single_axis_sequence(**kwargs) elif scheme == QUADRATIC: - sequence = new_quadratic_sequence(**kwargs) + sequence = _new_quadratic_sequence(**kwargs) elif scheme == X_CONCATENATED: - sequence = new_x_concatenated_sequence(**kwargs) + sequence = _new_x_concatenated_sequence(**kwargs) elif scheme == XY_CONCATENATED: - sequence = new_xy_concatenated_sequence(**kwargs) + sequence = _new_xy_concatenated_sequence(**kwargs) # Raise an error if the input sequence is not known else: raise ArgumentsValueError( @@ -131,9 +131,9 @@ def _check_duration(duration): return duration -def new_ramsey_sequence(duration=None, - pre_post_rotation=False, - **kwargs): +def _new_ramsey_sequence(duration=None, + pre_post_rotation=False, + **kwargs): """Ramsey sequence @@ -179,9 +179,9 @@ def new_ramsey_sequence(duration=None, **kwargs) -def new_spin_echo_sequence(duration=None, - pre_post_rotation=False, - **kwargs): +def _new_spin_echo_sequence(duration=None, + pre_post_rotation=False, + **kwargs): """Spin Echo Sequence. @@ -227,10 +227,10 @@ def new_spin_echo_sequence(duration=None, **kwargs) -def new_carr_purcell_sequence(duration=None, - number_of_offsets=None, - pre_post_rotation=False, - **kwargs): +def _new_carr_purcell_sequence(duration=None, + number_of_offsets=None, + pre_post_rotation=False, + **kwargs): """Carr-Purcell Sequence. @@ -285,10 +285,10 @@ def new_carr_purcell_sequence(duration=None, detuning_rotations=detuning_rotations, **kwargs) -def new_carr_purcell_meiboom_gill_sequence(duration=None, # pylint: disable=invalid-name - number_of_offsets=None, - pre_post_rotation=False, - **kwargs): +def _new_carr_purcell_meiboom_gill_sequence(duration=None, # pylint: disable=invalid-name + number_of_offsets=None, + pre_post_rotation=False, + **kwargs): """Carr-Purcell-Meiboom-Gill Sequences. Parameters @@ -347,9 +347,9 @@ def new_carr_purcell_meiboom_gill_sequence(duration=None, # pylint: disable=inv **kwargs) -def new_uhrig_single_axis_sequence(duration=None, number_of_offsets=None, - pre_post_rotation=False, - **kwargs): +def _new_uhrig_single_axis_sequence(duration=None, number_of_offsets=None, + pre_post_rotation=False, + **kwargs): """Uhrig Single Axis Sequence. @@ -408,10 +408,10 @@ def new_uhrig_single_axis_sequence(duration=None, number_of_offsets=None, **kwargs) -def new_periodic_single_axis_sequence(duration=None, # pylint: disable=invalid-name - number_of_offsets=None, - pre_post_rotation=False, - **kwargs): +def _new_periodic_single_axis_sequence(duration=None, # pylint: disable=invalid-name + number_of_offsets=None, + pre_post_rotation=False, + **kwargs): """Periodic Single Axis Sequence. @@ -468,10 +468,10 @@ def new_periodic_single_axis_sequence(duration=None, # pylint: disable=invali **kwargs) -def new_walsh_single_axis_sequence(duration=None, - paley_order=None, - pre_post_rotation=False, - **kwargs): +def _new_walsh_single_axis_sequence(duration=None, + paley_order=None, + pre_post_rotation=False, + **kwargs): """Welsh Single Axis Sequence. @@ -546,11 +546,11 @@ def new_walsh_single_axis_sequence(duration=None, **kwargs) -def new_quadratic_sequence(duration=None, - number_inner_offsets=None, - number_outer_offsets=None, - pre_post_rotation=False, - **kwargs): +def _new_quadratic_sequence(duration=None, + number_inner_offsets=None, + number_outer_offsets=None, + pre_post_rotation=False, + **kwargs): """Quadratic Decoupling Sequence @@ -649,10 +649,10 @@ def new_quadratic_sequence(duration=None, **kwargs) -def new_x_concatenated_sequence(duration=1.0, - concatenation_order=None, - pre_post_rotation=False, - **kwargs): +def _new_x_concatenated_sequence(duration=1.0, + concatenation_order=None, + pre_post_rotation=False, + **kwargs): """X-Concatenated Dynamic Decoupling Sequence Concatenation of base sequence C(\tau/2)XC(\tau/2)X @@ -727,10 +727,10 @@ def new_x_concatenated_sequence(duration=1.0, **kwargs) -def new_xy_concatenated_sequence(duration=1.0, - concatenation_order=None, - pre_post_rotation=False, - **kwargs): +def _new_xy_concatenated_sequence(duration=1.0, + concatenation_order=None, + pre_post_rotation=False, + **kwargs): """XY-Concatenated Dynamic Decoupling Sequence Concatenation of base sequence C(\tau/4)XC(\tau/4)YC(\tau/4)XC(\tau/4)Y diff --git a/qctrlopencontrols/exceptions/__init__.py b/qctrlopencontrols/exceptions/__init__.py index 57f3d09c..9b5e06ea 100644 --- a/qctrlopencontrols/exceptions/__init__.py +++ b/qctrlopencontrols/exceptions/__init__.py @@ -19,3 +19,5 @@ """ from .exceptions import ArgumentsValueError + +__all__ = ['ArgumentsValueError'] diff --git a/qctrlopencontrols/globals/__init__.py b/qctrlopencontrols/globals/__init__.py index d3d25a39..d93432fd 100644 --- a/qctrlopencontrols/globals/__init__.py +++ b/qctrlopencontrols/globals/__init__.py @@ -49,3 +49,6 @@ """Algorithm to convert a DDS to Quantum circuit where the unitaties are considered as instantaneous operation. """ + +__all__ = ['QCTRL_EXPANDED', 'CSV', 'JSON', 'CARTESIAN', + 'CYLINDRICAL', 'FIX_DURATION_UNITARY', 'INSTANT_UNITARY'] diff --git a/qctrlopencontrols/qiskit/__init__.py b/qctrlopencontrols/qiskit/__init__.py index 899a7499..3377237b 100644 --- a/qctrlopencontrols/qiskit/__init__.py +++ b/qctrlopencontrols/qiskit/__init__.py @@ -18,4 +18,6 @@ ============= """ -from .quantum_circuit import (convert_dds_to_quantum_circuit) +from .quantum_circuit import (convert_dds_to_qiskit_quantum_circuit) + +__all__ = ['convert_dds_to_qiskit_quantum_circuit'] diff --git a/qctrlopencontrols/qiskit/quantum_circuit.py b/qctrlopencontrols/qiskit/quantum_circuit.py index 913f8f4f..c322f0f6 100644 --- a/qctrlopencontrols/qiskit/quantum_circuit.py +++ b/qctrlopencontrols/qiskit/quantum_circuit.py @@ -29,7 +29,7 @@ from qctrlopencontrols.globals import (FIX_DURATION_UNITARY, INSTANT_UNITARY) -def convert_dds_to_quantum_circuit( +def convert_dds_to_qiskit_quantum_circuit( dynamic_decoupling_sequence, target_qubits=None, gate_time=0.1, diff --git a/tests/test_driven_controls.py b/tests/test_driven_controls.py index 3782c495..da2b336b 100644 --- a/tests/test_driven_controls.py +++ b/tests/test_driven_controls.py @@ -24,7 +24,7 @@ from qctrlopencontrols.exceptions import ArgumentsValueError from qctrlopencontrols import DrivenControl -from qctrlopencontrols.driven_controls.constants import ( +from qctrlopencontrols import ( UPPER_BOUND_SEGMENTS, UPPER_BOUND_RABI_RATE, UPPER_BOUND_DETUNING_RATE) diff --git a/tests/test_dynamical_decoupling.py b/tests/test_dynamical_decoupling.py index e65ed4cd..6670ff71 100644 --- a/tests/test_dynamical_decoupling.py +++ b/tests/test_dynamical_decoupling.py @@ -65,9 +65,18 @@ def test_dynamical_decoupling_sequence(): _repr_string = '{0.__class__.__name__!s}('.format(sequence) + attributes = { + 'duration': sequence.duration, + 'offsets': sequence.offsets, + 'rabi_rotations': sequence.rabi_rotations, + 'azimuthal_angles': sequence.azimuthal_angles, + 'detuning_rotations': sequence.detuning_rotations, + 'name': sequence.name + } + attributes_string = ','.join('{0}={1}'.format(attribute, repr(getattr(sequence, attribute))) - for attribute in sequence.base_attributes) + for attribute in attributes) _repr_string += attributes_string _repr_string += ')' diff --git a/tests/test_predefined_driven_controls.py b/tests/test_predefined_driven_controls.py index 11b440cf..e9addc12 100644 --- a/tests/test_predefined_driven_controls.py +++ b/tests/test_predefined_driven_controls.py @@ -22,17 +22,10 @@ from qctrlopencontrols.exceptions import ArgumentsValueError -from qctrlopencontrols.driven_controls import ( +from qctrlopencontrols import ( new_predefined_driven_control, - new_primitive_control, new_wimperis_1_control, new_solovay_kitaev_1_control, - PRIMITIVE, BB1, SK1, CORPSE, - new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control, - new_corpse_in_scrofulous_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control, - new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control, - new_walsh_amplitude_modulated_filter_1_control -) + PRIMITIVE, BB1, SK1, CORPSE, SCROFULOUS, CORPSE_IN_SCROFULOUS, + CORPSE_IN_BB1, CORPSE_IN_SK1, WAMF1) def test_new_predefined_driven_control(): @@ -69,7 +62,8 @@ def test_primitive_control_segments(): _rabi_rotation ] - primitive_control_1 = new_primitive_control( + primitive_control_1 = new_predefined_driven_control( + scheme=PRIMITIVE, rabi_rotation=_rabi_rotation, maximum_rabi_rate=_rabi_rate, azimuthal_angle=_azimuthal_angle @@ -77,10 +71,10 @@ def test_primitive_control_segments(): # Test the new_predefined_driven_control function also primitive_control_2 = new_predefined_driven_control( + scheme=PRIMITIVE, rabi_rotation=_rabi_rotation, maximum_rabi_rate=_rabi_rate, azimuthal_angle=_azimuthal_angle, - scheme=PRIMITIVE ) for control in [primitive_control_1, primitive_control_2]: @@ -110,16 +104,17 @@ def test_wimperis_1_control(): [np.cos(phi_p + _azimuthal_angle), np.sin(phi_p + _azimuthal_angle)] ]) - wimperis_control_1 = new_wimperis_1_control( + wimperis_control_1 = new_predefined_driven_control( + scheme=BB1, rabi_rotation=_rabi_rotation, azimuthal_angle=_azimuthal_angle, maximum_rabi_rate=_maximum_rabi_rate ) wimperis_control_2 = new_predefined_driven_control( + scheme=BB1, rabi_rotation=_rabi_rotation, azimuthal_angle=_azimuthal_angle, maximum_rabi_rate=_maximum_rabi_rate, - scheme=BB1 ) durations = [np.pi, np.pi, np.pi * 2, np.pi] @@ -149,7 +144,8 @@ def test_solovay_kitaev_1_control(): np.sin(phi_p + _azimuthal_angle)] ] - sk1_control_1 = new_solovay_kitaev_1_control( + sk1_control_1 = new_predefined_driven_control( + scheme=SK1, rabi_rotation=_rabi_rotation, azimuthal_angle=_azimuthal_angle, maximum_rabi_rate=1 @@ -180,12 +176,14 @@ def test_scofulous_control(): # Test that exceptions are raised upon wrong inputs for rabi_rotation # (SCROFULOUS is only defined for pi/4, pi/2 and pi pulses) with pytest.raises(ArgumentsValueError): - _ = new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( + _ = new_predefined_driven_control( + scheme=SCROFULOUS, rabi_rotation=0.3 ) # Construct SCROFULOUS controls for target rotations pi/4, pi/2 and pi - scrofulous_pi = new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( + scrofulous_pi = new_predefined_driven_control( + scheme=SCROFULOUS, rabi_rotation=np.pi, azimuthal_angle=0.5, maximum_rabi_rate=2*np.pi ) @@ -201,7 +199,8 @@ def test_scofulous_control(): assert np.allclose(pi_segments, _pi_segments) - scrofulous_pi2 = new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( + scrofulous_pi2 = new_predefined_driven_control( + scheme=SCROFULOUS, rabi_rotation=np.pi/2, azimuthal_angle=-0.5, maximum_rabi_rate=2*np.pi ) @@ -217,7 +216,8 @@ def test_scofulous_control(): assert np.allclose(pi_on_2_segments, _pi_on_2_segments) - scrofulous_pi4 = new_short_composite_rotation_for_undoing_length_over_and_under_shoot_control( + scrofulous_pi4 = new_predefined_driven_control( + scheme=SCROFULOUS, rabi_rotation=np.pi/4, azimuthal_angle=0, maximum_rabi_rate=2*np.pi ) @@ -239,7 +239,8 @@ def test_corpse_in_scrofulous_control(): defined numerically as well. """ # Test pi and pi/2 rotations - cs_pi = new_corpse_in_scrofulous_control( + cs_pi = new_predefined_driven_control( + scheme=CORPSE_IN_SCROFULOUS, rabi_rotation=np.pi, azimuthal_angle=0.5, maximum_rabi_rate=2*np.pi ) @@ -261,7 +262,8 @@ def test_corpse_in_scrofulous_control(): assert np.allclose(pi_segments, _pi_segments) - cs_pi_on_2 = new_corpse_in_scrofulous_control( + cs_pi_on_2 = new_predefined_driven_control( + scheme=CORPSE_IN_SCROFULOUS, rabi_rotation=np.pi/2, azimuthal_angle=0.25, maximum_rabi_rate=np.pi ) @@ -300,7 +302,8 @@ def test_corpse_control(): [np.cos(_azimuthal_angle), np.sin(_azimuthal_angle), 0., _rabi_rotation / 2. - k] ] - corpse_control_1 = new_compensating_for_off_resonance_with_a_pulse_sequence_control( + corpse_control_1 = new_predefined_driven_control( + scheme=CORPSE, rabi_rotation=_rabi_rotation, azimuthal_angle=_azimuthal_angle, maximum_rabi_rate=1 @@ -323,7 +326,8 @@ def test_corpse_control(): def test_cinbb_control(): """Test the segments of the CinBB (BB1 made up of CORPSEs) driven control """ - cinbb = new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( + cinbb = new_predefined_driven_control( + scheme=CORPSE_IN_BB1, rabi_rotation=np.pi/3, azimuthal_angle=0.25, maximum_rabi_rate=np.pi ) @@ -342,7 +346,8 @@ def test_cinbb_control(): assert np.allclose(segments, _segments) - cinbb = new_compensating_for_off_resonance_with_a_pulse_sequence_with_wimperis_control( + cinbb = new_predefined_driven_control( + scheme=CORPSE_IN_BB1, rabi_rotation=np.pi/5, azimuthal_angle=-0.25, maximum_rabi_rate=np.pi ) @@ -365,7 +370,8 @@ def test_cinbb_control(): def test_cinsk1_control(): """Test the segments of the CinSK1 (SK1 made up of CORPSEs) driven control """ - cinsk = new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( + cinsk = new_predefined_driven_control( + scheme=CORPSE_IN_SK1, rabi_rotation=np.pi/2, azimuthal_angle=0.5, maximum_rabi_rate=2*np.pi ) @@ -383,7 +389,8 @@ def test_cinsk1_control(): assert np.allclose(segments, _segments) - cinsk = new_compensating_for_off_resonance_with_a_pulse_sequence_with_solovay_kitaev_control( + cinsk = new_predefined_driven_control( + scheme=CORPSE_IN_SK1, rabi_rotation=2*np.pi, azimuthal_angle=-0.5, maximum_rabi_rate=2*np.pi ) @@ -407,11 +414,13 @@ def test_walsh_control(): # Test that exceptions are raised upon wrong inputs for rabi_rotation # (WALSH control is only defined for pi/4, pi/2 and pi pulses) with pytest.raises(ArgumentsValueError): - _ = new_walsh_amplitude_modulated_filter_1_control( + _ = new_predefined_driven_control( + scheme=WAMF1, rabi_rotation=0.3 ) # test pi rotation - walsh_pi = new_walsh_amplitude_modulated_filter_1_control( + walsh_pi = new_predefined_driven_control( + scheme=WAMF1, rabi_rotation=np.pi, azimuthal_angle=-0.35, maximum_rabi_rate=2*np.pi ) @@ -429,7 +438,8 @@ def test_walsh_control(): assert np.allclose(pi_segments, _pi_segments) # test pi/2 rotation - walsh_pi_on_2 = new_walsh_amplitude_modulated_filter_1_control( + walsh_pi_on_2 = new_predefined_driven_control( + scheme=WAMF1, rabi_rotation=np.pi/2, azimuthal_angle=0.57, maximum_rabi_rate=2*np.pi ) @@ -447,7 +457,8 @@ def test_walsh_control(): assert np.allclose(pi_on_2_segments, _pi_on_2_segments) # test pi/4 rotation - walsh_pi_on_4 = new_walsh_amplitude_modulated_filter_1_control( + walsh_pi_on_4 = new_predefined_driven_control( + scheme=WAMF1, rabi_rotation=np.pi/4, azimuthal_angle=-0.273, maximum_rabi_rate=2*np.pi ) pi_on_4_segments = np.vstack(( diff --git a/tests/test_predefined_dynamical_decoupling.py b/tests/test_predefined_dynamical_decoupling.py index 22009174..2470d381 100644 --- a/tests/test_predefined_dynamical_decoupling.py +++ b/tests/test_predefined_dynamical_decoupling.py @@ -24,8 +24,8 @@ from qctrlopencontrols.exceptions import ArgumentsValueError -import qctrlopencontrols.dynamic_decoupling_sequences.predefined as pre -from qctrlopencontrols.dynamic_decoupling_sequences import ( +from qctrlopencontrols import new_predefined_dds +from qctrlopencontrols import ( SPIN_ECHO, CARR_PURCELL, CARR_PURCELL_MEIBOOM_GILL, WALSH_SINGLE_AXIS, PERIODIC_SINGLE_AXIS, UHRIG_SINGLE_AXIS, QUADRATIC, X_CONCATENATED, @@ -39,8 +39,9 @@ def test_ramsey(): duration = 10. - sequence = pre.new_predefined_dds(scheme='Ramsey', - duration=duration) + sequence = new_predefined_dds( + scheme='Ramsey', + duration=duration) _offsets = np.array([]) _rabi_rotations = np.array([]) @@ -52,8 +53,11 @@ def test_ramsey(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme='Ramsey', duration=duration, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme='Ramsey', + duration=duration, + pre_post_rotation=True) + _rabi_rotations = np.array([np.pi/2, np.pi/2]) _azimuthal_angles = np.array([0., 0.]) _detuning_rotations = np.array([0., 0.]) @@ -71,8 +75,9 @@ def test_spin_echo(): duration = 10. - sequence = pre.new_predefined_dds(scheme=SPIN_ECHO, - duration=duration) + sequence = new_predefined_dds( + scheme=SPIN_ECHO, + duration=duration) _offsets = np.array([duration/2.]) _rabi_rotations = np.array([np.pi]) @@ -84,9 +89,10 @@ def test_spin_echo(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=SPIN_ECHO, - duration=duration, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=SPIN_ECHO, + duration=duration, + pre_post_rotation=True) _offsets = np.array([0, duration / 2., duration]) _rabi_rotations = np.array([np.pi/2, np.pi, np.pi/2]) @@ -107,9 +113,10 @@ def test_curr_purcell(): duration = 10. number_of_offsets = 4 - sequence = pre.new_predefined_dds(scheme=CARR_PURCELL, - duration=duration, - number_of_offsets=number_of_offsets) + sequence = new_predefined_dds( + scheme=CARR_PURCELL, + duration=duration, + number_of_offsets=number_of_offsets) _spacing = duration/number_of_offsets _offsets = np.array([_spacing*0.5, _spacing*0.5+_spacing, @@ -123,10 +130,11 @@ def test_curr_purcell(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=CARR_PURCELL, - duration=duration, - number_of_offsets=number_of_offsets, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=CARR_PURCELL, + duration=duration, + number_of_offsets=number_of_offsets, + pre_post_rotation=True) _offsets = np.array([0, _spacing * 0.5, _spacing * 0.5 + _spacing, _spacing * 0.5 + 2 * _spacing, _spacing * 0.5 + 3 * _spacing, @@ -149,9 +157,10 @@ def test_curr_purcell_meiboom_sequence(): # pylint: disable=invalid-name duration = 10. number_of_offsets = 4 - sequence = pre.new_predefined_dds(scheme=CARR_PURCELL_MEIBOOM_GILL, - duration=duration, - number_of_offsets=number_of_offsets) + sequence = new_predefined_dds( + scheme=CARR_PURCELL_MEIBOOM_GILL, + duration=duration, + number_of_offsets=number_of_offsets) _spacing = duration/number_of_offsets _offsets = np.array([_spacing*0.5, _spacing*0.5+_spacing, @@ -165,10 +174,11 @@ def test_curr_purcell_meiboom_sequence(): # pylint: disable=invalid-name assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=CARR_PURCELL_MEIBOOM_GILL, - duration=duration, - number_of_offsets=number_of_offsets, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=CARR_PURCELL_MEIBOOM_GILL, + duration=duration, + number_of_offsets=number_of_offsets, + pre_post_rotation=True) _offsets = np.array([0, _spacing * 0.5, _spacing * 0.5 + _spacing, _spacing * 0.5 + 2 * _spacing, _spacing * 0.5 + 3 * _spacing, duration]) @@ -190,9 +200,10 @@ def test_uhrig_single_axis_sequence(): duration = 10. number_of_offsets = 4 - sequence = pre.new_predefined_dds(scheme=UHRIG_SINGLE_AXIS, - duration=duration, - number_of_offsets=number_of_offsets) + sequence = new_predefined_dds( + scheme=UHRIG_SINGLE_AXIS, + duration=duration, + number_of_offsets=number_of_offsets) constant = 0.5 / (number_of_offsets+1) _delta_positions = [duration*(np.sin(np.pi*(k+1)*constant))**2 @@ -208,10 +219,11 @@ def test_uhrig_single_axis_sequence(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=UHRIG_SINGLE_AXIS, - duration=duration, - number_of_offsets=number_of_offsets, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=UHRIG_SINGLE_AXIS, + duration=duration, + number_of_offsets=number_of_offsets, + pre_post_rotation=True) _offsets = np.array(_delta_positions) _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) @@ -234,9 +246,10 @@ def test_periodic_single_axis_sequence(): # pylint: disable=invalid-name duration = 10. number_of_offsets = 4 - sequence = pre.new_predefined_dds(scheme=PERIODIC_SINGLE_AXIS, - duration=duration, - number_of_offsets=number_of_offsets) + sequence = new_predefined_dds( + scheme=PERIODIC_SINGLE_AXIS, + duration=duration, + number_of_offsets=number_of_offsets) constant = 1 / (number_of_offsets+1) # prepare the offsets for delta comb @@ -251,10 +264,11 @@ def test_periodic_single_axis_sequence(): # pylint: disable=invalid-name assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=PERIODIC_SINGLE_AXIS, - duration=duration, - number_of_offsets=number_of_offsets, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=PERIODIC_SINGLE_AXIS, + duration=duration, + number_of_offsets=number_of_offsets, + pre_post_rotation=True) _offsets = np.array(_delta_positions) _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) @@ -277,9 +291,10 @@ def test_walsh_single_axis_sequence(): duration = 10. paley_order = 20 - sequence = pre.new_predefined_dds(scheme=WALSH_SINGLE_AXIS, - duration=duration, - paley_order=paley_order) + sequence = new_predefined_dds( + scheme=WALSH_SINGLE_AXIS, + duration=duration, + paley_order=paley_order) hamming_weight = 5 samples = 2 ** hamming_weight @@ -308,10 +323,12 @@ def test_walsh_single_axis_sequence(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=WALSH_SINGLE_AXIS, - duration=duration, - paley_order=paley_order, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=WALSH_SINGLE_AXIS, + duration=duration, + paley_order=paley_order, + pre_post_rotation=True) + _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) _rabi_rotations = np.insert(_rabi_rotations, [0, _rabi_rotations.shape[0]], [np.pi/2, np.pi/2]) @@ -333,9 +350,10 @@ def test_quadratic_sequence(): number_inner_offsets = 4 number_outer_offsets = 4 - sequence = pre.new_predefined_dds(scheme=QUADRATIC, duration=duration, - number_inner_offsets=number_inner_offsets, - number_outer_offsets=number_outer_offsets) + sequence = new_predefined_dds( + scheme=QUADRATIC, duration=duration, + number_inner_offsets=number_inner_offsets, + number_outer_offsets=number_outer_offsets) _offsets = np.zeros((number_outer_offsets+1, number_inner_offsets + 1)) @@ -379,10 +397,11 @@ def test_quadratic_sequence(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=QUADRATIC, duration=duration, - number_inner_offsets=number_inner_offsets, - number_outer_offsets=number_outer_offsets, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=QUADRATIC, duration=duration, + number_inner_offsets=number_inner_offsets, + number_outer_offsets=number_outer_offsets, + pre_post_rotation=True) _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) _rabi_rotations = np.insert(_rabi_rotations, [0, _rabi_rotations.shape[0]], @@ -406,9 +425,10 @@ def test_xconcatenated_sequence(): duration = 10. concatenation_order = 3 - sequence = pre.new_predefined_dds(scheme=X_CONCATENATED, - duration=duration, - concatenation_order=concatenation_order) + sequence = new_predefined_dds( + scheme=X_CONCATENATED, + duration=duration, + concatenation_order=concatenation_order) _spacing = duration/(2**concatenation_order) _offsets = [_spacing, 3*_spacing, 4 * _spacing, 5 * _spacing, 7 * _spacing] @@ -423,10 +443,11 @@ def test_xconcatenated_sequence(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=X_CONCATENATED, - duration=duration, - concatenation_order=concatenation_order, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=X_CONCATENATED, + duration=duration, + concatenation_order=concatenation_order, + pre_post_rotation=True) _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) _rabi_rotations = np.insert(_rabi_rotations, [0, _rabi_rotations.shape[0]], @@ -448,9 +469,10 @@ def test_xyconcatenated_sequence(): duration = 10. concatenation_order = 2 - sequence = pre.new_predefined_dds(scheme=XY_CONCATENATED, - duration=duration, - concatenation_order=concatenation_order) + sequence = new_predefined_dds( + scheme=XY_CONCATENATED, + duration=duration, + concatenation_order=concatenation_order) _spacing = duration / (2 ** (concatenation_order*2)) _offsets = [_spacing, 2*_spacing, 3 * _spacing, 4 * _spacing, @@ -471,10 +493,11 @@ def test_xyconcatenated_sequence(): assert np.allclose(_azimuthal_angles, sequence.azimuthal_angles) assert np.allclose(_detuning_rotations, sequence.detuning_rotations) - sequence = pre.new_predefined_dds(scheme=XY_CONCATENATED, - duration=duration, - concatenation_order=concatenation_order, - pre_post_rotation=True) + sequence = new_predefined_dds( + scheme=XY_CONCATENATED, + duration=duration, + concatenation_order=concatenation_order, + pre_post_rotation=True) _offsets = np.insert(_offsets, [0, _offsets.shape[0]], [0, duration]) _rabi_rotations = np.insert(_rabi_rotations, [0, _rabi_rotations.shape[0]], @@ -499,29 +522,39 @@ def test_attribute_values(): # duration cannot be <= 0 with pytest.raises(ArgumentsValueError): - _ = pre.new_predefined_dds(scheme=SPIN_ECHO, duration=-2) + _ = new_predefined_dds(scheme=SPIN_ECHO, duration=-2) # number_of_offsets cannot be <= 0 - _ = pre.new_predefined_dds(scheme=CARR_PURCELL_MEIBOOM_GILL, duration=2, - number_of_offsets=-1) + _ = new_predefined_dds( + scheme=CARR_PURCELL_MEIBOOM_GILL, duration=2, + number_of_offsets=-1) # for QDD, none of the offsets can be <=0 - _ = pre.new_predefined_dds(scheme=QUADRATIC, duration=2, - number_inner_offsets=-1, number_outer_offsets=2) - _ = pre.new_predefined_dds(scheme=QUADRATIC, duration=2, - number_inner_offsets=1, number_outer_offsets=-2) - _ = pre.new_predefined_dds(scheme=QUADRATIC, duration=2, - number_inner_offsets=-1, number_outer_offsets=-2) + _ = new_predefined_dds( + scheme=QUADRATIC, duration=2, + number_inner_offsets=-1, number_outer_offsets=2) + _ = new_predefined_dds( + scheme=QUADRATIC, duration=2, + number_inner_offsets=1, number_outer_offsets=-2) + _ = new_predefined_dds( + scheme=QUADRATIC, duration=2, + number_inner_offsets=-1, number_outer_offsets=-2) # for x-cdd and xy-cdd concatenation_order cannot be <=0 - _ = pre.new_predefined_dds(scheme=X_CONCATENATED, duration=2, - concatenation_order=-1) - _ = pre.new_predefined_dds(scheme=X_CONCATENATED, duration=-2, - concatenation_order=1) - _ = pre.new_predefined_dds(scheme=X_CONCATENATED, duration=-2, - concatenation_order=-1) - _ = pre.new_predefined_dds(scheme=XY_CONCATENATED, duration=2, - concatenation_order=-1) - _ = pre.new_predefined_dds(scheme=XY_CONCATENATED, duration=-2, - concatenation_order=1) - _ = pre.new_predefined_dds(scheme=XY_CONCATENATED, duration=-2, - concatenation_order=-1) + _ = new_predefined_dds( + scheme=X_CONCATENATED, duration=2, + concatenation_order=-1) + _ = new_predefined_dds( + scheme=X_CONCATENATED, duration=-2, + concatenation_order=1) + _ = new_predefined_dds( + scheme=X_CONCATENATED, duration=-2, + concatenation_order=-1) + _ = new_predefined_dds( + scheme=XY_CONCATENATED, duration=2, + concatenation_order=-1) + _ = new_predefined_dds( + scheme=XY_CONCATENATED, duration=-2, + concatenation_order=1) + _ = new_predefined_dds( + scheme=XY_CONCATENATED, duration=-2, + concatenation_order=-1) diff --git a/tests/test_qctrl_object.py b/tests/test_qctrl_object.py deleted file mode 100644 index de21bc47..00000000 --- a/tests/test_qctrl_object.py +++ /dev/null @@ -1,66 +0,0 @@ -# Copyright 2019 Q-CTRL Pty Ltd & Q-CTRL Inc -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -===================== -Tests for base module -===================== -""" - -import pytest -from qctrlopencontrols.exceptions import ArgumentsValueError -from qctrlopencontrols.base import QctrlObject - - -class SampleClass(QctrlObject): #pylint: disable=too-few-public-methods - - """A sample class with attributes - - Parameters - ---------- - sample_attribute : int - A sample attribute of integer type - base_attributes : list - A list of attributes to be used as base_attributes - """ - - def __init__(self, sample_attribute, base_attributes): - super(SampleClass, self).__init__(base_attributes=base_attributes) - self.sample_attribute = sample_attribute - - -def test_qctrl_object(): # pylint: disable=too-few-public-methods - """Tests the __repr__ and __str__ methods of base.QctrlObject - """ - - sample_class = SampleClass(sample_attribute=50, base_attributes=['sample_attribute']) - - _sample_repr = '{0.__class__.__name__!s}(sample_attribute={0.sample_attribute!r})'.format( - sample_class) - - assert repr(sample_class) == _sample_repr - assert str(sample_class) == str(_sample_repr) - - sample_class = SampleClass(sample_attribute=50, base_attributes=None) - _sample_repr = 'No attributes provided for object of class {0.__class__.__name__!s}'.format( - sample_class) - - assert repr(sample_class) == _sample_repr - assert str(sample_class) == str(_sample_repr) - - with pytest.raises(ArgumentsValueError): - - _ = SampleClass(sample_attribute=50., base_attributes=[]) - _ = SampleClass(sample_attribute=50., base_attributes=['sample_1', 40]) - _ = SampleClass(sample_attribute=50., base_attributes='no list') diff --git a/tests/test_qiskit_sequence.py b/tests/test_qiskit_sequence.py index c4c95fde..e58ca8f1 100644 --- a/tests/test_qiskit_sequence.py +++ b/tests/test_qiskit_sequence.py @@ -24,7 +24,7 @@ from qiskit import BasicAer from qctrlopencontrols import ( - new_predefined_dds, convert_dds_to_quantum_circuit) + new_predefined_dds, convert_dds_to_qiskit_quantum_circuit) def _create_test_sequence(sequence_scheme, pre_post_rotation): @@ -93,7 +93,7 @@ def _check_circuit_unitary(pre_post_rotation, multiplier, algorithm): 'quadratic', 'X concatenated', 'XY concatenated']: sequence = _create_test_sequence(sequence_scheme, pre_post_rotation) - quantum_circuit = convert_dds_to_quantum_circuit( + quantum_circuit = convert_dds_to_qiskit_quantum_circuit( dynamic_decoupling_sequence=sequence, add_measurement=False, algorithm=algorithm) From df46e59f0edb693ba90c29893f0939ec69b1205d Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Wed, 12 Jun 2019 14:21:53 +1000 Subject: [PATCH 03/16] __init__ file merged --- examples/export_a_dds_to_program.ipynb | 829 ------------------------- examples/export_a_dds_to_pyquil.ipynb | 469 ++++++++++++++ qctrlopencontrols/pyquil/__init__.py | 4 +- qctrlopencontrols/pyquil/program.py | 2 +- 4 files changed, 473 insertions(+), 831 deletions(-) delete mode 100755 examples/export_a_dds_to_program.ipynb create mode 100755 examples/export_a_dds_to_pyquil.ipynb diff --git a/examples/export_a_dds_to_program.ipynb b/examples/export_a_dds_to_program.ipynb deleted file mode 100755 index 9e32cf63..00000000 --- a/examples/export_a_dds_to_program.ipynb +++ /dev/null @@ -1,829 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Export a Dynamical Decoupling Sequence to Program\n", - "\n", - "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported to a Program defined in Pyquil. We also show how a DDS can decrease the number of errors, when executing a quantum program on a noisy device (simulated by Pyquil).\n", - "\n", - "Note: To create a quantum program, you need to install `pyquil` package. Follow the [instruction](http://docs.rigetti.com/en/stable/start.html) to install `pyquil`. Moreover, in order to simulate the quantum program, you will require the [FOrestSDK](https://www.rigetti.com/forest). Follow the [instruction] (http://docs.rigetti.com/en/stable/start.html) to obtain and install ForestSDK on your computer." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#General\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.gridspec import GridSpec\n", - "\n", - "#Q-CTRL Open Controls\n", - "from qctrlopencontrols import new_predefined_dds, convert_dds_to_program\n", - "\n", - "#pyquil\n", - "from pyquil.api import get_qc\n", - "from pyquil.noise import dephasing_kraus_map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running a DDS on a Pyquil Quantum Virtual Machine (QVM)\n", - "\n", - "This section demonstrates how a DDS can be prepared and a corresponding Pyquil program made and executed on a Quantum Virtual Simulator (QVM).\n", - "\n", - "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", - "\n", - "Pyquil implements quantum computation through `Program` that contains a series of [gates](http://docs.rigetti.com/en/stable/apidocs/gates.html). How these gates are physically implemented will depend on the device that it is run on. Rigetti's documentation gives an oversight on Rigetti's [native gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#native-gates-for-rigetti-qpus)] and other [physically realizable gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#all-gates-and-instructions).\n", - "\n", - "If a user wants to add pauses (in time) during a computation they can use identity gates. However, executing a quantum program with identity gates cause the compiler to remove the gates before execution to increase efficiency. This can be avoided by using `Pragma PRESERVE` blocks (see [documentation](http://docs.rigetti.com/en/stable/basics.html#pragmas) for more detail and other usages of `Pragma`).All of $I$ (identity gate), $RX$ (X-rotation gates) and $RY$ (Y-rotation gates) take a fixed time (`gate_time`).\n", - "\n", - "Converting a DDS into a Pyquil program is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](XXXX).\n", - "\n", - "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We also create a Ramsey DDS of the same duration to compare as a benchmark. For both the sequences, we add a $X_{\\pi/2}$ rotation on either end of the sequence." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Preparing the Sequences" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quadratic sequence:\n", - "Duration = 5e-06\n", - "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", - "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", - "Ramsey sequence:\n", - "Duration = 5e-06\n", - "Offsets = [0.0,1.0] x 5e-06\n", - "Rabi Rotations = [0.5,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Quadratic sequence, total duration: 20us\n", - "quadratic_sequence = new_predefined_dds(\n", - " scheme='quadratic',\n", - " duration=5e-6, \n", - " number_inner_offsets=2,\n", - " number_outer_offsets=2,\n", - " pre_post_rotation=True,\n", - " name='Quadratic sequence')\n", - "\n", - "# Ramsey sequence, total duration: 20us\n", - "ramsey_sequence = new_predefined_dds(\n", - " scheme='Ramsey',\n", - " duration=5e-6,\n", - " pre_post_rotation=True,\n", - " name='Ramsey sequence')\n", - "\n", - "print(quadratic_sequence)\n", - "print(ramsey_sequence)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Constructing the Program Using Q-CTRL Open Controls\n", - "\n", - "To construct a `Program` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`.\n", - "\n", - "In this example, we will use $0$th qubit and specify the `gate_time` to be $50$ $n$s (see [noise specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "## Prepare the Pyquil related parameters\n", - "'''\n", - "target_qubits : list\n", - " A list of integers specifying the target qubits within the set of qubit registers\n", - "'''\n", - "target_qubits = [0]\n", - "\n", - "'''\n", - "gate_time : float\n", - " Time delay (in seconds) introduced by identity gate\n", - "'''\n", - "gate_time = 50e-9\n", - "\n", - "'''\n", - "add_measurement : bool\n", - " Indicates if the program requires a measurement step.\n", - "'''\n", - "add_measurement = True\n", - "\n", - "## convert the quadratic sequence to program\n", - "quadratic_program = convert_dds_to_program(\n", - " dynamic_decoupling_sequence=quadratic_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement,\n", - ")\n", - "\n", - "## convert the ramsey sequence to program\n", - "ramsey_program = convert_dds_to_program(\n", - " dynamic_decoupling_sequence=ramsey_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the DDS\n", - "\n", - "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 3, 1, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Quadratic Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 1, 3, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Ramsey Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compiling and running the pograms\n", - "\n", - "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;1-qubit device in this case.\n", - "\n", - "NOTE: You will require ForestSDK to run the following segments. You need to start the the Quil Compiler and QVM in server mode. Execute the following commands in separate prompts.\n", - "\n", - "```\n", - "$ quilc -S\n", - "$ qvm -S\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "# create a noiseless quantum device with 1-qubit\n", - "quantum_device = get_qc(\"1q-qvm\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Compiling the Quadratic DDS Program\n", - "\n", - "Note that both DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 20]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", - "\n", - "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", - "\n", - "The `I()` in the compiled program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", - "\n", - "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", - "\n", - "At the end of each program, we place a `measurement` operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DECLARE qubit-0 BIT[1]\n", - "RX(pi/2) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi/2) 0\n", - "MEASURE 0 qubit-0[0]\n", - "HALT\n", - "\n" - ] - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "##Compiling the quadratic program\n", - "executable_quadratic_program = quantum_device.compile(quadratic_program)\n", - "## print the compiled program\n", - "print(executable_quadratic_program.program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Compiling the Ramsey program\n", - "\n", - "Compiling the program for Ramsey sequence is similar." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DECLARE qubit-0 BIT[1]\n", - "RX(pi/2) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi/2) 0\n", - "MEASURE 0 qubit-0[0]\n", - "HALT\n", - "\n" - ] - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "\n", - "##Compiling the quadratic program\n", - "executable_ramsey_program = quantum_device.compile(ramsey_program)\n", - "## print the compiled program\n", - "print(executable_ramsey_program.program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And here we count 100 `Id` operations, implementing a total delay of $100 \\times 50 ns = 5 \\mu s$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the programs using Pyquil's QVM\n", - "\n", - "Here, we will use the quantum device we created earlier to run the program. The experiment consists of `trials` repeats of the program on a qubit. Each run collects the state of the qubit as measurement. The result is displayed as a histogram. We here define small utility method to plot the trial results for QVM." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_trial_outcomes(trial_result, qubit = 0):\n", - " \"\"\"Plots the trial result as probabilities.\n", - " Parameters\n", - " ----------\n", - " trial_result : dict\n", - " A dict where the key is the target qubits and value is a numy array of size\n", - " containing outcome of each trial in computational basis.\n", - " qubit: int\n", - " An interger corresponding to the target qubit.\n", - " \"\"\"\n", - " \n", - " qubit_trial_result = trial_result[qubit]\n", - " \n", - " number_of_trials = qubit_trial_result.shape[0]\n", - " \n", - " outcome = np.array([number_of_trials-np.sum(qubit_trial_result), np.sum(qubit_trial_result)])\n", - " outcome_probabilities = outcome / number_of_trials\n", - " \n", - " ##plotting the outcome probabilities\n", - " #ax = plt.subplots(1,1)\n", - " #ax.bar([0, 1], outcome_probabilities)\n", - " #ax.xlabel('States')\n", - " #ax.xticks(ticks=[0, 1])\n", - " #ax.ylabel('Probabilities')\n", - " plt.bar(np.array([0, 1]), outcome_probabilities)\n", - " plt.xticks(np.array([0, 1]), [0, 1])\n", - " plt.ylabel('Probabilities')\n", - " plt.xlabel('States')\n", - " \n", - "'''\n", - "trials : int\n", - " An integer denoting the number of repeats of the program on quantum device\n", - "'''\n", - "trials=100" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run_and_measure(quadratic_program, trials=trials)\n", - "plot_trial_outcomes(quadratic_result)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "ramsey_result = quantum_device.run_and_measure(ramsey_program, trials=trials)\n", - "plot_trial_outcomes(ramsey_result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the programs with noise\n", - "\n", - "We use the same DDS and program defined above. However, in this case, we define a dephasing noise for the identity gates through appropriate Kraus Operator with specific dephasing probability. We introduce the noise to the programs. We then run the programs with noisy gates on the same device created above. Outcome of these experiments are plotted and compared with that obtained from ideal gates." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# define a one-shot dephasing probability\n", - "p = 0.02\n", - "\n", - "# define a dephasing with probability p\n", - "kraus_operators = dephasing_kraus_map(p=p)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Running the quadratic sequence program with noisy identity gates\n", - "\n", - "Here we will introduce the noisy identity gates to the quadratic sequence program, run it on the virtual device and plot the outcome." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "#add noise to the identity gates\n", - "noisy_quadratic_program = quadratic_program.define_noisy_gate(\"I\", [1], kraus_operators)\n", - "#obtain the noisy result\n", - "noisy_quadratic_result = quantum_device.run_and_measure(noisy_quadratic_program, trials=trials)\n", - "#plot the noisy results\n", - "plot_trial_outcomes(noisy_quadratic_result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Running the ramsey sequence program with noisy identity gates\n", - "\n", - "Here we will introduce the noisy identity gates to the ramsey sequence program, run it on the virtual device and plot the outcome." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "#add noise to the identity gates\n", - "noisy_ramsey_program = ramsey_program.define_noisy_gate(\"I\", target_qubits, kraus_operators)\n", - "#obtain the noisy result\n", - "noisy_ramsey_result = quantum_device.run_and_measure(noisy_ramsey_program, trials=trials)\n", - "#plot the noisy results\n", - "plot_trial_outcomes(noisy_ramsey_result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Reducing Errors by Increasing the Coherence Time\n", - "\n", - "In the ideal noiseless simulator, both the Ramsey DDS and Quadratic DDS produced exactly the same outcome, the $|1 \\rangle$ state with probability 1. However, in the case of noisy channels, we can see a marked difference. The Quadratic DDS produced a probability distribution closer to the expected outcome. This is because the Quadratic DDS is able to cancel the effects of magnetic noise in the environment - extending the [T2 time](https://en.wikipedia.org/wiki/Spin–spin_relaxation), and effectively increasing the coherence of the qubit." - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/export_a_dds_to_pyquil.ipynb b/examples/export_a_dds_to_pyquil.ipynb new file mode 100755 index 00000000..65b2ad5b --- /dev/null +++ b/examples/export_a_dds_to_pyquil.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Export a Dynamical Decoupling Sequence to Pyquil\n", + "\n", + "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported to a `Program` defined in Pyquil.\n", + "\n", + "Note: To create a quantum program, you need to install `pyquil` package. Follow the [instruction](http://docs.rigetti.com/en/stable/start.html) to install `pyquil`. Moreover, in order to simulate the quantum program, you will require the [ForestSDK](https://www.rigetti.com/forest). Follow the [instruction] (http://docs.rigetti.com/en/stable/start.html) to obtain and install ForestSDK on your computer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#General\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.gridspec import GridSpec\n", + "\n", + "#Q-CTRL Open Controls\n", + "from qctrlopencontrols import (\n", + " new_predefined_dds, convert_dds_to_pyquil_program)\n", + "\n", + "#pyquil\n", + "from pyquil.api import get_qc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running a DDS on a Pyquil Quantum Virtual Machine (QVM)\n", + "\n", + "This section demonstrates how a DDS can be prepared and a corresponding Pyquil program made and executed on a Quantum Virtual Simulator (QVM).\n", + "\n", + "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", + "\n", + "Pyquil implements quantum computation through `Program` that contains a series of [gates](http://docs.rigetti.com/en/stable/apidocs/gates.html). How these gates are physically implemented will depend on the device that it is run on. Rigetti's documentation gives an oversight on Rigetti's [native gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#native-gates-for-rigetti-qpus)] and other [physically realizable gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#all-gates-and-instructions).\n", + "\n", + "If a user wants to add pauses (in time) during a computation they can use identity gates. However, executing a quantum program with identity gates cause the compiler to remove the gates before execution to increase efficiency. This can be avoided by using `Pragma PRESERVE` blocks (see [documentation](http://docs.rigetti.com/en/stable/basics.html#pragmas) for more detail and other usages of `Pragma`).All of $I$ (identity gate), $RX$ (X-rotation gates) and $RY$ (Y-rotation gates) take a fixed time (`gate_time`).\n", + "\n", + "Converting a DDS into a Pyquil program is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](XXXX).\n", + "\n", + "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We add a $X_{\\pi/2}$ rotation on either end of the sequence." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preparing the Sequences" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadratic sequence:\n", + "Duration = 5e-06\n", + "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", + "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", + "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", + "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n" + ] + } + ], + "source": [ + "## Quadratic sequence, total duration: 20us\n", + "quadratic_sequence = new_predefined_dds(\n", + " scheme='quadratic',\n", + " duration=5e-6, \n", + " number_inner_offsets=2,\n", + " number_outer_offsets=2,\n", + " pre_post_rotation=True,\n", + " name='Quadratic sequence')\n", + "print(quadratic_sequence)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing the Program Using Q-CTRL Open Controls\n", + "\n", + "To construct a `Program` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`.\n", + "\n", + "In this example, we will use $0$th qubit and specify the `gate_time` to be $50$ $n$s (see same [specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "## Prepare the Pyquil related parameters\n", + "'''\n", + "target_qubits : list\n", + " A list of integers specifying the target qubits within the set of qubit registers\n", + "'''\n", + "target_qubits = [0]\n", + "\n", + "'''\n", + "gate_time : float\n", + " Time delay (in seconds) introduced by identity gate\n", + "'''\n", + "gate_time = 50e-9\n", + "\n", + "'''\n", + "add_measurement : bool\n", + " Indicates if the program requires a measurement step.\n", + "'''\n", + "add_measurement = True\n", + "\n", + "## convert the quadratic sequence to program\n", + "quadratic_program = convert_dds_to_pyquil_program(\n", + " dynamic_decoupling_sequence=quadratic_sequence,\n", + " target_qubits=target_qubits,\n", + " gate_time=gate_time,\n", + " add_measurement=add_measurement,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the DDS\n", + "\n", + "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", + "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", + " formatted_plot_data['rabi_rotations'],\n", + " formatted_plot_data['azimuthal_angles'],\n", + " formatted_plot_data['detuning_rotations'],\n", + " formatted_plot_data['times']\n", + ")\n", + "\n", + "# prepare the axes\n", + "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", + " 3, 1, figsize=(20,5))\n", + "\n", + "rabi_plot_axis.plot(times, rabi_rotations)\n", + "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "rabi_plot_axis.set_xlabel('Time (sec)')\n", + "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", + "\n", + "azimuth_plot_axis.plot(times, azimuthal_angles)\n", + "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "azimuth_plot_axis.set_xlabel('Time (sec)')\n", + "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", + "\n", + "detuning_plot_axis.plot(times, detuning_rotations)\n", + "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "detuning_plot_axis.set_xlabel('Time (sec)')\n", + "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", + "\n", + "plt.suptitle('Quadratic Sequence')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compiling and running the pograms\n", + "\n", + "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;1-qubit device in this case.\n", + "\n", + "NOTE: You will require ForestSDK to run the following segments. You need to start the the Quil Compiler and QVM in server mode. Execute the following commands in separate prompts.\n", + "\n", + "```\n", + "$ quilc -S\n", + "$ qvm -S\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# NBVAL_SKIP\n", + "quantum_device = get_qc(\"1q-qvm\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Compiling the Quadratic DDS Program\n", + "\n", + "Note that both DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", + "\n", + "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", + "\n", + "The `I()` in the compiled program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", + "\n", + "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", + "\n", + "At the end of each program, we place a `measurement` operator to read out the result." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DECLARE qubit-0 BIT[1]\n", + "RX(pi/2) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RZ(pi) 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "I 0\n", + "RX(pi/2) 0\n", + "MEASURE 0 qubit-0[0]\n", + "HALT\n", + "\n" + ] + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "##Compiling the quadratic program\n", + "executable_quadratic_program = quantum_device.compile(quadratic_program)\n", + "## print the compiled program\n", + "print(executable_quadratic_program.program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the programs using Pyquil's QVM\n", + "\n", + "Here, we will use the quantum device we created earlier to run the program. The experiment consists of `trials` repeats of the program on a qubit. Each run collects the state of the qubit as measurement. The result is displayed as a histogram. We here define small utility method to plot the trial results for QVM." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_trial_outcomes(trial_result, qubit = 0):\n", + " \"\"\"Plots the trial result as probabilities.\n", + " Parameters\n", + " ----------\n", + " trial_result : dict\n", + " A dict where the key is the target qubits and value is a numy array of size\n", + " containing outcome of each trial in computational basis.\n", + " qubit: int\n", + " An interger corresponding to the target qubit.\n", + " \"\"\"\n", + " \n", + " qubit_trial_result = trial_result[qubit]\n", + " \n", + " number_of_trials = qubit_trial_result.shape[0]\n", + " \n", + " outcome = np.array([number_of_trials-np.sum(qubit_trial_result), np.sum(qubit_trial_result)])\n", + " outcome_probabilities = outcome / number_of_trials\n", + " \n", + " plt.bar(np.array([0, 1]), outcome_probabilities)\n", + " plt.xticks(np.array([0, 1]), [0, 1])\n", + " plt.ylabel('Probabilities')\n", + " plt.xlabel('States')\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "'''\n", + "trials : int\n", + " An integer denoting the number of repeats of the program on quantum device\n", + "'''\n", + "trials=100\n", + "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "quadratic_result = quantum_device.run_and_measure(quadratic_program, trials=trials)\n", + "plot_trial_outcomes(quadratic_result)" + ] + } + ], + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/qctrlopencontrols/pyquil/__init__.py b/qctrlopencontrols/pyquil/__init__.py index 2392f289..5f227a00 100644 --- a/qctrlopencontrols/pyquil/__init__.py +++ b/qctrlopencontrols/pyquil/__init__.py @@ -18,4 +18,6 @@ ============= """ -from .program import convert_dds_to_program +from .program import convert_dds_to_pyquil_program + +__all__ = ['convert_dds_to_pyquil_program'] diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index 68901d04..5b63528a 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -30,7 +30,7 @@ FIX_DURATION_UNITARY, INSTANT_UNITARY) -def convert_dds_to_program( +def convert_dds_to_pyquil_program( dynamic_decoupling_sequence, target_qubits=None, gate_time=0.1, From fde8a5e50df9bf447216e14d940917b957904774 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Wed, 12 Jun 2019 14:41:24 +1000 Subject: [PATCH 04/16] method in test updated --- tests/test_pyquil_sequence.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_pyquil_sequence.py b/tests/test_pyquil_sequence.py index 12ab78f9..4fec845a 100644 --- a/tests/test_pyquil_sequence.py +++ b/tests/test_pyquil_sequence.py @@ -25,7 +25,7 @@ from qctrlopencontrols import ( DynamicDecouplingSequence, - convert_dds_to_program) + convert_dds_to_pyquil_program) def test_pyquil_program(): @@ -45,7 +45,7 @@ def test_pyquil_program(): azimuthal_angles=_azimuthal_angles, detuning_rotations=_detuning_rotations) - program = convert_dds_to_program( + program = convert_dds_to_pyquil_program( sequence, [0], gate_time=1e-6) From fce5648228659e3317bad3abf593576f251f9994 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Mon, 1 Jul 2019 10:28:50 +1000 Subject: [PATCH 05/16] notebook updated for tests on rigetti device --- examples/export_a_dds_to_pyquil.ipynb | 1949 +++++++++++++++++++++++-- qctrlopencontrols/pyquil/program.py | 13 +- 2 files changed, 1827 insertions(+), 135 deletions(-) diff --git a/examples/export_a_dds_to_pyquil.ipynb b/examples/export_a_dds_to_pyquil.ipynb index 65b2ad5b..e1ec2f32 100755 --- a/examples/export_a_dds_to_pyquil.ipynb +++ b/examples/export_a_dds_to_pyquil.ipynb @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -74,24 +74,35 @@ "output_type": "stream", "text": [ "Quadratic sequence:\n", - "Duration = 5e-06\n", - "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", + "Duration = 2e-05\n", + "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 2e-05\n", "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n" + "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", + "Ramsey sequence:\n", + "Duration = 2e-05\n", + "Offsets = [0.0,1.0] x 2e-05\n", + "Rabi Rotations = [0.5,0.5] x pi\n", + "Azimuthal Angles = [0.0,0.0] x pi\n", + "Detuning Rotations = [0.0,0.0] x pi\n" ] } ], "source": [ - "## Quadratic sequence, total duration: 20us\n", "quadratic_sequence = new_predefined_dds(\n", - " scheme='quadratic',\n", - " duration=5e-6, \n", + " scheme='quadratic',\n", + " duration=20e-6, \n", " number_inner_offsets=2,\n", " number_outer_offsets=2,\n", " pre_post_rotation=True,\n", " name='Quadratic sequence')\n", - "print(quadratic_sequence)" + "ramsey_sequence = new_predefined_dds(\n", + " scheme='Ramsey',\n", + " duration=20e-6, \n", + " pre_post_rotation=True,\n", + " name='Ramsey sequence')\n", + "print(quadratic_sequence)\n", + "print(ramsey_sequence)" ] }, { @@ -107,16 +118,841 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ro[0]\n", + "PRAGMA PRESERVE_BLOCK\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "DECLARE ro BIT[1]\n", + "MEASURE 1 ro[0]\n", + "PRAGMA END_PRESERVE_BLOCK\n", + "\n", + "ro[0]\n", + "PRAGMA PRESERVE_BLOCK\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "DECLARE ro BIT[1]\n", + "MEASURE 1 ro[0]\n", + "PRAGMA END_PRESERVE_BLOCK\n", + "\n" + ] + } + ], "source": [ "## Prepare the Pyquil related parameters\n", "'''\n", "target_qubits : list\n", " A list of integers specifying the target qubits within the set of qubit registers\n", "'''\n", - "target_qubits = [0]\n", + "target_qubits = [1]\n", "\n", "'''\n", "gate_time : float\n", @@ -129,14 +965,39 @@ " Indicates if the program requires a measurement step.\n", "'''\n", "add_measurement = True\n", - "\n", "## convert the quadratic sequence to program\n", "quadratic_program = convert_dds_to_pyquil_program(\n", " dynamic_decoupling_sequence=quadratic_sequence,\n", " target_qubits=target_qubits,\n", " gate_time=gate_time,\n", " add_measurement=add_measurement,\n", - ")" + ")\n", + "print(quadratic_program.out())\n", + "quadratic_program = quadratic_program.wrap_in_numshots_loop(1000)\n", + "\n", + "## convert the ramsey sequence to program\n", + "ramsey_program = convert_dds_to_pyquil_program(\n", + " dynamic_decoupling_sequence=ramsey_sequence,\n", + " target_qubits=target_qubits,\n", + " gate_time=gate_time,\n", + " add_measurement=add_measurement,\n", + ")\n", + "print(ramsey_program.out())\n", + "ramsey_program = ramsey_program.wrap_in_numshots_loop(1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#from pyquil.gates import MEASURE\n", + "#readout = quadratic_program.declare('ro', 'BIT', len(target_qubits))\n", + "#for idx, qubit in enumerate(target_qubits):\n", + "# quadratic_program += MEASURE(qubit, readout[idx])\n", + "#quadratic_program = quadratic_program.wrap_in_numshots_loop(1000)\n", + "#print(quadratic_program.out())\n" ] }, { @@ -148,14 +1009,21 @@ "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Plotting Quadratic sequence" + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -198,6 +1066,63 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Plotting Ramsey sequence" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", + "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", + " formatted_plot_data['rabi_rotations'],\n", + " formatted_plot_data['azimuthal_angles'],\n", + " formatted_plot_data['detuning_rotations'],\n", + " formatted_plot_data['times']\n", + ")\n", + "\n", + "# prepare the axes\n", + "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", + " 3, 1, figsize=(20,5))\n", + "\n", + "rabi_plot_axis.plot(times, rabi_rotations)\n", + "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "rabi_plot_axis.set_xlabel('Time (sec)')\n", + "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", + "\n", + "azimuth_plot_axis.plot(times, azimuthal_angles)\n", + "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "azimuth_plot_axis.set_xlabel('Time (sec)')\n", + "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", + "\n", + "detuning_plot_axis.plot(times, detuning_rotations)\n", + "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "detuning_plot_axis.set_xlabel('Time (sec)')\n", + "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", + "\n", + "plt.suptitle('Quadratic Sequence')\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -216,12 +1141,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# NBVAL_SKIP\n", - "quantum_device = get_qc(\"1q-qvm\")" + "quantum_device = get_qc(\"Aspen-2\", as_qvm=True, noisy=True)" ] }, { @@ -243,122 +1168,420 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "DECLARE qubit-0 BIT[1]\n", - "RX(pi/2) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi/2) 0\n", - "MEASURE 0 qubit-0[0]\n", + "DECLARE ro BIT[1]\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "MEASURE 1 ro[0]\n", "HALT\n", "\n" ] @@ -373,6 +1596,432 @@ "print(executable_quadratic_program.program)" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DECLARE ro BIT[1]\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "MEASURE 1 ro[0]\n", + "HALT\n", + "\n" + ] + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "##Compiling the quadratic program\n", + "executable_ramsey_program = quantum_device.compile(ramsey_program)\n", + "## print the compiled program\n", + "print(executable_ramsey_program.program)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -384,7 +2033,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -415,7 +2064,38 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "'''\n", + "trials : int\n", + " An integer denoting the number of repeats of the program on quantum device\n", + "'''\n", + "trials=100\n", + "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "quadratic_result = quantum_device.run(executable_quadratic_program)\n", + "plot_trial_outcomes(quadratic_result, qubit=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -440,9 +2120,16 @@ "'''\n", "trials=100\n", "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run_and_measure(quadratic_program, trials=trials)\n", - "plot_trial_outcomes(quadratic_result)" + "ramsey_result = quantum_device.run(executable_ramsey_program)\n", + "plot_trial_outcomes(ramsey_result, qubit=1)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index 8cc66bed..05ccedda 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -140,6 +140,7 @@ def convert_dds_to_pyquil_program( time_covered = 0 program = Program() + #program += Pragma('INITIAL_REWIRING', ['"GREEDY"']) program += Pragma('PRESERVE_BLOCK') for operation_idx in range(operations.shape[1]): @@ -200,10 +201,14 @@ def convert_dds_to_pyquil_program( time_covered = offsets[operation_idx] + unitary_time if add_measurement: - for qubit in target_qubits: - bit_name = 'qubit-{}'.format(qubit) - measurement_bit = program.declare(bit_name, 'BIT', 1) - program += MEASURE(qubit, measurement_bit) + #for qubit in target_qubits: + # bit_name = 'ro'.format(qubit) + # measurement_bit = program.declare(bit_name, 'BIT', 1) + # program += MEASURE(qubit, measurement_bit) + readout = program.declare('ro', 'BIT', len(target_qubits)) + for idx, qubit in enumerate(target_qubits): + program += MEASURE(qubit, readout[idx]) + print(readout[idx]) program += Pragma('END_PRESERVE_BLOCK') return program From e79c4b133c73db0f5f1c082117c82663c2a2800e Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Mon, 1 Jul 2019 13:11:33 +1000 Subject: [PATCH 06/16] pyquil notebook with 2 segments --- examples/export_a_dds_to_pyquil.ipynb | 774 +++++++++++++++++++++----- qctrlopencontrols/pyquil/program.py | 13 +- 2 files changed, 641 insertions(+), 146 deletions(-) diff --git a/examples/export_a_dds_to_pyquil.ipynb b/examples/export_a_dds_to_pyquil.ipynb index 65b2ad5b..9a447848 100755 --- a/examples/export_a_dds_to_pyquil.ipynb +++ b/examples/export_a_dds_to_pyquil.ipynb @@ -78,7 +78,13 @@ "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n" + "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", + "Ramsey sequence:\n", + "Duration = 5e-06\n", + "Offsets = [0.0,1.0] x 5e-06\n", + "Rabi Rotations = [0.5,0.5] x pi\n", + "Azimuthal Angles = [0.0,0.0] x pi\n", + "Detuning Rotations = [0.0,0.0] x pi\n" ] } ], @@ -91,7 +97,15 @@ " number_outer_offsets=2,\n", " pre_post_rotation=True,\n", " name='Quadratic sequence')\n", - "print(quadratic_sequence)" + "print(quadratic_sequence)\n", + "\n", + "## Ramsey sequence, total duration: 20us\n", + "ramsey_sequence = new_predefined_dds(\n", + " scheme='Ramsey',\n", + " duration=5e-6,\n", + " pre_post_rotation=True,\n", + " name='Ramsey sequence')\n", + "print(ramsey_sequence)" ] }, { @@ -107,16 +121,25 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ro[0]\n", + "ro[0]\n" + ] + } + ], "source": [ "## Prepare the Pyquil related parameters\n", "'''\n", "target_qubits : list\n", " A list of integers specifying the target qubits within the set of qubit registers\n", "'''\n", - "target_qubits = [0]\n", + "target_qubits = [1]\n", "\n", "'''\n", "gate_time : float\n", @@ -136,6 +159,13 @@ " target_qubits=target_qubits,\n", " gate_time=gate_time,\n", " add_measurement=add_measurement,\n", + ")\n", + "## convert the ramsey sequence to program\n", + "ramsey_program = convert_dds_to_pyquil_program(\n", + " dynamic_decoupling_sequence=ramsey_sequence,\n", + " target_qubits=target_qubits,\n", + " gate_time=gate_time,\n", + " add_measurement=add_measurement,\n", ")" ] }, @@ -148,14 +178,21 @@ "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Plotting the Quadratic Sequence" + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -202,9 +239,344 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Compiling and running the pograms\n", + "#### Plotting the Ramsey sequence" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", + "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", + " formatted_plot_data['rabi_rotations'],\n", + " formatted_plot_data['azimuthal_angles'],\n", + " formatted_plot_data['detuning_rotations'],\n", + " formatted_plot_data['times']\n", + ")\n", + "\n", + "# prepare the axes\n", + "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", + " 3, 1, figsize=(20,5))\n", + "\n", + "rabi_plot_axis.plot(times, rabi_rotations)\n", + "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "rabi_plot_axis.set_xlabel('Time (sec)')\n", + "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", + "\n", + "azimuth_plot_axis.plot(times, azimuthal_angles)\n", + "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "azimuth_plot_axis.set_xlabel('Time (sec)')\n", + "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", + "\n", + "detuning_plot_axis.plot(times, detuning_rotations)\n", + "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", + "detuning_plot_axis.set_xlabel('Time (sec)')\n", + "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", + "\n", + "plt.suptitle('Quadratic Sequence')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Printing the Quadratic DDS Program\n", + "\n", + "Note that Quadratic DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", + "\n", + "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", + "\n", + "The `I` in the program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", + "\n", + "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", + "\n", + "At the end of each program, we place a `MEASURE` operator to read out the result." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PRAGMA PRESERVE_BLOCK\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RZ(pi) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "DECLARE ro BIT[1]\n", + "MEASURE 1 ro[0]\n", + "PRAGMA END_PRESERVE_BLOCK\n", + "\n" + ] + } + ], + "source": [ + "print(quadratic_program.out())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Printing the Ramsey DDS Program\n", "\n", - "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;1-qubit device in this case.\n", + "Similar to Quadratic program, Ramsey program has $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. In between there are 99 `I` gates corresponding to the interval $99\\times 50ns=4.95\\mu$s interval (close to the desired $5\\mu$s) between the $X_{\\pi/2}$ intervals.\n", + "\n", + "At the end of each program, we place a `MEASURE` operator to read out the result." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PRAGMA PRESERVE_BLOCK\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "DECLARE ro BIT[1]\n", + "MEASURE 1 ro[0]\n", + "PRAGMA END_PRESERVE_BLOCK\n", + "\n" + ] + } + ], + "source": [ + "print(ramsey_program.out())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compiling and running the pograms on Virtual Quantum Device\n", + "\n", + "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;\n", "\n", "NOTE: You will require ForestSDK to run the following segments. You need to start the the Quil Compiler and QVM in server mode. Execute the following commands in separate prompts.\n", "\n", @@ -216,12 +588,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# NBVAL_SKIP\n", - "quantum_device = get_qc(\"1q-qvm\")" + "quantum_device = get_qc(\"Aspen-4-2Q-A\", as_qvm=True)" ] }, { @@ -243,123 +615,136 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "# We loop the program in order to run it several times\n", + "'''\n", + "trials : int\n", + " An integer denoting the number of repeats of the program on quantum device\n", + "'''\n", + "trials=1000\n", + "quadratic_program = quadratic_program.wrap_in_numshots_loop(trials)\n", + "\n", + "##Compiling the quadratic program\n", + "executable_quadratic_program = quantum_device.compile(quadratic_program)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "DECLARE qubit-0 BIT[1]\n", - "RX(pi/2) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RZ(pi) 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "I 0\n", - "RX(pi/2) 0\n", - "MEASURE 0 qubit-0[0]\n", - "HALT\n", + "DECLARE ro BIT[1]\n", + "RX(pi/2) 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "I 1\n", + "RX(pi/2) 1\n", + "MEASURE 1 ro[0]\n", "\n" ] } @@ -367,10 +752,18 @@ "source": [ "# NBVAL_SKIP\n", "\n", + "# We loop the program in order to run it several times\n", + "'''\n", + "trials : int\n", + " An integer denoting the number of repeats of the program on quantum device\n", + "'''\n", + "trials=1000\n", + "ramsey_program = ramsey_program.wrap_in_numshots_loop(trials)\n", + "\n", "##Compiling the quadratic program\n", - "executable_quadratic_program = quantum_device.compile(quadratic_program)\n", + "executable_ramsey_program = quantum_device.compile(ramsey_program)\n", "## print the compiled program\n", - "print(executable_quadratic_program.program)" + "print(executable_ramsey_program.program)" ] }, { @@ -384,24 +777,22 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "def plot_trial_outcomes(trial_result, qubit = 0):\n", - " \"\"\"Plots the trial result as probabilities.\n", + "def plot_trial_outcomes(trial_result):\n", + " \"\"\"Plots the trial result as probabilities. Expects results from runs involving only\n", + " single qubit\n", " Parameters\n", " ----------\n", - " trial_result : dict\n", - " A dict where the key is the target qubits and value is a numy array of size\n", - " containing outcome of each trial in computational basis.\n", - " qubit: int\n", - " An interger corresponding to the target qubit.\n", + " trial_result : numpy.ndarray\n", + " An array where each row contains the output trials in computational basis.\n", " \"\"\"\n", " \n", - " qubit_trial_result = trial_result[qubit]\n", + " qubit_trial_result = trial_result[:, 0]\n", " \n", - " number_of_trials = qubit_trial_result.shape[0]\n", + " number_of_trials = qubit_trial_result.shape\n", " \n", " outcome = np.array([number_of_trials-np.sum(qubit_trial_result), np.sum(qubit_trial_result)])\n", " outcome_probabilities = outcome / number_of_trials\n", @@ -415,12 +806,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAQWElEQVR4nO3de7BdZX3G8e9DIgJya02sShJCJWpR66VHwDLj/RKghRm1FmaYimVMb1Qt1SlWxYrOeKeODlUzhUKx5eJl2lSj1FrA8YLNASyaKJ1ItQSdEhQRpQKxv/6xF7g5Ocnep2TtnfB+PzOZs9a73r32b2cy58n7vmuvlapCktSuvaZdgCRpugwCSWqcQSBJjTMIJKlxBoEkNW7xtAtYqCVLltTKlSunXYYk7VGuueaaW6tq6XzH9rggWLlyJbOzs9MuQ5L2KEm+s6NjTg1JUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxvUWBEnOT3JLkq/v4HiSvD/J5iTXJ3laX7VIknaszxHBBcDqnRw/FljV/VkDfLDHWiRJO9BbEFTV54Ef7KTLicDf1sDVwMFJHtVXPZKk+U3zm8WHADcN7W/p2r43t2OSNQxGDaxYsWIixUnTsPLMT027BO3Gvv2O43s57x6xWFxVa6tqpqpmli6d91YZkqT/p2kGwc3A8qH9ZV2bJGmCphkE64Df6a4eOhq4vaq2mxaSJPWrtzWCJBcDzwaWJNkCvBl4CEBVfQhYDxwHbAbuBF7RVy2SpB3rLQiq6uQRxwv4o77eX5I0nj1isViS1B+DQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxvUaBElWJ7khyeYkZ85zfEWSK5Jcl+T6JMf1WY8kaXu9BUGSRcC5wLHAEcDJSY6Y0+2NwGVV9VTgJOCv+qpHkjS/PkcERwKbq+rGqrobuAQ4cU6fAg7stg8CvttjPZKkefQZBIcANw3tb+nahv0FcEqSLcB64I/nO1GSNUlmk8xu3bq1j1olqVnTXiw+GbigqpYBxwEXJdmupqpaW1UzVTWzdOnSiRcpSQ9mfQbBzcDyof1lXduw04DLAKrqy8A+wJIea5IkzdFnEGwAViU5LMneDBaD183p81/A8wCS/AqDIHDuR5ImqLcgqKptwOnA5cA3GFwdtDHJ2UlO6Lr9KfDKJP8OXAycWlXVV02SpO0t7vPkVbWewSLwcNtZQ9ubgGP6rEGStHPTXiyWJE2ZQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS48YKgiTvSnJgkock+VySrUlO6bs4SVL/xh0RvLCqfgT8BvBt4HDgdX0VJUmanHGDYHH383jgo1V1e0/1SJImbPHoLgB8Msk3gf8B/iDJUuCn/ZUlSZqUsUYEVXUm8OvATFXdA9wJnNhnYZKkyRh3sXg/4A+BD3ZNjwZm+ipKkjQ5464R/A1wN4NRAcDNwNt6qUiSNFHjBsFjqupdwD0AVXUnkN6qkiRNzLhBcHeSfYECSPIY4K5RL0qyOskNSTYnOXMHfV6WZFOSjUn+fuzKJUm7xLhXDb0Z+AywPMnfAccAp+7sBUkWAecCLwC2ABuSrKuqTUN9VgGvB46pqtuSPGLhH0GS9ECMFQRV9dkk1wJHM5gSenVV3TriZUcCm6vqRoAklzC40mjTUJ9XAudW1W3d+9yywPolSQ/QTqeGkjy++/k04FDge8B3gRVd284cAtw0tL+laxv2WOCxSb6Y5OokqxdSvCTpgRs1IjgDWAO8d55jBTx3F7z/KuDZwDLg80meVFU/HO6UZE1XBytWrHiAbylJGrbTIKiqNd3msVV1v28SJ9lnxLlvBpYP7S/r2oZtAb7SfUntP5P8B4Ng2DCnjrXAWoCZmZka8b6SpAUY96qhL43ZNmwDsCrJYUn2Bk4C1s3p8w8MRgMkWcJgqujGMWuSJO0COx0RJHkkg3n9fZM8lZ9/d+BAYL+dvbaqtiU5HbgcWAScX1Ubk5wNzFbVuu7YC5NsAn4GvK6qvv+APpEkaUFGrRG8iMFlosuAc4ba7wD+fNTJq2o9sH5O21lD28VgHeKM8cqVJO1qo9YILgQuTPKSqvr4hGqSJE3QqKmhU6rqI8DKJNv9r72qzpnnZZKkPcioqaGHdT/377sQSdJ0jJoa+nD38y2TKUeSNGmjpobev7PjVfWqXVuOJGnSRk0NXTORKiRJUzPOVUOSpAexUVND76uq1yT5J7pnEQyrqhN6q0ySNBGjpoYu6n6+p+9CJEnTMWpq6Jru51Xd/YIez2BkcENV3T2B+iRJPRvrwTRJjgc+BHyLwf2GDkvye1X16T6LkyT1b9xHVb4XeE5VbYb7nln8KcAgkKQ93Li3ob7j3hDo3MjgxnOSpD3cqKuGXtxtziZZD1zGYI3gt5jz8BhJ0p5p1NTQbw5t/zfwrG57K7BvLxVJkiZq1FVDr5hUIZKk6Rj3qqF9gNOAJwD3Pau4qn63p7okSRMy7mLxRcAjGTyx7CoGTyxzsViSHgTGDYLDq+pNwE+6+w8dDxzVX1mSpEkZNwju6X7+MMkTgYOAR/RTkiRpksb9QtnaJL8AvAlYx+CJZW/qrSpJ0sSMFQRV9dfd5lXAL/dXjiRp0saaGkry8CQfSHJtkmuSvC/Jw/suTpLUv3HXCC4BbgFeArwUuBW4tK+iJEmTM+4awaOq6q1D+29L8tt9FCRJmqxxRwT/nOSkJHt1f14GXN5nYZKkyRh107k7GNxkLsBrgI90h/YCfgy8ttfqJEm9G3WvoQMmVYgkaTrGXSMgyQnAM7vdK6vqk/2UJEmapHEvH30H8GpgU/fn1Une3mdhkqTJGHdEcBzwlKr6X4AkFwLXAa/vqzBJ0mSMe9UQwMFD2wft6kIkSdMx7ojg7cB1Sa5gcAXRM4Eze6tKkjQxI0cESQJ8ATga+ATwceAZVTXym8VJVie5IcnmJDsMjiQvSVJJZhZQuyRpFxg5IqiqSrK+qp7E4M6jY0myCDgXeAGwBdiQZF1VbZrT7wAGC9FfWVDlkqRdYtw1gmuTPH2B5z4S2FxVN1bV3QzuV3TiPP3eCrwT+OkCzy9J2gXGDYKjgKuTfCvJ9Um+luT6Ea85BLhpaH9L13afJE8DllfVp3Z2oiRrkswmmd26deuYJUuSxjHuYvGLdvUbJ9kLOAc4dVTfqloLrAWYmZmpXV2LJLVs1L2G9gF+Hzgc+BpwXlVtG/PcNwPLh/aXdW33OgB4InDlYD2aRwLrkpxQVbNjvock6QEaNTV0ITDDIASOBd67gHNvAFYlOSzJ3sBJDC02V9XtVbWkqlZW1UrgasAQkKQJGzU1dER3tRBJzgP+bdwTV9W2JKczuF31IuD8qtqY5GxgtqrGvgJJktSfUUFwz70b3S/2BZ28qtYD6+e0nbWDvs9e0MklSbvEqCB4cpIfddsB9u32w+ArBgf2Wp0kqXejnkewaFKFSJKmYyE3nZMkPQgZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjes1CJKsTnJDks1Jzpzn+BlJNiW5PsnnkhzaZz2SpO31FgRJFgHnAscCRwAnJzliTrfrgJmq+lXgY8C7+qpHkjS/PkcERwKbq+rGqrobuAQ4cbhDVV1RVXd2u1cDy3qsR5I0jz6D4BDgpqH9LV3bjpwGfHq+A0nWJJlNMrt169ZdWKIkabdYLE5yCjADvHu+41W1tqpmqmpm6dKlky1Okh7kFvd47puB5UP7y7q2+0nyfOANwLOq6q4e65EkzaPPEcEGYFWSw5LsDZwErBvukOSpwIeBE6rqlh5rkSTtQG9BUFXbgNOBy4FvAJdV1cYkZyc5oev2bmB/4KNJvppk3Q5OJ0nqSZ9TQ1TVemD9nLazhraf3+f7S5JG2y0WiyVJ02MQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhrXaxAkWZ3khiSbk5w5z/GHJrm0O/6VJCv7rEeStL3egiDJIuBc4FjgCODkJEfM6XYacFtVHQ78JfDOvuqRJM2vzxHBkcDmqrqxqu4GLgFOnNPnRODCbvtjwPOSpMeaJElzLO7x3IcANw3tbwGO2lGfqtqW5Hbg4cCtw52SrAHWdLs/TnJDLxW3Zwlz/q6l3Yz/Rofkgc2ZHLqjA30GwS5TVWuBtdOu48EmyWxVzUy7DmlH/Dc6GX1ODd0MLB/aX9a1zdsnyWLgIOD7PdYkSZqjzyDYAKxKcliSvYGTgHVz+qwDXt5tvxT416qqHmuSJM3R29RQN+d/OnA5sAg4v6o2JjkbmK2qdcB5wEVJNgM/YBAWmhyn27S789/oBMT/gEtS2/xmsSQ1ziCQpMYZBA0adesPadqSnJ/kliRfn3YtLTAIGjPmrT+kabsAWD3tIlphELRnnFt/SFNVVZ9ncCWhJsAgaM98t/44ZEq1SNoNGASS1DiDoD3j3PpDUkMMgvaMc+sPSQ0xCBpTVduAe2/98Q3gsqraON2qpPtLcjHwZeBxSbYkOW3aNT2YeYsJSWqcIwJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBNIcSd6QZGOS65N8NclRSV6TZL8xXjtWP2l34uWj0pAkzwDOAZ5dVXclWQLsDXwJmKmqW0e8/tvj9JN2J44IpPt7FHBrVd0F0P1CfynwaOCKJFcAJPlgktlu5PCWru1V8/R7YZIvJ7k2yUeT7N+1vyPJpm7U8Z7Jf0zp5xwRSEO6X9RfAPYD/gW4tKqumvs//SS/WFU/6J7v8DngVVV1/XC/bjTxCeDYqvpJkj8DHsrgeRBfAh5fVZXk4Kr64aQ/q3QvRwTSkKr6MfBrwBpgK3BpklPn6fqyJNcC1wFPYPCQn7mO7tq/mOSrwMuBQ4HbgZ8C5yV5MXDnrv4c0kIsnnYB0u6mqn4GXAlcmeRrDH6B3yfJYcBrgadX1W1JLgD2medUAT5bVSdvdyA5Engeg2mn04Hn7srPIC2EIwJpSJLHJVk11PQU4DvAHcABXduBwE+A25P8EoPHft5ruN/VwDFJDu/O/bAkj+2mnw6qqvXAnwBP7u0DSWNwRCDd3/7AB5IcDGwDNjOYJjoZ+EyS71bVc5JcB3yTwdPevjj0+rVz+p0KXJzkod3xNzIIi39Msg+DUcMZk/hg0o64WCxJjXNqSJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxv0fd3zuTA5+VdIAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -434,15 +825,114 @@ "source": [ "# NBVAL_SKIP\n", "\n", - "'''\n", - "trials : int\n", - " An integer denoting the number of repeats of the program on quantum device\n", - "'''\n", - "trials=100\n", "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run_and_measure(quadratic_program, trials=trials)\n", + "quadratic_result = quantum_device.run(executable_quadratic_program)\n", "plot_trial_outcomes(quadratic_result)" ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "ramsey_result = quantum_device.run(executable_ramsey_program)\n", + "plot_trial_outcomes(ramsey_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compiling and running the pograms on Rigetti Quantum Device\n", + "\n", + "We can use the programs created before. However, this time we need to get a real device. You have to have an access to a Rigetti lattice. Follow [the steps](https://www.rigetti.com/) to get an account to access a Rigetti lattice. Once you have account, follow the instructions to [reserve a lattice](https://www.rigetti.com/qcs/docs/reservations) and [run a jupyter notebook](https://www.rigetti.com/qcs/docs/guides#setting-up-a-jupyter-notebook-on-your-qmi)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "It looks like you've tried to run a program against a QPU but do\n not currently have a reservation on one. To reserve time on Rigetti\n QPUs, use the command line interface, qcs, which comes pre-installed\n in your QMI. From within your QMI, type:\n\n qcs reserve --lattice \n\nFor more information, please see the docs at\nhttps://www.rigetti.com/qcs/docs/reservations or reach out to Rigetti\nsupport at support@rigetti.com.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m----------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0mTraceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Get the reserved lattice. In this case we are using 'Aspen-4-2Q-A' - change this to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# the one you reserve\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mquantum_device\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_qc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Aspen-4-2Q-A\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mas_qvm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_error_reporting.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mglobal_error_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_entry\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;31m# poke the return value of that call in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_quantum_computer.py\u001b[0m in \u001b[0;36mget_qc\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 620\u001b[0m qam=QPU(\n\u001b[1;32m 621\u001b[0m \u001b[0mendpoint\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpyquil_config\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqpu_url\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 622\u001b[0;31m user=pyquil_config.user_id),\n\u001b[0m\u001b[1;32m 623\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 624\u001b[0m compiler=QPUCompiler(\n", + "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_error_reporting.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mglobal_error_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_entry\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;31m# poke the return value of that call in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_qpu.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, endpoint, user, priority)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0mFor\u001b[0m \u001b[0mmore\u001b[0m \u001b[0minformation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplease\u001b[0m \u001b[0msee\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdocs\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0mhttps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m//\u001b[0m\u001b[0mwww\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrigetti\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcom\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mqcs\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mdocs\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mreservations\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mreach\u001b[0m \u001b[0mout\u001b[0m \u001b[0mto\u001b[0m \u001b[0mRigetti\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m support at support@rigetti.com.\"\"\")\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mendpoint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: It looks like you've tried to run a program against a QPU but do\n not currently have a reservation on one. To reserve time on Rigetti\n QPUs, use the command line interface, qcs, which comes pre-installed\n in your QMI. From within your QMI, type:\n\n qcs reserve --lattice \n\nFor more information, please see the docs at\nhttps://www.rigetti.com/qcs/docs/reservations or reach out to Rigetti\nsupport at support@rigetti.com." + ] + } + ], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "# Get the reserved lattice. In this case we are using 'Aspen-4-2Q-A' - change this to\n", + "# the one you reserve\n", + "quantum_device = get_qc(\"Aspen-4-2Q-A\", as_qvm=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NBVAL_SKIP\n", + "\n", + "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "quadratic_result = quantum_device.run(executable_quadratic_program)\n", + "plot_trial_outcomes(quadratic_result)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", + "ramsey_result = quantum_device.run(executable_ramsey_program)\n", + "plot_trial_outcomes(ramsey_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reducing Errors by Increasing the Coherence Time\n", + "\n", + "In the ideal noiseless simulator, both the Ramsey DDS and Quadratic DDS produced exactly the same outcome, the $|1 \\rangle$ state with probability 1. However, in a real device, we can see a marked difference. The Quadratic DDS produced a probability distribution closer to the expected outcome. This is because the Quadratic DDS is able to cancel the effects of magnetic noise in the environment - extending the [T2 time](https://en.wikipedia.org/wiki/Spin–spin_relaxation), and effectively increasing the coherence of the qubit." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index 8cc66bed..cc71e6d9 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -140,6 +140,7 @@ def convert_dds_to_pyquil_program( time_covered = 0 program = Program() + #program += Pragma('INITIAL_REWIRING', ['"GREEDY"']) program += Pragma('PRESERVE_BLOCK') for operation_idx in range(operations.shape[1]): @@ -200,10 +201,14 @@ def convert_dds_to_pyquil_program( time_covered = offsets[operation_idx] + unitary_time if add_measurement: - for qubit in target_qubits: - bit_name = 'qubit-{}'.format(qubit) - measurement_bit = program.declare(bit_name, 'BIT', 1) - program += MEASURE(qubit, measurement_bit) + #for qubit in target_qubits: + # bit_name = 'ro'.format(qubit) + # measurement_bit = program.declare(bit_name, 'BIT', 1) + # program += MEASURE(qubit, measurement_bit) + readout = program.declare('ro', 'BIT', len(target_qubits)) + for idx, qubit in enumerate(target_qubits): + program += MEASURE(qubit, readout[idx]) + program += Pragma('END_PRESERVE_BLOCK') return program From d80b0668ae0440198ae9d1b750c77656a747656d Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Mon, 1 Jul 2019 15:43:01 +1000 Subject: [PATCH 07/16] version of pyquil notebook working with Rigetti lattice --- examples/export_a_dds_to_pyquil.ipynb | 226 +++++++------------------- 1 file changed, 60 insertions(+), 166 deletions(-) diff --git a/examples/export_a_dds_to_pyquil.ipynb b/examples/export_a_dds_to_pyquil.ipynb index 9a447848..cd73618e 100755 --- a/examples/export_a_dds_to_pyquil.ipynb +++ b/examples/export_a_dds_to_pyquil.ipynb @@ -54,7 +54,7 @@ "\n", "Converting a DDS into a Pyquil program is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](XXXX).\n", "\n", - "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We add a $X_{\\pi/2}$ rotation on either end of the sequence." + "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator and on a real device. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We also create a Ramsey DDS of the same duration to compare as a benchmark. For both the sequences, we add a $X_{\\pi/2}$ rotation on either end of the sequence." ] }, { @@ -116,23 +116,14 @@ "\n", "To construct a `Program` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`.\n", "\n", - "In this example, we will use $0$th qubit and specify the `gate_time` to be $50$ $n$s (see same [specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." + "In this example, we will use $1$st qubit and specify the `gate_time` to be $50$ $n$s (see same [specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ro[0]\n", - "ro[0]\n" - ] - } - ], + "outputs": [], "source": [ "## Prepare the Pyquil related parameters\n", "'''\n", @@ -187,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -244,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -311,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -450,7 +441,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -588,7 +579,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -615,7 +606,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -630,125 +621,14 @@ "quadratic_program = quadratic_program.wrap_in_numshots_loop(trials)\n", "\n", "##Compiling the quadratic program\n", - "executable_quadratic_program = quantum_device.compile(quadratic_program)" + "executable_quadratic_program_for_qvm = quantum_device.compile(quadratic_program)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DECLARE ro BIT[1]\n", - "RX(pi/2) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RX(pi/2) 1\n", - "MEASURE 1 ro[0]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# NBVAL_SKIP\n", "\n", @@ -761,9 +641,7 @@ "ramsey_program = ramsey_program.wrap_in_numshots_loop(trials)\n", "\n", "##Compiling the quadratic program\n", - "executable_ramsey_program = quantum_device.compile(ramsey_program)\n", - "## print the compiled program\n", - "print(executable_ramsey_program.program)" + "executable_ramsey_program_for_qvm = quantum_device.compile(ramsey_program)\n" ] }, { @@ -777,7 +655,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -806,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -824,15 +702,13 @@ ], "source": [ "# NBVAL_SKIP\n", - "\n", - "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run(executable_quadratic_program)\n", + "quadratic_result = quantum_device.run(executable_quadratic_program_for_qvm)\n", "plot_trial_outcomes(quadratic_result)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -852,7 +728,7 @@ "# NBVAL_SKIP\n", "\n", "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "ramsey_result = quantum_device.run(executable_ramsey_program)\n", + "ramsey_result = quantum_device.run(executable_ramsey_program_for_qvm)\n", "plot_trial_outcomes(ramsey_result)" ] }, @@ -869,23 +745,7 @@ "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "It looks like you've tried to run a program against a QPU but do\n not currently have a reservation on one. To reserve time on Rigetti\n QPUs, use the command line interface, qcs, which comes pre-installed\n in your QMI. From within your QMI, type:\n\n qcs reserve --lattice \n\nFor more information, please see the docs at\nhttps://www.rigetti.com/qcs/docs/reservations or reach out to Rigetti\nsupport at support@rigetti.com.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m----------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0mTraceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Get the reserved lattice. In this case we are using 'Aspen-4-2Q-A' - change this to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# the one you reserve\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mquantum_device\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_qc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Aspen-4-2Q-A\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mas_qvm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_error_reporting.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mglobal_error_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_entry\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;31m# poke the return value of that call in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_quantum_computer.py\u001b[0m in \u001b[0;36mget_qc\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 620\u001b[0m qam=QPU(\n\u001b[1;32m 621\u001b[0m \u001b[0mendpoint\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpyquil_config\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqpu_url\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 622\u001b[0;31m user=pyquil_config.user_id),\n\u001b[0m\u001b[1;32m 623\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 624\u001b[0m compiler=QPUCompiler(\n", - "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_error_reporting.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mglobal_error_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_entry\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;31m# poke the return value of that call in\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.virtualenvs/venv/lib/python3.6/site-packages/pyquil/api/_qpu.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, endpoint, user, priority)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0mFor\u001b[0m \u001b[0mmore\u001b[0m \u001b[0minformation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplease\u001b[0m \u001b[0msee\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdocs\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0mhttps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m//\u001b[0m\u001b[0mwww\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrigetti\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcom\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mqcs\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mdocs\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mreservations\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mreach\u001b[0m \u001b[0mout\u001b[0m \u001b[0mto\u001b[0m \u001b[0mRigetti\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m support at support@rigetti.com.\"\"\")\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mendpoint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mRuntimeError\u001b[0m: It looks like you've tried to run a program against a QPU but do\n not currently have a reservation on one. To reserve time on Rigetti\n QPUs, use the command line interface, qcs, which comes pre-installed\n in your QMI. From within your QMI, type:\n\n qcs reserve --lattice \n\nFor more information, please see the docs at\nhttps://www.rigetti.com/qcs/docs/reservations or reach out to Rigetti\nsupport at support@rigetti.com." - ] - } - ], + "outputs": [], "source": [ "# NBVAL_SKIP\n", "\n", @@ -896,25 +756,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# NBVAL_SKIP\n", "\n", + "## Compiling the quadratic program for the chosen real lattice\n", + "executable_quadratic_program_for_lattice = quantum_device.compile(quadratic_program)\n", + "\n", "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run(executable_quadratic_program)\n", + "quadratic_result = quantum_device.run(executable_quadratic_program_for_lattice)\n", "plot_trial_outcomes(quadratic_result)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEICAYAAABS0fM3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAATN0lEQVR4nO3dfZBdd33f8fcHucI82aR40xBJtlQsQpU0gWYRtEx5JpFwK3UCIVLKDG7daDKtYohLBtEEN1EyE/IEmaQaigoUDynIgnbaTdhGocSmBUxG64eYSkZkozrRiraswTg8DDZKvv3jHtHrq6u9V9Keu5LO+zWzc8/vd37n3O+d2dnP/s4595xUFZKk7nrCShcgSVpZBoEkdZxBIEkdZxBIUscZBJLUcQaBJHVcq0GQZEuSY0nmk+wZsv7aJHckuTfJ/Ule3WY9kqQzpa3vESRZBXweeBWwABwGdlbV0b4x+4F7q+pdSTYBs1W1fqn9XnPNNbV+/ZJDJEkD7r777oeqamrYuitafN/NwHxVHQdIcgDYDhztG1PAVc3y1cAXRu10/fr1zM3NLXOpknR5S/JnZ1vXZhCsAU70tReAFwyM+XngD5L8FPAU4JUt1iNJGmKlTxbvBN5fVWuBVwMfSHJGTUl2JZlLMre4uDjxIiXpctZmEJwE1vW11zZ9/W4CDgJU1V3AlcA1gzuqqv1VNV1V01NTQw9xSZLOU5tBcBjYmGRDktXADmBmYMyfA68ASPK36AWB//JL0gS1FgRVdQrYDRwCHgAOVtWRJHuTbGuG/UvgJ5L8MfAh4MbydqiSNFFtniymqmaB2YG+W/uWjwIvarMGSdLSVvpksSRphRkEktRxBoEkdVyr5wgknZv1ez660iXoIvbg229oZb/OCCSp4wwCSeo4g0CSOs4gkKSOMwgkqeMMAknqOINAkjrOIJCkjjMIJKnjDAJJ6jiDQJI6ziCQpI4zCCSp4wwCSeq4VoMgyZYkx5LMJ9kzZP07k9zX/Hw+yVfarEeSdKbWnkeQZBWwD3gVsAAcTjLTPKcYgKr66b7xPwU8r616JEnDtTkj2AzMV9XxqnoMOABsX2L8TuBDLdYjSRqizSBYA5zoay80fWdIch2wAfjDFuuRJA1xsZws3gF8pKr+ctjKJLuSzCWZW1xcnHBpknR5azMITgLr+tprm75hdrDEYaGq2l9V01U1PTU1tYwlSpLaDILDwMYkG5KspvfHfmZwUJLnAN8B3NViLZKks2gtCKrqFLAbOAQ8ABysqiNJ9ibZ1jd0B3CgqqqtWiRJZ9fa5aMAVTULzA703TrQ/vk2a5AkLe1iOVksSVohBoEkdZxBIEkdZxBIUscZBJLUcQaBJHWcQSBJHWcQSFLHGQSS1HEGgSR1nEEgSR1nEEhSxxkEktRxBoEkdZxBIEkdZxBIUscZBJLUcQaBJHVcq0GQZEuSY0nmk+w5y5jXJTma5EiSD7ZZjyTpTK09szjJKmAf8CpgATicZKaqjvaN2Qi8FXhRVT2c5DvbqkeSNFybM4LNwHxVHa+qx4ADwPaBMT8B7KuqhwGq6ost1iNJGqLNIFgDnOhrLzR9/Z4NPDvJp5J8JsmWYTtKsivJXJK5xcXFlsqVpG5a6ZPFVwAbgZcCO4F/l+Tpg4Oqan9VTVfV9NTU1IRLlKTLW5tBcBJY19de2/T1WwBmqupbVfW/gM/TCwZJ0oS0GQSHgY1JNiRZDewAZgbG/Gd6swGSXEPvUNHxFmuSJA1oLQiq6hSwGzgEPAAcrKojSfYm2dYMOwR8KclR4A7gZ6rqS23VJEk6U2uXjwJU1SwwO9B3a99yAbc0P5KkFbDSJ4slSSvMIJCkjjMIJKnjDAJJ6jiDQJI6ziCQpI4zCCSp4wwCSeo4g0CSOs4gkKSOMwgkqeMMAknqOINAkjrOIJCkjjMIJKnjDAJJ6jiDQJI6ziCQpI5rNQiSbElyLMl8kj1D1t+YZDHJfc3PP2uzHknSmcYKgiS/muSqJH8tycebP96vH7HNKmAfsBXYBOxMsmnI0Nur6rnNz3vO+RNIki7IuDOCH6qqvwD+AfAgcD3wMyO22QzMV9XxqnoMOABsP99CJUntGDcIrmhebwA+XFWPjLHNGuBEX3uh6Rv0miT3J/lIknXDdpRkV5K5JHOLi4tjlixJGse4QfB7ST4H/CDw8SRTwDeX4f1/F1hfVd8PfAy4bdigqtpfVdNVNT01NbUMbytJOm2sIKiqPcDfA6ar6lvANxh9mOck0P8f/tqmr3+/X6qqR5vme+gFjSRpgsY9Wfxk4J8D72q6vhuYHrHZYWBjkg1JVgM7gJmB/T6zr7kNeGCceiRJy2fcQ0P/HniM3qwAev/Z/9JSG1TVKWA3cIjeH/iDVXUkyd4k25phNyc5kuSPgZuBG8+xfknSBbpi9BAAnlVVP5ZkJ0BVfSNJRm1UVbPA7EDfrX3LbwXeeg71SpKW2bgzgseSPAkogCTPAh5dehNJ0qVg3BnBvwZ+H1iX5D8AL8LDOJJ0WRgrCKrqY0nuAV4IBHhjVT3UamWSpIlY8tBQkuc0r38HuA7438AXgGubPknSJW7UjOAWYBfwG0PWFfDyZa9IkjRRSwZBVe1qFrdW1eO+SZzkytaqkiRNzLhXDX16zD5J0iVmyRlBku+id6O4JyV5Hr0TxQBXAU9uuTZJ0gSMOkfww/QuE10LvKOv/6vAv2qpJknSBI06R3AbcFuS11TVf5xQTZKkCRp1aOj1VfU7wPoktwyur6p3DNlMknQJGXVo6CnN61PbLkSStDJGHRp6d/P6C5MpR5I0aaMODf3WUuur6ublLUeSNGmjDg3dPZEqJEkrZpyrhiRJl7FRh4Z+s6relOR3aZ5F0K+qtg3ZTJJ0CRl1aOgDzeuvt12IJGllLHmvoaq6u3n9BHAX8DDwZeCupm9JSbYkOZZkPsmeJca9JkklmT638iVJF2qsm84luQH4U+C3gH8DzCfZOmKbVcA+YCuwCdiZZNOQcU8D3gj80bmVLklaDuPeffQ3gJdV1Uur6iXAy4B3jthmMzBfVcer6jHgALB9yLhfBH4F+OaQdZKklo0bBF+tqvm+9nF6N55byhrgRF97oen7tuYpZ+uq6qNL7SjJriRzSeYWFxfHLFmSNI5RVw39SLM4l2QWOEjv6qEfBQ5fyBsneQK9O5reOGpsVe0H9gNMT0+fcfWSJOn8jbpq6B/2Lf9f4CXN8iLwpBHbngTW9bXXNn2nPQ34PuDOJADfBcwk2VZVcyP2LUlaJqO+UPZPLmDfh4GNSTbQC4AdwI/37fsR4JrT7SR3Am82BCRpskbNCIBvP5/4JuB7gW8/q7iq/unZtqmqU0l2A4eAVcD7qupIkr3AXFXNXFDlkqRlMVYQ0Pti2efoPbFsL/CPgQdGbVRVs8DsQN+tZxn70jFrkSQto3GvGrq+qt4GfL25/9ANwAvaK0uSNCnjBsG3mtevJPk+4GrgO9spSZI0SeMeGtqf5DuAtwEz9J5Y9rbWqpIkTcxYQVBV72kWPwH8zfbKkSRN2rj3GnpGkt9Ock+Su5P8ZpJntF2cJKl9454jOAB8EXgN8FrgIeD2toqSJE3OuOcInllVv9jX/qUkP9ZGQZKkyRp3RvAHSXYkeULz8zp6XxSTJF3iRt107qv0bjIX4E3A7zSrngB8DXhzq9VJklo36l5DT5tUIZKklTHuOQKSbANe3DTvrKrfa6ckSdIkjXv56NvpPU7yaPPzxiS/3GZhkqTJGHdG8GrguVX1VwBJbgPuBd7aVmGSpMkY96ohgKf3LV+93IVIklbGuDOCXwbuTXIHvSuIXgzsaa0qSdLEjAyC9J4j+UnghcDzm+63VNX/abMwSdJkjAyCqqoks1X1t+ndeVSSdBkZ9xzBPUmeP3qYJOlSM24QvAD4TJI/TXJ/ks8muX/URkm2JDmWZD7JGecUkvxks6/7knwyyaZz/QCSpAsz7sniHz7XHSdZBewDXgUsAIeTzFTV0b5hH6yqf9uM3wa8A9hyru8lSTp/o+41dCXwk8D1wGeB91bVqTH3vRmYr6rjzb4OANvpfSENgKr6i77xT6F3XyNJ0gSNmhHcRu95xf8D2ApsovcN43GsAU70tRcY8sD7JP8CuAVYDbx82I6S7AJ2AVx77bVjvr0kaRyjzhFsqqrXV9W76T2Q5u8vdwFVta+qngW8Bfi5s4zZX1XTVTU9NTW13CVIUqeNCoJvnV44h0NCp50E1vW11zZ9Z3MA+Efn+B6SpAs06tDQDyQ5fRw/wJOaduh9xeCqJbY9DGxMsoFeAOwAfrx/QJKNVfUnTfMG4E+QJE3UqOcRrDrfHVfVqSS76T3JbBXwvqo6kmQvMFdVM8DuJK+kN/N4GHjD+b6fJOn8jP08gvNRVbPA7EDfrX3L4554liS15FzuPipJugwZBJLUcQaBJHWcQSBJHWcQSFLHGQSS1HEGgSR1nEEgSR1nEEhSxxkEktRxBoEkdZxBIEkdZxBIUse1evfRi836PR9d6RJ0EXvw7TesdAnSinBGIEkdZxBIUscZBJLUcQaBJHVcq0GQZEuSY0nmk+wZsv6WJEeT3J/k40mua7MeSdKZWguCJKuAfcBWYBOwM8mmgWH3AtNV9f3AR4BfbaseSdJwbc4INgPzVXW8qh4DDgDb+wdU1R1V9Y2m+RlgbYv1SJKGaDMI1gAn+toLTd/Z3AT812ErkuxKMpdkbnFxcRlLlCRdFCeLk7wemAZ+bdj6qtpfVdNVNT01NTXZ4iTpMtfmN4tPAuv62mubvsdJ8krgZ4GXVNWjLdYjSRqizRnBYWBjkg1JVgM7gJn+AUmeB7wb2FZVX2yxFknSWbQWBFV1CtgNHAIeAA5W1ZEke5Nsa4b9GvBU4MNJ7ksyc5bdSZJa0upN56pqFpgd6Lu1b/mVbb6/JGm0i+JksSRp5RgEktRxBoEkdZxBIEkdZxBIUscZBJLUcQaBJHWcQSBJHWcQSFLHGQSS1HEGgSR1nEEgSR1nEEhSxxkEktRxBoEkdZxBIEkdZxBIUse1GgRJtiQ5lmQ+yZ4h61+c5J4kp5K8ts1aJEnDtRYESVYB+4CtwCZgZ5JNA8P+HLgR+GBbdUiSltbmM4s3A/NVdRwgyQFgO3D09ICqerBZ91ct1iFJWkKbh4bWACf62gtNnyTpInJJnCxOsivJXJK5xcXFlS5Hki4rbQbBSWBdX3tt03fOqmp/VU1X1fTU1NSyFCdJ6mkzCA4DG5NsSLIa2AHMtPh+kqTz0FoQVNUpYDdwCHgAOFhVR5LsTbINIMnzkywAPwq8O8mRtuqRJA3X5lVDVNUsMDvQd2vf8mF6h4wkSSvkkjhZLElqj0EgSR1nEEhSxxkEktRxBoEkdZxBIEkdZxBIUscZBJLUcQaBJHWcQSBJHWcQSFLHGQSS1HEGgSR1nEEgSR1nEEhSxxkEktRxBoEkdZxBIEkd12oQJNmS5FiS+SR7hqx/YpLbm/V/lGR9m/VIks7UWhAkWQXsA7YCm4CdSTYNDLsJeLiqrgfeCfxKW/VIkoZrc0awGZivquNV9RhwANg+MGY7cFuz/BHgFUnSYk2SpAFtBsEa4ERfe6HpGzqmqk4BjwDPaLEmSdKAK1a6gHEk2QXsappfS3JsJeu5jFwDPLTSRVws4oHJi5G/o30u8Hf0urOtaDMITgLr+tprm75hYxaSXAFcDXxpcEdVtR/Y31KdnZVkrqqmV7oO6Wz8HZ2MNg8NHQY2JtmQZDWwA5gZGDMDvKFZfi3wh1VVLdYkSRrQ2oygqk4l2Q0cAlYB76uqI0n2AnNVNQO8F/hAknngy/TCQpI0QfEf8O5Ksqs57CZdlPwdnQyDQJI6zltMSFLHGQQdNOrWH9JKS/K+JF9M8j9XupYuMAg6Zsxbf0gr7f3AlpUuoisMgu4Z59Yf0oqqqv9O70pCTYBB0D3j3PpDUocYBJLUcQZB94xz6w9JHWIQdM84t/6Q1CEGQcc0t/s+feuPB4CDVXVkZauSHi/Jh4C7gO9JspDkppWu6XLmN4slqeOcEUhSxxkEktRxBoEkdZxBIEkdZxBIUscZBNKAJD+b5EiS+5Pcl+QFSd6U5MljbDvWOOli4uWjUp8kfxd4B/DSqno0yTXAauDTwHRVPTRi+wfHGSddTJwRSI/3TOChqnoUoPmD/lrgu4E7ktwBkORdSeaamcMvNH03Dxn3Q0nuSnJPkg8neWrT//YkR5tZx69P/mNK/58zAqlP84f6k8CTgf8G3F5Vnxj8Tz/JX6+qLzfPd/g4cHNV3d8/rplN/Cdga1V9PclbgCfSex7Ep4HnVFUleXpVfWXSn1U6zRmB1Keqvgb8ILALWARuT3LjkKGvS3IPcC/wvfQe8jPohU3/p5LcB7wBuA54BPgm8N4kPwJ8Y7k/h3QurljpAqSLTVX9JXAncGeSz9L7A/5tSTYAbwaeX1UPJ3k/cOWQXQX4WFXtPGNFshl4Bb3DTruBly/nZ5DOhTMCqU+S70mysa/rucCfAV8Fntb0XQV8HXgkyd+g99jP0/rHfQZ4UZLrm30/Jcmzm8NPV1fVLPDTwA+09oGkMTgjkB7vqcBvJ3k6cAqYp3eYaCfw+0m+UFUvS3Iv8Dl6T3v7VN/2+wfG3Qh8KMkTm/U/Ry8s/kuSK+nNGm6ZxAeTzsaTxZLUcR4akqSOMwgkqeMMAknqOINAkjrOIJCkjjMIJKnjDAJJ6jiDQJI67v8Bj/ATPfU4GHcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ + "# NBVAL_SKIP\n", + "\n", + "## Compiling the ramsey program for the chosen real lattice\n", + "executable_ramsey_program_for_lattice = quantum_device.compile(ramsey_program)\n", + "\n", "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "ramsey_result = quantum_device.run(executable_ramsey_program)\n", + "ramsey_result = quantum_device.run(executable_ramsey_program_for_lattice)\n", "plot_trial_outcomes(ramsey_result)" ] }, From 593a5c1cd24e65daffa6ab8267c24a0c08cef9c2 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Mon, 1 Jul 2019 16:21:06 +1000 Subject: [PATCH 08/16] cleaned up pyquil program --- qctrlopencontrols/pyquil/program.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index cc71e6d9..5ef9ec56 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -140,7 +140,6 @@ def convert_dds_to_pyquil_program( time_covered = 0 program = Program() - #program += Pragma('INITIAL_REWIRING', ['"GREEDY"']) program += Pragma('PRESERVE_BLOCK') for operation_idx in range(operations.shape[1]): @@ -201,10 +200,6 @@ def convert_dds_to_pyquil_program( time_covered = offsets[operation_idx] + unitary_time if add_measurement: - #for qubit in target_qubits: - # bit_name = 'ro'.format(qubit) - # measurement_bit = program.declare(bit_name, 'BIT', 1) - # program += MEASURE(qubit, measurement_bit) readout = program.declare('ro', 'BIT', len(target_qubits)) for idx, qubit in enumerate(target_qubits): program += MEASURE(qubit, readout[idx]) From ba024e90aadf554e2e2c420d6f465a4d586a556f Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Mon, 1 Jul 2019 16:23:50 +1000 Subject: [PATCH 09/16] linted --- qctrlopencontrols/pyquil/program.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index 5ef9ec56..8a86c1d1 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -203,7 +203,7 @@ def convert_dds_to_pyquil_program( readout = program.declare('ro', 'BIT', len(target_qubits)) for idx, qubit in enumerate(target_qubits): program += MEASURE(qubit, readout[idx]) - + program += Pragma('END_PRESERVE_BLOCK') return program From 3b002b87af6a9ec6c45da71856505e46b625bebf Mon Sep 17 00:00:00 2001 From: CircleCI workflow Date: Mon, 1 Jul 2019 06:39:13 +0000 Subject: [PATCH 10/16] Update setup.py/README.rst to match pyproject.toml/README.md [ci skip] --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index b8724f42..a474ffd2 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ license='Apache-2.0', keywords='quantum computing open source engineering', classifiers=['Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Intended Audience :: Education', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: Apache Software License', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3.6', 'Topic :: Scientific/Engineering :: Physics', 'Topic :: Scientific/Engineering :: Visualization', 'Topic :: Software Development :: Embedded Systems', 'Topic :: System :: Distributed Computing'], - packages=['qctrlopencontrols', 'qctrlopencontrols.base', 'qctrlopencontrols.cirq', 'qctrlopencontrols.driven_controls', 'qctrlopencontrols.dynamic_decoupling_sequences', 'qctrlopencontrols.exceptions', 'qctrlopencontrols.globals', 'qctrlopencontrols.qiskit'], + packages=['qctrlopencontrols', 'qctrlopencontrols.base', 'qctrlopencontrols.cirq', 'qctrlopencontrols.driven_controls', 'qctrlopencontrols.dynamic_decoupling_sequences', 'qctrlopencontrols.exceptions', 'qctrlopencontrols.globals', 'qctrlopencontrols.pyquil', 'qctrlopencontrols.qiskit'], package_data={}, install_requires=['cirq==0.*,>=0.5.0', 'numpy==1.*,>=1.16.0', 'qiskit-ibmq-provider==0.*,>=0.2.2', 'qiskit-terra==0.*,>=0.8.1', 'scipy==1.*,>=1.3.0'], extras_require={'dev': ['pylama', 'pylint', 'pylint-runner', 'pytest']}, From bbcdebf23cec038c5362789e5f496e3888c791bb Mon Sep 17 00:00:00 2001 From: Steve Gore Date: Mon, 1 Jul 2019 16:39:56 +1000 Subject: [PATCH 11/16] Reapply notebook removal --- examples/creating_a_dds.ipynb | 504 --------------- examples/creating_a_driven_control.ipynb | 427 ------------- examples/export_a_dds_to_cirq.ipynb | 362 ----------- examples/export_a_dds_to_qiskit.ipynb | 769 ----------------------- examples/notebook-sanitize.cfg | 7 - 5 files changed, 2069 deletions(-) delete mode 100644 examples/creating_a_dds.ipynb delete mode 100644 examples/creating_a_driven_control.ipynb delete mode 100644 examples/export_a_dds_to_cirq.ipynb delete mode 100755 examples/export_a_dds_to_qiskit.ipynb delete mode 100644 examples/notebook-sanitize.cfg diff --git a/examples/creating_a_dds.ipynb b/examples/creating_a_dds.ipynb deleted file mode 100644 index bbd0d8d7..00000000 --- a/examples/creating_a_dds.ipynb +++ /dev/null @@ -1,504 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Creating a Dynamical Decoupling Sequence\n", - "\n", - "This notebook illustrates how to use Q-CTRL Open Controls to create a [Dynamical Decoupling Sequence (DDS)](https://en.wikipedia.org/wiki/Dynamical_decoupling). \n", - "\n", - "Dynamical decoupling is the use of fast pulses, often treated as instant ideal unitary operations, on a qubit to decouple it from its environment and improve its coherence time. The train of pulses is called a sequence, hence DDS. DDS can be used to increase the coherence time of a qubit or they can be used as part of a characterization process to identify coherence time and/or noise spectra.\n", - "\n", - "Q-CTRL Open Controls can be used to create a DDS from a library of well-known dynamical decoupling schemes. Once created, it can be printed, plotted, exported in CSV or JSON format for use on a quantum computer or any of [Q-CTRL's products](https://q-ctrl.com/products/)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from qctrlopencontrols import new_predefined_dds, DynamicDecouplingSequence" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Predefined Dynamical Decoupling Schemes\n", - "\n", - "Q-CTRL Open Controls can create DDSs according to the following protocols:\n", - "\n", - "1. `Ramsey`\n", - "2. `spin echo`\n", - "3. `Carr-Purcell`\n", - "4. `Carr-Purcell-Meiboom-Gill`\n", - "5. `Uhrig`\n", - "6. `periodic`\n", - "7. `Walsh single-axis`\n", - "8. `quadratic`\n", - "9. `X concatenated`\n", - "10. `XY concatenated`\n", - "\n", - "See the [technical documentation](https://docs.q-ctrl.com/control-formats#dynamical-decoupling-sequences) for details." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating and Printing a Dynamical Decoupling Sequence\n", - "\n", - "A DDS is defined as a set of instant unitary operations, each defined with by a `rabi_rotation`, a `azimuthal_angle`, a `detuning_angle`, and applied at a particular time (`offset`). The mathematical definition of a sequence is explained in the [technical documentation](http://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences).\n", - "\n", - "Q-CTRL Open controls can generate a DDS from a library of dynamical decoupling schemes, mathematically defined in the [technical documentation](https://docs.q-ctrl.com/control-formats#dynamical-decoupling-sequences). Below we give a few examples of generating DDSs. The schemes are grouped into cells if they have common keywords." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SE DDS:\n", - "Duration = 1e-05\n", - "Offsets = [0.5] x 1e-05\n", - "Rabi Rotations = [1.0] x pi\n", - "Azimuthal Angles = [0.0] x pi\n", - "Detuning Rotations = [0.0] x pi\n" - ] - } - ], - "source": [ - "## Spin echo sequence\n", - "se_dds = new_predefined_dds(scheme='spin echo', duration=10e-6, name='SE DDS')\n", - "print(se_dds)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CP DDS:\n", - "Duration = 1e-05\n", - "Offsets = [0.125,0.375,0.625,0.875] x 1e-05\n", - "Rabi Rotations = [1.0,1.0,1.0,1.0] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0,0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Carr-Purcell sequence\n", - "## 'Carr-Purcell-Meiboom-Gill', 'Uhrig single-axis' or 'Periodic single-axis' schemes use same keywords\n", - "cp_dds = new_predefined_dds(\n", - " scheme='Carr-Purcell', \n", - " duration=10e-6, \n", - " number_of_offsets = 4.,\n", - " name='CP DDS')\n", - "print(cp_dds)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Walsh DDS:\n", - "Duration = 1e-05\n", - "Offsets = [0.125,0.25,0.375,0.5,0.625,0.75,0.875] x 1e-05\n", - "Rabi Rotations = [1.0,1.0,1.0,1.0,1.0,1.0,1.0] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Walsh single-axis\n", - "walsh_dds = new_predefined_dds(\n", - " scheme='Walsh single-axis', \n", - " duration=10e-6, \n", - " paley_order = 4.,\n", - " name='Walsh DDS')\n", - "print(walsh_dds)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quadratic DDS:\n", - "Duration = 1e-05\n", - "Offsets = [0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375] x 1e-05\n", - "Rabi Rotations = [0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0] x pi\n" - ] - } - ], - "source": [ - "## Quadratic sequence\n", - "quadratic_dds = new_predefined_dds(\n", - " scheme='quadratic', \n", - " duration=10e-6, \n", - " number_inner_offsets = 2,\n", - " number_outer_offsets = 2,\n", - " name='Quadratic DDS')\n", - "print(quadratic_dds)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "XC DDS:\n", - "Duration = 1e-05\n", - "Offsets = [0.25,0.75] x 1e-05\n", - "Rabi Rotations = [1.0,1.0] x pi\n", - "Azimuthal Angles = [0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## X concatenated sequence\n", - "## 'XY concatenated' scheme uses the same keyword\n", - "xc_dds = new_predefined_dds(\n", - " scheme='X concatenated', \n", - " duration=10e-6, \n", - " concatenation_order = 2,\n", - " name='XC DDS')\n", - "print(xc_dds)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ramsey DDS:\n", - "Duration = 1e-06\n", - "Offsets = [] x 1e-06\n", - "Rabi Rotations = [] x pi\n", - "Azimuthal Angles = [] x pi\n", - "Detuning Rotations = [] x pi\n" - ] - } - ], - "source": [ - "## Ramsay DDS\n", - "ramsey_dds = new_predefined_dds(scheme='Ramsey', duration=1e-6, name='Ramsey DDS')\n", - "print(ramsey_dds)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting a DDS\n", - "\n", - "Once created, Q-CTRL Open Controls provides the method `get_plot_formatted_arrays` to create a set of formatted arrays ready to be immediately plotted with Matplotlib. We use the `quadratic_dds` as a sample sequence to generate plots of the `rabi_rotations`, `azimuthal_angles` and `detuning_rotations`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'Detuning Rotation (rad)')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = quadratic_dds.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times'])\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 1, 3, figsize=(20,5))\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (s)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (s)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (s)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exporting the Dynamical Decoupling Sequence\n", - "\n", - "Q-CTRL Open Controls enables exporting DDS in CSV or JSON format. An exported sequence is [formatted](https://docs.q-ctrl.com/control-formats) to be compatible with [Q-CTRL BLACK OPAL](https://app.q-ctrl.com).\n", - "\n", - "An ideal DDS is defined as a sequence of instantaneously-applied pulses (typically rotations around one or more of the Cartesian control axes - x,y,z). However, in reality, the rate of rotation is limited by the `maximum_rabi_rate` and/or `maximum_detuning_rate` for a given pulse. Due to this limiting factor, the target rotation is implemented over a control segment with finite duration. Q-CTRL Open Controls converts a `DynamicDecouplingSequence` into a `DrivenControl` before exporting the resulting `DrivenControl`. This conversion requires the `maximum_rabi_rate` and `maximum_detuning_rate` to be specified and raises an error if the conversion is not successful (i.e. overlapping control segments due to low `maximum_rabi_rate` or `maximum_detuning_rate` etc.).\n", - "\n", - "Q-CTRL Open Controls can export a sequence in either `cartesian` or `cylindrical` coordinates. For details, consult the [technical documentation](https://docs.q-ctrl.com/output-data-formats#q-ctrl-hardware).\n", - "\n", - "In the example below, we chose the `quadratic_dds` (created above) for exporting to a CSV file." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "file_type='CSV'\n", - "filename='example_sequence.csv'\n", - "\n", - "\n", - "quadratic_dds.export_to_file(\n", - " filename=filename, \n", - " file_type=file_type,\n", - " maximum_rabi_rate=2e6*np.pi,\n", - " maximum_detuning_rate=4e6*np.pi)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rabi_rate,azimuthal_angle,detuning,duration,maximum_rabi_rate\n", - "\n", - "0.0,0.0,0.0,4.999999999999999e-07,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.4999999999999994e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,9.999999999999997e-07,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.4999999999999994e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,2.5000000000000015e-07,6283185.307179586\n", - "\n", - "1.0,0.0,0.0,5.000000000000003e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,8.749999999999997e-07,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.499999999999997e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,2.2500000000000005e-06,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.499999999999993e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,8.750000000000001e-07,6283185.307179586\n", - "\n", - "1.0,0.0,0.0,4.999999999999994e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,2.50000000000001e-07,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.499999999999993e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,1.0000000000000023e-06,6283185.307179586\n", - "\n", - "0.0,0.0,3.141592653589793,2.499999999999993e-07,6283185.307179586\n", - "\n", - "0.0,0.0,0.0,5.000000000000003e-07,6283185.307179586\n" - ] - } - ], - "source": [ - "## Reload the file and check its content to better understand the format\n", - "with open(filename, 'rt') as handle:\n", - " file_content = handle.readlines()\n", - "for line in file_content:\n", - " print(line)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Opening the Exported Sequence in Q-CTRL BLACK OPAL" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The exported CSV files are compatible for analysis by a suite of tools offered by [Q-CTRL BLACK OPAL](https://app.q-ctrl.com). For example, you can upload the exported file in the [1-QUBIT Workspace](https://app.q-ctrl.com/oneQubit) for further analysis. The process to upload a custom control is described in [Uploading and Evaluating Custom Controls](https://help.q-ctrl.com/black-opal/guides/uploading-and-evaluating-custom-controls). For a full capability of BLACK OPAL, consult [Q-CTRL Help](https://help.q-ctrl.com/black-opal)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom Definition of Dynamic Decoupling Sequence\n", - "\n", - "An arbitrary `DynamicDecouplingSequence` can be created by providing a `duration` along with arrays for the `rabi_rotations`, `azimuthal_angles`, `detuning_rotations` and offsets." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'Detuning Rotation (rad)')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_duration = 1.50\n", - "_rabi_rotations = [np.pi, np.pi, 0., np.pi, np.pi]\n", - "_azimuthal_angles = [np.pi/2, 0., 0., 0., np.pi/2]\n", - "_detuning_rotations = [0., 0., np.pi, 0., 0.]\n", - "_offsets = [0.25, 0.50, 0.75, 1.00, 1.25]\n", - "_name = 'Custom DDS'\n", - "\n", - "custom_dds = DynamicDecouplingSequence(duration=_duration,\n", - " rabi_rotations=_rabi_rotations,\n", - " azimuthal_angles=_azimuthal_angles,\n", - " detuning_rotations=_detuning_rotations,\n", - " offsets=_offsets,\n", - " name=_name)\n", - "\n", - "## let us plot and verify\n", - "formatted_plot_data = custom_dds.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times'])\n", - "\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 1, 3, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlim([0, _duration])\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlim([0, _duration])\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlim([0, _duration])\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/creating_a_driven_control.ipynb b/examples/creating_a_driven_control.ipynb deleted file mode 100644 index 66df69f1..00000000 --- a/examples/creating_a_driven_control.ipynb +++ /dev/null @@ -1,427 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Creating a Driven Control\n", - "\n", - "This notebook illustrates how to use Q-CTRL Open Controls to create a driven control.\n", - "\n", - "A driven control represents a continuous drive on a the transition of a qubit with a tunable detuning. The Open Controls package allows you to generate driven controls that enact dynamically corrected gates (DCG). These dynamically corrected gates are able to achieve an arbitrary rotation of the bloch sphere (around any point on the equator), in a manner that is robust to dephasing and/or control noise. DCGs can be used as drop-in gate replacements to suppress errors in a quantum computation.\n", - "\n", - "Q-CTRL Open Controls can be used to create a driven control from a library of well-known control schemes. Once created, it can be printed, plotted, exported in CSV or JSON format for use on a quantum computer or any of [Q-CTRL's products](https://q-ctrl.com/products/)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from qctrlopencontrols import new_predefined_driven_control, DrivenControl" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Predefined Driven Control Schemes\n", - "\n", - "Q-CTRL Open Controls can create driven controls according to the following dynamically corrected gate protocols:\n", - "\n", - "1. `primitive`\n", - "2. `BB1`\n", - "3. `SK1`\n", - "4. `CORPSE`\n", - "5. `WAMF1`\n", - "6. `SCROFULOUS`\n", - "7. `COPRSE in BB1`\n", - "8. `CORPSE in SK1`\n", - "9. `CORPSE in SCROFULOUS`\n", - "\n", - "See the [technical documentation](https://docs.q-ctrl.com/control-library) for details." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating and Printing a Driven Control\n", - "\n", - "A driven control is made of a continuous drive on the qubits transition with a tunable detuning. The continuous drive is described by a piecewise constant function made of a set of segments. Each drive segment has a `rabi_rate` applied at a `azimuthal_angle` for a `duration`, with a `detuning`. The mathematical definition of a driven control is explained in the [technical documentation](http://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences).\n", - "\n", - "Q-CTRL Open controls can generate a driven control from a library of dynamically corrected gate schemes, mathematically defined in the [technical documentation](https://docs.q-ctrl.com/control-formats#dynamical-decoupling-sequences). All dynamically corrected gates are derived from three quantities: \n", - "\n", - "* `maximum_rabi_rate` the maximum achievable rabi rate.\n", - "* `rabi_rotation` the total rotation of the bloch sphere.\n", - "* `azimuthal_angle` the angle to the center point of the rotation on the equator. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Primitive X-pi:\n", - "Rabi Rates = [1.0] x 6.283185307179586\n", - "Azimuthal Angles = [0.0] x pi\n", - "Detunings = [0] x 0.0\n", - "Durations = [1.0] x 0.5\n" - ] - } - ], - "source": [ - "## Primitive Pi pulse in X\n", - "prim = new_predefined_driven_control(\n", - " rabi_rotation=np.pi,\n", - " azimuthal_angle=0,\n", - " maximum_rabi_rate=2 * np.pi,\n", - " scheme='primitive',\n", - " name='Primitive X-pi'\n", - ")\n", - "print(prim)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "BB1 X-pi:\n", - "Rabi Rates = [1.0,1.0,1.0,1.0] x 6.283185307179586\n", - "Azimuthal Angles = [0.0,0.5804306232551663,1.7412918697654987,0.5804306232551663] x pi\n", - "Detunings = [0,0,0,0] x 0.0\n", - "Durations = [0.2,0.2,0.4,0.2] x 2.5\n" - ] - } - ], - "source": [ - "## BB1 Pi pulse in X (implements the same effective operation as above)\n", - "bb1_x = new_predefined_driven_control(\n", - " rabi_rotation=np.pi,\n", - " azimuthal_angle=0,\n", - " maximum_rabi_rate=2 * np.pi,\n", - " scheme='BB1',\n", - " name='BB1 X-pi'\n", - ")\n", - "print(bb1_x)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "BB1 Y-pi/2:\n", - "Rabi Rates = [1.0,1.0,1.0,1.0] x 6.283185307179586\n", - "Azimuthal Angles = [0.5,1.0398930876747683,2.1196792630243046,1.0398930876747683] x pi\n", - "Detunings = [0,0,0,0] x 0.0\n", - "Durations = [0.1111111111111111,0.2222222222222222,0.4444444444444444,0.2222222222222222] x 2.25\n" - ] - } - ], - "source": [ - "## BB1 Pi/2 pulse in Y\n", - "bb1_y = new_predefined_driven_control(\n", - " rabi_rotation=np.pi/2,\n", - " azimuthal_angle=np.pi/2,\n", - " maximum_rabi_rate=2 * np.pi,\n", - " scheme='BB1',\n", - " name='BB1 Y-pi/2'\n", - ")\n", - "print(bb1_y)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SK1 Y-pi/2:\n", - "Rabi Rates = [1.0,1.0,1.0] x 6.283185307179586\n", - "Azimuthal Angles = [0.5,-0.03989308767476825,1.0398930876747683] x pi\n", - "Detunings = [0,0,0] x 0.0\n", - "Durations = [0.1111111111111111,0.4444444444444444,0.4444444444444444] x 2.25\n" - ] - } - ], - "source": [ - "## SK1 Pi/2 pulse in Y\n", - "sk1 = new_predefined_driven_control(\n", - " rabi_rotation=np.pi/2,\n", - " azimuthal_angle=np.pi/2,\n", - " maximum_rabi_rate=2 * np.pi,\n", - " scheme='SK1',\n", - " name='SK1 Y-pi/2'\n", - ")\n", - "print(sk1)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CORPSE X-pi/2:\n", - "Rabi Rates = [1.0,1.0,1.0] x 6.283185307179586\n", - "Azimuthal Angles = [0.0,1.0,0.0] x pi\n", - "Detunings = [0,0,0] x 0.0\n", - "Durations = [0.5284727158825664,0.43811717424831853,0.033410109869114954] x 2.0199465438373845\n" - ] - } - ], - "source": [ - "## CORPSE Pi/2 pulse in X\n", - "corpse = new_predefined_driven_control(\n", - " rabi_rotation=np.pi/2,\n", - " azimuthal_angle=0,\n", - " maximum_rabi_rate=2 * np.pi,\n", - " scheme='CORPSE',\n", - " name='CORPSE X-pi/2'\n", - ")\n", - "print(corpse)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting a driven control\n", - "\n", - "Once created, Q-CTRL Open Controls provides the method `get_plot_formatted_arrays` to create a set of formatted arrays ready to be immediately plotted with Matplotlib. We use the `BB1` as a driven control to generate plots of the `rabi_rates`, `azimuthal_angles` and `detunings`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAAFACAYAAAA4bSyDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIkmSJEmSJGGSSJIkSZIkScD/D+U8hXKDbUHUAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = bb1_x.get_plot_formatted_arrays(coordinates='cylindrical')\n", - "rabi_rates, azimuthal_angles, detunings, times = (formatted_plot_data['rabi_rates'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detunings'],\n", - " formatted_plot_data['times'])\n", - "# prepare the axes\n", - "figure, (x_axis, y_axis, z_axis) = plt.subplots(1, 3, figsize=(20,5))\n", - "\n", - "x_axis.fill_between(times, rabi_rates, 0, alpha=0.15, color='#680cea')\n", - "x_axis.plot(times, rabi_rates, color='#680cea')\n", - "x_axis.set_xlabel('Time (s)')\n", - "x_axis.set_ylabel('Rabi Rate (radHz)')\n", - "\n", - "y_axis.fill_between(times, azimuthal_angles, 0, alpha=0.15, color='#680cea')\n", - "y_axis.plot(times, azimuthal_angles, color='#680cea')\n", - "y_axis.set_xlabel('Time (s)')\n", - "y_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "z_axis.fill_between(times, detunings, 0, alpha=0.15, color='#680cea')\n", - "z_axis.plot(times, detunings, color='#680cea')\n", - "z_axis.set_xlabel('Time (s)')\n", - "z_axis.set_ylabel('Detuning (radHz)')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exporting the Driven Control\n", - "\n", - "Q-CTRL Open Controls enables exporting driven controls in CSV or JSON format. An exported driven control is [formatted](https://docs.q-ctrl.com/control-formats) to be compatible with [Q-CTRL BLACK OPAL](https://app.q-ctrl.com).\n", - "\n", - "Q-CTRL Open Controls can export a driven control in either `cartesian` or `cylindrical` coordinates. For details, consult the [technical documentation](https://docs.q-ctrl.com/output-data-formats#q-ctrl-hardware).\n", - "\n", - "In the example below, we chose the `bb1_x` control (created above) for exporting to a CSV file." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "file_type='CSV'\n", - "filename='example_driven_control.csv'\n", - "\n", - "bb1_x.export_to_file(\n", - " filename=filename, \n", - " file_type=file_type,\n", - " coordinates='cartesian')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "amplitude_x,amplitude_y,detuning,duration,maximum_rabi_rate\n", - "\n", - "6.283185307179586,0.0,0.0,0.5,6.283185307179586\n", - "\n", - "-1.570796326794896,6.083668013960418,0.0,0.5,6.283185307179586\n", - "\n", - "4.319689898685962,-4.562751010470316,0.0,1.0,6.283185307179586\n", - "\n", - "-1.570796326794896,6.083668013960418,0.0,0.5,6.283185307179586\n" - ] - } - ], - "source": [ - "## Reload the file and check its content to better understand the format\n", - "with open(filename, 'rt') as handle:\n", - " file_content = handle.readlines()\n", - "for line in file_content:\n", - " print(line)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Opening the Exported Sequence in Q-CTRL BLACK OPAL" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The exported CSV files are compatible for analysis by a suite of tools offered by [Q-CTRL BLACK OPAL](https://app.q-ctrl.com). For example, you can upload the exported file in the [1-QUBIT Workspace](https://app.q-ctrl.com/oneQubit) for further analysis. The process to upload a custom control is described in [Uploading and Evaluating Custom Controls](https://help.q-ctrl.com/black-opal/guides/uploading-and-evaluating-custom-controls). For a full capability of BLACK OPAL, consult [Q-CTRL Help](https://help.q-ctrl.com/black-opal)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom Definition of a Driven Control\n", - "\n", - "An arbitrary `DrivenControl` can be defined defined using arrays of `rabi_rotations`, `azimuthal_angles`, `detuning_rotations` and `durations`." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAFACAYAAAAfw61rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAGBqikwAAAAATE2RCQAAAICp/QBkKCSqeDTyXQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "_rabi_rates = [np.pi/2,np.pi/2,np.pi,np.pi]\n", - "_azimuthal_angles = [0., -np.pi/2, 0., np.pi/2]\n", - "_detunings = [np.pi/2, 0, -np.pi/2, 0]\n", - "_durations = [0.5, 1, 2, 0.5]\n", - "_name = 'Custon Driven Control'\n", - "\n", - "custom_driven_control = DrivenControl(rabi_rates=_rabi_rates, \n", - " azimuthal_angles=_azimuthal_angles,\n", - " detunings=_detunings,\n", - " durations=_durations,\n", - " name=_name)\n", - "\n", - "## let us plot and verify\n", - "formatted_plot_data = custom_driven_control.get_plot_formatted_arrays(coordinates='cylindrical')\n", - "rabi_rates, azimuthal_angles, detunings, times = (formatted_plot_data['rabi_rates'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detunings'],\n", - " formatted_plot_data['times'])\n", - "\n", - "figure, (x_axis, y_axis, z_axis) = plt.subplots(1, 3, figsize=(20,5))\n", - "\n", - "x_axis.fill_between(times, rabi_rates, 0, alpha=0.15, color='#680cea')\n", - "x_axis.plot(times, rabi_rates, color='#680cea')\n", - "x_axis.set_xlabel('Time (s)')\n", - "x_axis.set_ylabel('Rabi Rate (radHz)')\n", - "\n", - "y_axis.fill_between(times, azimuthal_angles, 0, alpha=0.15, color='#680cea')\n", - "y_axis.plot(times, azimuthal_angles, color='#680cea')\n", - "y_axis.set_xlabel('Time (s)')\n", - "y_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "z_axis.fill_between(times, detunings, 0, alpha=0.15, color='#680cea')\n", - "z_axis.plot(times, detunings, color='#680cea')\n", - "z_axis.set_xlabel('Time (s)')\n", - "z_axis.set_ylabel('Detuning (radHz)')\n", - "\n", - "plt.show()" - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/export_a_dds_to_cirq.ipynb b/examples/export_a_dds_to_cirq.ipynb deleted file mode 100644 index 71f908ad..00000000 --- a/examples/export_a_dds_to_cirq.ipynb +++ /dev/null @@ -1,362 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Export a Dynamical Decoupling Sequence to Cirq\n", - "\n", - "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported as `cirq.Circuit` or `cirq.Schedule` and run in `cirq.Simulator`.\n", - "\n", - "Note : You can install `cirq` by simply running `pip install cirq`. Please consult [Cirq Documentation](https://cirq.readthedocs.io/en/stable/) for installation instruction and general introduction to `cirq` package." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#General\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.gridspec import GridSpec\n", - "\n", - "#Q-CTRL Open Controls\n", - "from qctrlopencontrols import new_predefined_dds, convert_dds_to_cirq_circuit, convert_dds_to_cirq_schedule\n", - "\n", - "#Cirq : to run the circuit on simulator\n", - "import cirq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running a DDS on a Cirq Simulator\n", - "\n", - "This section demonstrates how a DDS can be prepared, a corresponding quantum circuit made and executed on a `cirq` simulator.\n", - "\n", - "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", - "\n", - "`cirq` implements quantum operations through a series of [gates](https://cirq.readthedocs.io/en/stable/gates.html). Standard way to create a circuit is through `cirq.Circuit` that accepts a list of valid gates. If a user wants to add pauses (in time) during a computation they can use identity gates. Alternatively, `cirq` provides `ScheduledOperation` that specifies an operation (application of a gate on one more qubits) at a certain instant measured in \"nano-seconds\" or \"pico-seconds\" from the start of the sequence. A list of `ScheduledOperation` is collated by `cirq.Schedule`. Both `cirq.Circuit` and `cirq.Schedule` can be used in `cirq.Simulator` to simulate the circuit. We provide two methods -`convert_dds_to_cirq_circuit` and `covert_dds_to_cirq_schedule` to select between `cirq.Circuit` and `cirq.Schedule` as desired output from the conversion method.\n", - "\n", - "Converting a DDS into a `cirq.Circuit` or `cirq.Schedule` is an approximate process where the instantaneous unitaries are replaced with finite duration gates. Moreover, in `cirq.Circuit`, the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](../qctrlopencontrols/cirq/cirq_circuit.py).\n", - "\n", - "In this example we will define a Quadratic DDS and convert it into a circuit that we can later run on a simulator. Note that we add a $X_{\\pi/2}$ rotation at both ends of the sequence. See [creating_a_dds.ipynb](creating_a_dds.ipynb) to see how other sequences can be created." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Preparing the Sequences" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quadratic sequence:\n", - "Duration = 2e-05\n", - "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 2e-05\n", - "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Quadratic sequence, total duration: 20us\n", - "quadratic_sequence = new_predefined_dds(\n", - " scheme='quadratic',\n", - " duration=20e-6, \n", - " number_inner_offsets=2,\n", - " number_outer_offsets=2,\n", - " pre_post_rotation=True,\n", - " name='Quadratic sequence')\n", - "print(quadratic_sequence)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Constructing the Circuit Using Q-CTRL Open Controls\n", - "\n", - "To construct a circuit/schedule from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list of target qubits (each of `cirq.Qid` type) to indicate qubits on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the gates. If measurement is required, use `add_measurement=True`.\n", - "\n", - "See the [source code](../qctrlopencontrols/cirq/cirq_circuit.py) for more information and other parameters that may be useful.\n", - "\n", - "In this example, we will use a single qubit on 1-D lattice. We specify the `gate_time` to be $0.4$ $\\mu$s. Finally we will add a measurement operation. In this example we will convert the DDS into a `cirq.Circuit`." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "## Prepare the conversion related parameters\n", - "'''\n", - "target_qubits : list\n", - " A list of cirq.Qid. In this case we are using a single\n", - " qubit (indexed 0) on 1-D lattice.\n", - "'''\n", - "target_qubits = [cirq.LineQubit(0)]\n", - "\n", - "\n", - "'''\n", - "gate_time : float\n", - " Time delay (in seconds) introduced by identity gate\n", - "'''\n", - "gate_time = 0.4e-6\n", - "\n", - "'''\n", - "add_measurement : bool\n", - " Indicates if the circuit requires a measurement step.\n", - " Required for 'qasm_simulator' and real device backends\n", - "'''\n", - "add_measurement = True\n", - "\n", - "## convert the quadratic sequence to cirq.Circuit\n", - "quadratic_cirq_circuit = convert_dds_to_cirq_circuit(\n", - " dynamic_decoupling_sequence=quadratic_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the DDS\n", - "\n", - "We can use Q-CTRL Open Controls to plot the DDS for comparison against its `cirq.Circuit` approximations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 3, 1, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Quadratic Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Drawing the Circuit\n", - "\n", - "We can draw a text diagram of the `cirq.Circuit` generated by Q-CTRL Open Controls.\n", - "\n", - "Note that a $X_{\\pi/2}$ rotation will be added at beginning and end, that is, at offsets of $[0, 20]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are implemented using $Rx($0.5\\pi$)$ gate.\n", - "\n", - "The $Rz(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $Rx(\\pi)$ gates correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", - "\n", - "The `I` in the drawing corresponds to the `identity` gate. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $1.25$ $\\mu$s. This is approximated by introducing 3-`Id` gates with a delay of $0.4\\times 3=1.2$ $\\mu s$. Similarly, the second set of 6 Id gates introduces a delay of 2.4$\\mu s$ close to the actual delay of $3.75−1.25=2.50\\mu s$.\n", - "\n", - "At the end of the circuit, we placed a `measurement` ($M$) operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0: ─Rx(0.5π)─I─I─I─Rz(π)─I─I─I─I─I─I─Rz(π)─I─I─I─Rx(π)─I─I─I─I─I─I─Rz(π)─I─I─I─I─I─I─I─I─I─I─I─I─Rz(π)─I─I─I─I─I─I─Rx(π)─I─I─I─Rz(π)─I─I─I─I─I─I─Rz(π)─I─I─I─Rx(0.5π)─M('qubit-0')─\n" - ] - } - ], - "source": [ - "##Drawing the Quadratic Circuit\n", - "print(quadratic_cirq_circuit.to_text_diagram_drawer().render())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the Circuit on Cirq Simulator using Cirq API\n", - "\n", - "Consult [Simulation](https://cirq.readthedocs.io/en/stable/simulation.html) for a description of available simulation APIs and their properties. Here, we will use the `run` method of `cirq.Simulator` to run the circuit. The circuit is run upto `repetitions` times. The result is printed after the simulation." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "qubit-0=1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n", - "Counter({1: 100})\n" - ] - } - ], - "source": [ - "##### Set the simulator parameters\n", - "'''\n", - "repetitions : int\n", - " The number of times the circuit will be executed\n", - "'''\n", - "repetitions = 100\n", - "\n", - "## Create the simulator\n", - "simulator = cirq.Simulator()\n", - "\n", - "#Run the simulator and collect result\n", - "result = simulator.run(quadratic_cirq_circuit, repetitions=repetitions)\n", - "\n", - "#print the outcome of each repetition\n", - "print(result)\n", - "\n", - "#you can also collect the outcome as histogram (calculated as dict)\n", - "print(result.histogram(key=['qubit-0']))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Creating a Schedule and running on Cirq Simulator\n", - "\n", - "We can create a `cirq.Schedule` from the DDS using `convert_dds_to_cirq_schedule` method." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "qubit-0=1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n", - "Counter({1: 100})\n" - ] - } - ], - "source": [ - "## convert the quadratic sequence to cirq.Schedule\n", - "quadratic_cirq_circuit = convert_dds_to_cirq_schedule(\n", - " dynamic_decoupling_sequence=quadratic_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement\n", - ")\n", - "\n", - "##### Set the simulator parameters\n", - "'''\n", - "repetitions : int\n", - " The number of times the circuit will be executed\n", - "'''\n", - "repetitions = 100\n", - "\n", - "## Create the simulator\n", - "simulator = cirq.Simulator()\n", - "\n", - "#Run the simulator and collect result\n", - "result = simulator.run(quadratic_cirq_circuit, repetitions=repetitions)\n", - "\n", - "#print the outcome of each repetition\n", - "print(result)\n", - "\n", - "#you can also collect the outcome as histogram (calculated as dict)\n", - "print(result.histogram(key=['qubit-0']))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/export_a_dds_to_qiskit.ipynb b/examples/export_a_dds_to_qiskit.ipynb deleted file mode 100755 index 7b07491a..00000000 --- a/examples/export_a_dds_to_qiskit.ipynb +++ /dev/null @@ -1,769 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Export a Dynamical Decoupling Sequence to Qiskit\n", - "\n", - "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported to a Qiskit circuit to run on an IBM Q device. We also show how a DDS can decrease the number of errors, when executing a quantum circuit on a real quantum computer, by extending the coherence time.\n", - "\n", - "Note: To run the DDS on a real device, you need to have an IBM Q account and acquire an API token. [Sign Up](https://quantumexperience.ng.bluemix.net/qx/login) if you have not already done so. Additionally, you will need to have the Qiskit library installed. Consult [Installing Qiskit](https://qiskit.org/documentation/install.html) for more information." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#General\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.gridspec import GridSpec\n", - "\n", - "#Q-CTRL Open Controls\n", - "from qctrlopencontrols import new_predefined_dds, convert_dds_to_qiskit_quantum_circuit\n", - "\n", - "#Qiskit\n", - "##To define a backend (simulated or real)\n", - "from qiskit import execute, BasicAer\n", - "\n", - "##To plot the outcome\n", - "from qiskit.tools.visualization import plot_histogram\n", - "\n", - "## To handle account information,find a suitable device and monitor a job\n", - "from qiskit import IBMQ\n", - "from qiskit.providers.ibmq import least_busy\n", - "from qiskit.tools.monitor import job_monitor" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running a DDS on a Qiskit Simulator\n", - "\n", - "This section demonstrates how a DDS can be prepared and a corresponding Qiskit circuit made and executed on a Qiskit simulator.\n", - "\n", - "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", - "\n", - "Qiskit implements quantum computation through a series of [gates in a quantum circuit](https://qiskit.org/documentation/getting_started.html#circuit-basics). How these gates are physically implemented will depend on the device that it is run on.\n", - "\n", - "On IBM Q devices, individual qubit rotations are completed using two basis elements. $Z$ rotations are performed with (almost) instantaneous clock shifts and $Y$ rotations are performed with microwave pulses over a fixed time. All single qubit gates are a combination of these two.\n", - "\n", - "If a user wants to add pauses (in time) during a computation they can use identity gates and barriers. The barriers ensure that the circuit is not simplified before execution on the machine. Both identity gates and $X$ or $Y$ rotation gates take a fixed time (`gate_time`).\n", - "\n", - "Converting a DDS into a Qiskit circuit is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](https://github.com/qctrl/python-open-controls/blob/master/qctrlopencontrols/qiskit/quantum_circuit.py).\n", - "\n", - "In this example we will define a Quadratic DDS and convert it into a circuit that we can later run on a simulator and on a real device. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We also create a Ramsey DDS of the same duration to compare as a benchmark. For both the sequences, we add a $X_{\\pi/2}$ rotation on either end of the sequence." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Preparing the Sequences" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quadratic sequence:\n", - "Duration = 2e-05\n", - "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 2e-05\n", - "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", - "Ramsey sequence:\n", - "Duration = 2e-05\n", - "Offsets = [0.0,1.0] x 2e-05\n", - "Rabi Rotations = [0.5,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Quadratic sequence, total duration: 20us\n", - "quadratic_sequence = new_predefined_dds(\n", - " scheme='quadratic',\n", - " duration=20e-6, \n", - " number_inner_offsets=2,\n", - " number_outer_offsets=2,\n", - " pre_post_rotation=True,\n", - " name='Quadratic sequence')\n", - "\n", - "# Ramsey sequence, total duration: 20us\n", - "ramsey_sequence = new_predefined_dds(\n", - " scheme='Ramsey',\n", - " duration=20e-6,\n", - " pre_post_rotation=True,\n", - " name='Ramsey sequence')\n", - "\n", - "print(quadratic_sequence)\n", - "print(ramsey_sequence)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Constructing the Circuit Using Q-CTRL Open Controls\n", - "\n", - "To construct a `QuantumCircuit` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`. Optionally you can provide a name to the circuit (`circuit_name`).\n", - "\n", - "See the [source code](https://github.com/qctrl/python-open-controls/blob/master/qctrlopencontrols/qiskit/quantum_circuit.py) for more information and other parameters that may be useful.\n", - "\n", - "In this example, we will use $0$th qubit and specify the `gate_time` to be $0.4$ $\\mu$s. Both the DDS will require a measurement operation." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "## Prepare the Qiskit related parameters\n", - "'''\n", - "target_qubits : list\n", - " A list of integers specifying the target qubits within the set of qubit registers\n", - "'''\n", - "target_qubits = [0]\n", - "\n", - "'''\n", - "gate_time : float\n", - " Time delay (in seconds) introduced by identity gate\n", - "'''\n", - "gate_time = 0.4e-6\n", - "\n", - "'''\n", - "add_measurement : bool\n", - " Indicates if the circuit requires a measurement step.\n", - " Required for 'qasm_simulator' and real device backends\n", - "'''\n", - "add_measurement = True\n", - "\n", - "'''\n", - "circuit_name : str\n", - " An optional string as a name to the circuit\n", - "'''\n", - "circuit_name = 'quadratic-sequence-circuit'\n", - "\n", - "## convert the quadratic sequence to QuantumCircuit\n", - "\n", - "quadratic_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(\n", - " dynamic_decoupling_sequence=quadratic_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement,\n", - " circuit_name=circuit_name\n", - ")\n", - "\n", - "## convert the ramsey sequence to QuantumCircuit\n", - "circuit_name = 'ramsey-sequence-circuit'\n", - "ramsey_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(\n", - " dynamic_decoupling_sequence=ramsey_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement,\n", - " circuit_name=circuit_name\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the DDS\n", - "\n", - "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Qiskit circuit approximations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 3, 1, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Quadratic Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 1, 3, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Ramsey Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Drawing the Circuits\n", - "\n", - "We can use Qiskit to draw the circuits generated by Q-CTRL Open Controls." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Drawing the Quadratic DDS Circuit\n", - "\n", - "Note that both DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 20]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the circuits in the form of pre-post-gates that are implemented via Qiskit's $U3(\\pi/2, -\\pi/2, \\pi/2)$ gate.\n", - "\n", - "The $U1(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $U3(\\pi, -\\pi/2, \\pi/2)$ gates correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", - "\n", - "The `Id` in the drawing corresponds to the `identity` gate. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $1.25$ $\\mu$s. This is approximated by introducing 3-`Id` gates with a delay of $0.4\\times 3=1.2$ $\\mu s$. Similarly, the second set of 6 `Id` gates introduces a delay of $2.4$ $\\mu s$ close to the actual delay of $3.75-1.25=2.50\\mu s$.\n", - "\n", - "The `barrier` gates are special gates that tell the Qiskit compilers not to simplify a circuit at the specified positions.\n", - "\n", - "At the end of each circuit, we place a `measurement` operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
         ┌───────────────────────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────────────┐»\n",
-       "q0_0: |0>┤ U3(1.5708,-pi/2,pi/2) ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U1(3.1416) ├»\n",
-       "         └───────────────────────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────────────┘»\n",
-       " c0_0: 0 ═════════════════════════════════════════════════════════════════════»\n",
-       "                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────────────┐»\n",
-       "«q0_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U1(3.1416) ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────────────┘»\n",
-       "«c0_0: ═══════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                             »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌───────────────────────┐ ░ ┌────┐ ░ »\n",
-       "«q0_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U3(3.1416,-pi/2,pi/2) ├─░─┤ Id ├─░─»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └───────────────────────┘ ░ └────┘ ░ »\n",
-       "«c0_0: ═══════════════════════════════════════════════════════════════════»\n",
-       "«                                                                         »\n",
-       "«      ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────────────┐ ░ ┌────┐ ░ »\n",
-       "«q0_0: ┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U1(3.1416) ├─░─┤ Id ├─░─»\n",
-       "«      └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────────────┘ ░ └────┘ ░ »\n",
-       "«c0_0: ═══════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                             »\n",
-       "«      ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ »\n",
-       "«q0_0: ┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─»\n",
-       "«      └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ »\n",
-       "«c0_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«      ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────────────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ »\n",
-       "«q0_0: ┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U1(3.1416) ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─»\n",
-       "«      └────┘ ░ └────┘ ░ └────┘ ░ └────────────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ »\n",
-       "«c0_0: ═══════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                             »\n",
-       "«      ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌───────────────────────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q0_0: ┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ U3(3.1416,-pi/2,pi/2) ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«      └────┘ ░ └────┘ ░ └────┘ ░ └───────────────────────┘ ░ └────┘ ░ └────┘»\n",
-       "«c0_0: ══════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                            »\n",
-       "«       ░ ┌────┐ ░ ┌────────────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q0_0: ─░─┤ Id ├─░─┤ U1(3.1416) ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────────────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c0_0: ═══════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                             »\n",
-       "«       ░ ┌────┐ ░ ┌────────────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ »\n",
-       "«q0_0: ─░─┤ Id ├─░─┤ U1(3.1416) ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─»\n",
-       "«       ░ └────┘ ░ └────────────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ »\n",
-       "«c0_0: ════════════════════════════════════════════════════════»\n",
-       "«                                                              »\n",
-       "«      ┌───────────────────────┐ ░ ┌─┐\n",
-       "«q0_0: ┤ U3(1.5708,-pi/2,pi/2) ├─░─┤M├\n",
-       "«      └───────────────────────┘ ░ └╥┘\n",
-       "«c0_0: ═════════════════════════════╩═\n",
-       "«
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "##Drawing the Quadratic Circuit\n", - "quadratic_quantum_circuit.draw()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Drawing the Ramsey DDS Circuit\n", - "\n", - "The drawing below shows the Ramsey DDS circuit consists of `Id` or `identity` gates surrounded by $X_{\\pi/2}$-pulses on both ends. The `measurement` operator appears at the end as in the original definition of the circuit. This will help us run the circuit in one of the simulators." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
         ┌───────────────────────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "q1_0: |0>┤ U3(1.5708,-pi/2,pi/2) ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "         └───────────────────────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       " c1_0: 0 ══════════════════════════════════════════════════════════════════════»\n",
-       "                                                                               »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c1_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c1_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c1_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c1_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐»\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘»\n",
-       "«c1_0: ════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                              »\n",
-       "«       ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ ┌────┐ ░ »\n",
-       "«q1_0: ─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─┤ Id ├─░─»\n",
-       "«       ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ └────┘ ░ »\n",
-       "«c1_0: ════════════════════════════════════════════════»\n",
-       "«                                                      »\n",
-       "«      ┌───────────────────────┐ ░ ┌─┐\n",
-       "«q1_0: ┤ U3(1.5708,-pi/2,pi/2) ├─░─┤M├\n",
-       "«      └───────────────────────┘ ░ └╥┘\n",
-       "«c1_0: ═════════════════════════════╩═\n",
-       "«
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ramsey_quantum_circuit.draw()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And here we count 50 `Id` operations, implementing a total delay of $50 \\times 0.4 = 20 \\mu s$" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "50\n" - ] - } - ], - "source": [ - "print(ramsey_quantum_circuit.count_ops()['id'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the Circuit on Qiskit Simulator using Qiskit API\n", - "\n", - "Before running our circuits on the real IBM Q hardware, let's run them through a simulator first.\n", - "\n", - "Consult [Simulating Circuits using Qiskit Aer](https://qiskit.org/documentation/getting_started.html#simulating-circuits-using-qiskit-aer) for a description of available simulators and their respective properties.\n", - "\n", - "Here, we will use the `qasm-simulator` to run the circuit. The experiment consists of `number_of_shots` repeats of the circuit operations on a qubit. Each run collects the state of the qubit as measurement. The result is displayed as a histogram." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "## Prepares the simulator backend\n", - "'''\n", - "backend : str\n", - " One of 'unitary_simulator', 'statevector_simulator' or 'qasm_simulator';\n", - " defaults to 'qasm_simulator'\n", - "'''\n", - "backend = 'qasm_simulator'\n", - "backend_simulator = BasicAer.get_backend(backend)\n", - "\n", - "'''\n", - "number_of_shots : int\n", - " Number of repeats the experiment has to be carried out;\n", - " defaults to 1\n", - "'''\n", - "number_of_shots = 1024" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Run the quadratic sequence circuit, Get the result (counts of state |1> and |0>), plot the histogram\n", - "job = execute(quadratic_quantum_circuit, backend_simulator, shots=number_of_shots)\n", - "result = job.result()\n", - "counts = result.get_counts(quadratic_quantum_circuit)\n", - "plot_histogram(counts)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Run the ramsey sequence circuit, Get the result (counts of state |1> and |0>), plot the histogram\n", - "job = execute(ramsey_quantum_circuit, backend_simulator, shots=number_of_shots)\n", - "result = job.result()\n", - "counts = result.get_counts(ramsey_quantum_circuit)\n", - "plot_histogram(counts)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running a Dynamical Decoupling Sequence on a Real Device\n", - "\n", - "Now that we've verified that our circuits run on the simulators, let's take a look at what happens when we run them on the real IBM Q devices.\n", - "\n", - "We use the same DDS and circuit defined above and use Qiskit's APIs to run the circuit. See [Running Circuits on IBM Q Devices](https://qiskit.org/documentation/getting_started.html#running-circuits-on-ibm-q-devices) for a more detailed explanation of the APIs used here." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Select a Suitable Device Based on Account Type and Configuration Using Qiskit API\n", - "\n", - "We use a basic configuration and choose the least busy device." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Least busy device is ibmqx2\n" - ] - } - ], - "source": [ - "# NBVAL_SKIP\n", - "'''\n", - "account_token : str\n", - " Token to enable IBM Q device access\n", - "'''\n", - "account_token = 'insert-your-ibmq-token-here'\n", - "IBMQ.enable_account(account_token)\n", - "available_devices = IBMQ.backends(\n", - " filters=lambda x: not x.configuration().simulator and x.status().operational is True\n", - ")\n", - "#print(available_devices)\n", - "backend = least_busy(available_devices)\n", - "print('Least busy device is {}'.format(backend.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the Circuits on a Real Device Using Qiskit API" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "'''\n", - "number_of_shots : int\n", - " Number of repeats the experiment has to be carried out;\n", - " defaults to 1\n", - "'''\n", - "number_of_shots = 1024\n", - "\n", - "# Run on a device\n", - "job = execute(quadratic_quantum_circuit, backend, shots=number_of_shots)\n", - "job_monitor(job)\n", - "result = job.result()\n", - "counts = result.get_counts(quadratic_quantum_circuit)\n", - "plot_histogram(counts)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "'''\n", - "number_of_shots : int\n", - " Number of repeats the experiment has to be carried out;\n", - " defaults to 1\n", - "'''\n", - "number_of_shots = 1024\n", - "\n", - "# Run on a device\n", - "job = execute(ramsey_quantum_circuit, backend, shots=number_of_shots)\n", - "job_monitor(job)\n", - "result = job.result()\n", - "counts = result.get_counts(ramsey_quantum_circuit)\n", - "plot_histogram(counts)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Close the Account\n", - "\n", - "Just to make sure, close the account after the task is over." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "IBMQ.disable_accounts(token=account_token)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Reducing Errors by Increasing the Coherence Time\n", - "\n", - "In the ideal noiseless simulator, both the Ramsey DDS and Quadratic DDS produced exactly the same outcome, the $|1 \\rangle$ state with probability 1. However, in a real device, we can see a marked difference. The Quadratic DDS produced a probability distribution closer to the expected outcome. This is because the Quadratic DDS is able to cancel the effects of magnetic noise in the environment - extending the [T2 time](https://en.wikipedia.org/wiki/Spin–spin_relaxation), and effectively increasing the coherence of the qubit." - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/notebook-sanitize.cfg b/examples/notebook-sanitize.cfg deleted file mode 100644 index d079c0f2..00000000 --- a/examples/notebook-sanitize.cfg +++ /dev/null @@ -1,7 +0,0 @@ -[regex1] -regex: \d{1,2}/\d{1,2}/\d{2,4} -replace: DATE-STAMP - -[regex2] -regex: \d{2}:\d{2}:\d{2} -replace: TIME-STAMP From 72423017992af9327fa52a455f8f462b1f521651 Mon Sep 17 00:00:00 2001 From: CircleCI workflow Date: Mon, 1 Jul 2019 06:40:15 +0000 Subject: [PATCH 12/16] Update setup.py/README.rst to match pyproject.toml/README.md [ci skip] --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 1fcc1bd5..a474ffd2 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ + # -*- coding: utf-8 -*- # DO NOT EDIT THIS FILE! @@ -32,7 +33,7 @@ license='Apache-2.0', keywords='quantum computing open source engineering', classifiers=['Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Intended Audience :: Education', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: Apache Software License', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3.6', 'Topic :: Scientific/Engineering :: Physics', 'Topic :: Scientific/Engineering :: Visualization', 'Topic :: Software Development :: Embedded Systems', 'Topic :: System :: Distributed Computing'], - packages=['qctrlopencontrols', 'qctrlopencontrols.base', 'qctrlopencontrols.cirq', 'qctrlopencontrols.driven_controls', 'qctrlopencontrols.dynamic_decoupling_sequences', 'qctrlopencontrols.exceptions', 'qctrlopencontrols.globals', 'qctrlopencontrols.qiskit'], + packages=['qctrlopencontrols', 'qctrlopencontrols.base', 'qctrlopencontrols.cirq', 'qctrlopencontrols.driven_controls', 'qctrlopencontrols.dynamic_decoupling_sequences', 'qctrlopencontrols.exceptions', 'qctrlopencontrols.globals', 'qctrlopencontrols.pyquil', 'qctrlopencontrols.qiskit'], package_data={}, install_requires=['cirq==0.*,>=0.5.0', 'numpy==1.*,>=1.16.0', 'qiskit-ibmq-provider==0.*,>=0.2.2', 'qiskit-terra==0.*,>=0.8.1', 'scipy==1.*,>=1.3.0'], extras_require={'dev': ['pylama', 'pylint', 'pylint-runner', 'pytest']}, From 16db9592c5ad95170b072a5dfd0db58a1980dd81 Mon Sep 17 00:00:00 2001 From: Steve Gore Date: Mon, 1 Jul 2019 16:41:54 +1000 Subject: [PATCH 13/16] Further notebook removal --- examples/export_a_dds_to_pyquil.ipynb | 853 -------------------------- 1 file changed, 853 deletions(-) delete mode 100755 examples/export_a_dds_to_pyquil.ipynb diff --git a/examples/export_a_dds_to_pyquil.ipynb b/examples/export_a_dds_to_pyquil.ipynb deleted file mode 100755 index cd73618e..00000000 --- a/examples/export_a_dds_to_pyquil.ipynb +++ /dev/null @@ -1,853 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Export a Dynamical Decoupling Sequence to Pyquil\n", - "\n", - "Q-CTRL Open Controls provides easy-to-use methods to construct Dynamical Decoupling Sequences (DDS) according to well-known dynamical decoupling schemes. This is described in the [creating a DDS notebook](creating_a_dds.ipynb). Here we show how a DDS from Q-CTRL Open Controls can be exported to a `Program` defined in Pyquil.\n", - "\n", - "Note: To create a quantum program, you need to install `pyquil` package. Follow the [instruction](http://docs.rigetti.com/en/stable/start.html) to install `pyquil`. Moreover, in order to simulate the quantum program, you will require the [ForestSDK](https://www.rigetti.com/forest). Follow the [instruction] (http://docs.rigetti.com/en/stable/start.html) to obtain and install ForestSDK on your computer." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#General\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.gridspec import GridSpec\n", - "\n", - "#Q-CTRL Open Controls\n", - "from qctrlopencontrols import (\n", - " new_predefined_dds, convert_dds_to_pyquil_program)\n", - "\n", - "#pyquil\n", - "from pyquil.api import get_qc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Running a DDS on a Pyquil Quantum Virtual Machine (QVM)\n", - "\n", - "This section demonstrates how a DDS can be prepared and a corresponding Pyquil program made and executed on a Quantum Virtual Simulator (QVM).\n", - "\n", - "Q-CTRL Open Controls defines a DDS as a set of instantaneous unitary operations performed at specific offset times, see the [technical documentation](https://docs.q-ctrl.com/control-library#dynamical-decoupling-sequences) for mathematical details.\n", - "\n", - "Pyquil implements quantum computation through `Program` that contains a series of [gates](http://docs.rigetti.com/en/stable/apidocs/gates.html). How these gates are physically implemented will depend on the device that it is run on. Rigetti's documentation gives an oversight on Rigetti's [native gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#native-gates-for-rigetti-qpus)] and other [physically realizable gates](http://docs.rigetti.com/en/stable/apidocs/gates.html#all-gates-and-instructions).\n", - "\n", - "If a user wants to add pauses (in time) during a computation they can use identity gates. However, executing a quantum program with identity gates cause the compiler to remove the gates before execution to increase efficiency. This can be avoided by using `Pragma PRESERVE` blocks (see [documentation](http://docs.rigetti.com/en/stable/basics.html#pragmas) for more detail and other usages of `Pragma`).All of $I$ (identity gate), $RX$ (X-rotation gates) and $RY$ (Y-rotation gates) take a fixed time (`gate_time`).\n", - "\n", - "Converting a DDS into a Pyquil program is an approximate process where the instantaneous unitaries are replaced with finite duration gates and the pauses in-between unitaries are replaced with the closest integer number of identity gates. The exact algorithm used to make this approximation is documented in the [source code](XXXX).\n", - "\n", - "In this example we will define a Quadratic DDS and convert it into a program that we can later run on a simulator and on a real device. See [creating_a_DDS.ipynb](creating_a_DDS.ipynb) to see how other sequences can be created. We also create a Ramsey DDS of the same duration to compare as a benchmark. For both the sequences, we add a $X_{\\pi/2}$ rotation on either end of the sequence." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Preparing the Sequences" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quadratic sequence:\n", - "Duration = 5e-06\n", - "Offsets = [0.0,0.06249999999999998,0.18749999999999994,0.24999999999999994,0.37499999999999994,0.6249999999999999,0.7499999999999999,0.8124999999999999,0.9375,1.0] x 5e-06\n", - "Rabi Rotations = [0.5,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,1.0,1.0,0.0,1.0,1.0,0.0,1.0,1.0,0.0] x pi\n", - "Ramsey sequence:\n", - "Duration = 5e-06\n", - "Offsets = [0.0,1.0] x 5e-06\n", - "Rabi Rotations = [0.5,0.5] x pi\n", - "Azimuthal Angles = [0.0,0.0] x pi\n", - "Detuning Rotations = [0.0,0.0] x pi\n" - ] - } - ], - "source": [ - "## Quadratic sequence, total duration: 20us\n", - "quadratic_sequence = new_predefined_dds(\n", - " scheme='quadratic',\n", - " duration=5e-6, \n", - " number_inner_offsets=2,\n", - " number_outer_offsets=2,\n", - " pre_post_rotation=True,\n", - " name='Quadratic sequence')\n", - "print(quadratic_sequence)\n", - "\n", - "## Ramsey sequence, total duration: 20us\n", - "ramsey_sequence = new_predefined_dds(\n", - " scheme='Ramsey',\n", - " duration=5e-6,\n", - " pre_post_rotation=True,\n", - " name='Ramsey sequence')\n", - "print(ramsey_sequence)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Constructing the Program Using Q-CTRL Open Controls\n", - "\n", - "To construct a `Program` from a DDS, we need to provide the DDS (`dynamic_decoupling_sequence`). You can also provide a list (`target_qubits`) to indicate qubit indices on which the DDS will be applied. `gate_time` is the delay (in seconds) introduced by each of the `identity` gates. If measurement is required, use `add_measurement=True`.\n", - "\n", - "In this example, we will use $1$st qubit and specify the `gate_time` to be $50$ $n$s (see same [specification](http://docs.rigetti.com/en/stable/apidocs/autogen/pyquil.noise.add_decoherence_noise.html#pyquil.noise.add_decoherence_noise)). Both the DDS will require a measurement operation." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "## Prepare the Pyquil related parameters\n", - "'''\n", - "target_qubits : list\n", - " A list of integers specifying the target qubits within the set of qubit registers\n", - "'''\n", - "target_qubits = [1]\n", - "\n", - "'''\n", - "gate_time : float\n", - " Time delay (in seconds) introduced by identity gate\n", - "'''\n", - "gate_time = 50e-9\n", - "\n", - "'''\n", - "add_measurement : bool\n", - " Indicates if the program requires a measurement step.\n", - "'''\n", - "add_measurement = True\n", - "\n", - "## convert the quadratic sequence to program\n", - "quadratic_program = convert_dds_to_pyquil_program(\n", - " dynamic_decoupling_sequence=quadratic_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement,\n", - ")\n", - "## convert the ramsey sequence to program\n", - "ramsey_program = convert_dds_to_pyquil_program(\n", - " dynamic_decoupling_sequence=ramsey_sequence,\n", - " target_qubits=target_qubits,\n", - " gate_time=gate_time,\n", - " add_measurement=add_measurement,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the DDS\n", - "\n", - "We can use Q-CTRL Open Controls to plot the DDS for comparison against their Pyquil program approximations." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Plotting the Quadratic Sequence" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = quadratic_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 3, 1, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Quadratic Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Plotting the Ramsey sequence" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "formatted_plot_data = ramsey_sequence.get_plot_formatted_arrays()\n", - "rabi_rotations, azimuthal_angles, detuning_rotations, times = (\n", - " formatted_plot_data['rabi_rotations'],\n", - " formatted_plot_data['azimuthal_angles'],\n", - " formatted_plot_data['detuning_rotations'],\n", - " formatted_plot_data['times']\n", - ")\n", - "\n", - "# prepare the axes\n", - "figure, (rabi_plot_axis, azimuth_plot_axis, detuning_plot_axis) = plt.subplots(\n", - " 3, 1, figsize=(20,5))\n", - "\n", - "rabi_plot_axis.plot(times, rabi_rotations)\n", - "rabi_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "rabi_plot_axis.set_xlabel('Time (sec)')\n", - "rabi_plot_axis.set_ylabel('Rabi Rotations (rad)')\n", - "\n", - "azimuth_plot_axis.plot(times, azimuthal_angles)\n", - "azimuth_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "azimuth_plot_axis.set_xlabel('Time (sec)')\n", - "azimuth_plot_axis.set_ylabel('Azimuthal Angle (rad)')\n", - "\n", - "detuning_plot_axis.plot(times, detuning_rotations)\n", - "detuning_plot_axis.ticklabel_format(style='sci', axis='x', scilimits=(0, 2))\n", - "detuning_plot_axis.set_xlabel('Time (sec)')\n", - "detuning_plot_axis.set_ylabel('Detuning Rotation (rad)')\n", - "\n", - "plt.suptitle('Quadratic Sequence')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Printing the Quadratic DDS Program\n", - "\n", - "Note that Quadratic DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", - "\n", - "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", - "\n", - "The `I` in the program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", - "\n", - "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", - "\n", - "At the end of each program, we place a `MEASURE` operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PRAGMA PRESERVE_BLOCK\n", - "RX(pi/2) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RX(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RX(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RZ(pi) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RX(pi/2) 1\n", - "DECLARE ro BIT[1]\n", - "MEASURE 1 ro[0]\n", - "PRAGMA END_PRESERVE_BLOCK\n", - "\n" - ] - } - ], - "source": [ - "print(quadratic_program.out())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Printing the Ramsey DDS Program\n", - "\n", - "Similar to Quadratic program, Ramsey program has $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. In between there are 99 `I` gates corresponding to the interval $99\\times 50ns=4.95\\mu$s interval (close to the desired $5\\mu$s) between the $X_{\\pi/2}$ intervals.\n", - "\n", - "At the end of each program, we place a `MEASURE` operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PRAGMA PRESERVE_BLOCK\n", - "RX(pi/2) 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "I 1\n", - "RX(pi/2) 1\n", - "DECLARE ro BIT[1]\n", - "MEASURE 1 ro[0]\n", - "PRAGMA END_PRESERVE_BLOCK\n", - "\n" - ] - } - ], - "source": [ - "print(ramsey_program.out())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compiling and running the pograms on Virtual Quantum Device\n", - "\n", - "We can use `pyQuil` to compile the programs generated by Q-CTRL Open Controls. In order to achieve that, we need to create a suitable QVM;\n", - "\n", - "NOTE: You will require ForestSDK to run the following segments. You need to start the the Quil Compiler and QVM in server mode. Execute the following commands in separate prompts.\n", - "\n", - "```\n", - "$ quilc -S\n", - "$ qvm -S\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "quantum_device = get_qc(\"Aspen-4-2Q-A\", as_qvm=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Compiling the Quadratic DDS Program\n", - "\n", - "Note that both DDS will be applied with $X_{\\pi/2}$ rotations at beginning and end, that is, at offsets of $[0, 5]$ $\\mu$s, to create the desired superposition state. The $X_{\\pi/2}$ rotations are added to the programs in the form of pre-post-gates that are implemented via Pyquil's $RX(\\pi/2)$ gate.\n", - "\n", - "The $RZ(\\pi)$ gates are $Z_\\pi$ pulses (a $\\pi$ rotation around $Z$-axis) and $RX(\\pi)$ correspond to $X_{\\pi}$ pulses (a $\\pi$ rotation around $X$-axis). The gates match the pulses in the DDS.\n", - "\n", - "The `I()` in the compiled program corresponds to the `identity` gates. In the DDS, the first $Z_{\\pi}$-pulse is applied at a delay of $0.3125$ $\\mu$s. This is approximated by introducing 6-`Id` gates with a delay of $50ns\\times 6=0.3$ $\\mu s$. Similarly, the second set of 12-`Id` gates introduces a delay of $0.6$ $\\mu s$ close to the actual delay of $0.9375-0.3125=0.625\\mu s$.\n", - "\n", - "The `Pragma` preserve blocks are added at the start and end of the program so that the compiler preserves the entire program. Without the preserve blocks the intermediate identity gates could be removed by compiler and hence the DDS would not have achieved the gaps required between the rotation operations.\n", - "\n", - "At the end of each program, we place a `measurement` operator to read out the result." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "# We loop the program in order to run it several times\n", - "'''\n", - "trials : int\n", - " An integer denoting the number of repeats of the program on quantum device\n", - "'''\n", - "trials=1000\n", - "quadratic_program = quadratic_program.wrap_in_numshots_loop(trials)\n", - "\n", - "##Compiling the quadratic program\n", - "executable_quadratic_program_for_qvm = quantum_device.compile(quadratic_program)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "# We loop the program in order to run it several times\n", - "'''\n", - "trials : int\n", - " An integer denoting the number of repeats of the program on quantum device\n", - "'''\n", - "trials=1000\n", - "ramsey_program = ramsey_program.wrap_in_numshots_loop(trials)\n", - "\n", - "##Compiling the quadratic program\n", - "executable_ramsey_program_for_qvm = quantum_device.compile(ramsey_program)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the programs using Pyquil's QVM\n", - "\n", - "Here, we will use the quantum device we created earlier to run the program. The experiment consists of `trials` repeats of the program on a qubit. Each run collects the state of the qubit as measurement. The result is displayed as a histogram. We here define small utility method to plot the trial results for QVM." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_trial_outcomes(trial_result):\n", - " \"\"\"Plots the trial result as probabilities. Expects results from runs involving only\n", - " single qubit\n", - " Parameters\n", - " ----------\n", - " trial_result : numpy.ndarray\n", - " An array where each row contains the output trials in computational basis.\n", - " \"\"\"\n", - " \n", - " qubit_trial_result = trial_result[:, 0]\n", - " \n", - " number_of_trials = qubit_trial_result.shape\n", - " \n", - " outcome = np.array([number_of_trials-np.sum(qubit_trial_result), np.sum(qubit_trial_result)])\n", - " outcome_probabilities = outcome / number_of_trials\n", - " \n", - " plt.bar(np.array([0, 1]), outcome_probabilities)\n", - " plt.xticks(np.array([0, 1]), [0, 1])\n", - " plt.ylabel('Probabilities')\n", - " plt.xlabel('States')\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "quadratic_result = quantum_device.run(executable_quadratic_program_for_qvm)\n", - "plot_trial_outcomes(quadratic_result)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "ramsey_result = quantum_device.run(executable_ramsey_program_for_qvm)\n", - "plot_trial_outcomes(ramsey_result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compiling and running the pograms on Rigetti Quantum Device\n", - "\n", - "We can use the programs created before. However, this time we need to get a real device. You have to have an access to a Rigetti lattice. Follow [the steps](https://www.rigetti.com/) to get an account to access a Rigetti lattice. Once you have account, follow the instructions to [reserve a lattice](https://www.rigetti.com/qcs/docs/reservations) and [run a jupyter notebook](https://www.rigetti.com/qcs/docs/guides#setting-up-a-jupyter-notebook-on-your-qmi)." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "# Get the reserved lattice. In this case we are using 'Aspen-4-2Q-A' - change this to\n", - "# the one you reserve\n", - "quantum_device = get_qc(\"Aspen-4-2Q-A\", as_qvm=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "## Compiling the quadratic program for the chosen real lattice\n", - "executable_quadratic_program_for_lattice = quantum_device.compile(quadratic_program)\n", - "\n", - "## Run the quadratic sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "quadratic_result = quantum_device.run(executable_quadratic_program_for_lattice)\n", - "plot_trial_outcomes(quadratic_result)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# NBVAL_SKIP\n", - "\n", - "## Compiling the ramsey program for the chosen real lattice\n", - "executable_ramsey_program_for_lattice = quantum_device.compile(ramsey_program)\n", - "\n", - "## Run the ramsey sequence program, Get the result (counts of state |1> and |0>), plot the histogram\n", - "ramsey_result = quantum_device.run(executable_ramsey_program_for_lattice)\n", - "plot_trial_outcomes(ramsey_result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Reducing Errors by Increasing the Coherence Time\n", - "\n", - "In the ideal noiseless simulator, both the Ramsey DDS and Quadratic DDS produced exactly the same outcome, the $|1 \\rangle$ state with probability 1. However, in a real device, we can see a marked difference. The Quadratic DDS produced a probability distribution closer to the expected outcome. This is because the Quadratic DDS is able to cancel the effects of magnetic noise in the environment - extending the [T2 time](https://en.wikipedia.org/wiki/Spin–spin_relaxation), and effectively increasing the coherence of the qubit." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From e45b56d0f19c151c65fe6b6b80e0e460cd66dc03 Mon Sep 17 00:00:00 2001 From: Steve Gore Date: Mon, 1 Jul 2019 16:46:40 +1000 Subject: [PATCH 14/16] Add Pyquil --- poetry.lock | 104 ++++++++++++++++++++++++++++++++++++++++++++++++- pyproject.toml | 1 + setup.py | 2 +- 3 files changed, 105 insertions(+), 2 deletions(-) diff --git a/poetry.lock b/poetry.lock index 1600ae8f..d6493097 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,3 +1,11 @@ +[[package]] +category = "main" +description = "ANTLR 4.7.2 runtime for Python 3.6.3" +name = "antlr4-python3-runtime" +optional = false +python-versions = "*" +version = "4.7.2" + [[package]] category = "main" description = "Fast ASN.1 parser and serializer with definitions for private keys, public keys, certificates, CRL, OCSP, CMS, PKCS#3, PKCS#7, PKCS#8, PKCS#12, PKCS#5, X.509 and TSP" @@ -152,6 +160,14 @@ optional = false python-versions = "*" version = "1.1.6" +[[package]] +category = "main" +description = "Clean single-source support for Python 3 and 2" +name = "future" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +version = "0.17.1" + [[package]] category = "main" description = "Google API Client Library for Python" @@ -209,6 +225,14 @@ optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "2.8" +[[package]] +category = "main" +description = "Immutable Collections" +name = "immutables" +optional = false +python-versions = "*" +version = "0.6" + [[package]] category = "dev" description = "Read metadata from Python packages" @@ -334,6 +358,14 @@ optional = false python-versions = "*" version = "1.1.0" +[[package]] +category = "main" +description = "MessagePack (de)serializer." +name = "msgpack" +optional = false +python-versions = "*" +version = "0.6.1" + [[package]] category = "main" description = "Python package for creating and manipulating graphs and networks" @@ -561,6 +593,23 @@ optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" version = "2.4.0" +[[package]] +category = "main" +description = "A Python library to generate Quantum Instruction Language (Quil) Programs." +name = "pyquil" +optional = false +python-versions = ">=3.6" +version = "2.9.1" + +[package.dependencies] +antlr4-python3-runtime = "*" +immutables = "0.6" +networkx = ">=2.0.0" +numpy = "*" +requests = "*" +rpcq = ">=2.5.1" +six = "*" + [[package]] category = "dev" description = "pytest: simple powerful testing with Python" @@ -598,6 +647,14 @@ version = "2.8.0" [package.dependencies] six = ">=1.5" +[[package]] +category = "main" +description = "Python wrapper around rapidjson" +name = "python-rapidjson" +optional = false +python-versions = ">=3.4" +version = "0.7.2" + [[package]] category = "main" description = "World timezone definitions, modern and historical" @@ -606,6 +663,14 @@ optional = false python-versions = "*" version = "2019.1" +[[package]] +category = "main" +description = "Python bindings for 0MQ" +name = "pyzmq" +optional = false +python-versions = ">=2.7,!=3.0*,!=3.1*,!=3.2*" +version = "18.0.2" + [[package]] category = "main" description = "Qiskit provider for accessing the quantum devices and simulators at IBMQ" @@ -676,6 +741,22 @@ cryptography = ">=1.3" ntlm-auth = ">=1.0.2" requests = ">=2.0.0" +[[package]] +category = "main" +description = "The RPC framework and message specification for Rigetti QCS." +name = "rpcq" +optional = false +python-versions = ">=3.6" +version = "2.7.1" + +[package.dependencies] +future = "*" +msgpack = ">=0.6" +python-rapidjson = "*" +pyzmq = ">=17" +"ruamel.yaml" = "*" +typing = "*" + [[package]] category = "main" description = "Pure-Python RSA implementation" @@ -687,6 +768,18 @@ version = "4.0" [package.dependencies] pyasn1 = ">=0.1.3" +[[package]] +category = "main" +description = "ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order" +name = "ruamel.yaml" +optional = false +python-versions = "*" +version = "0.15.97" + +[package.extras] +docs = ["ryd"] +jinja2 = ["ruamel.yaml.jinja2 (>=0.2)"] + [[package]] category = "main" description = "SciPy: Scientific Library for Python" @@ -818,10 +911,11 @@ docs = ["sphinx", "jaraco.packaging (>=3.2)", "rst.linker (>=1.9)"] testing = ["pathlib2", "contextlib2", "unittest2"] [metadata] -content-hash = "432d177b4e1c25d1c57edbb077d1200ebaaa9ff2478834db6019aa43eaff948b" +content-hash = "8d9aa4b7bc758be12f7fd3380faa1500f21d8b0295c7a19b283ae38d8dc48b27" python-versions = ">=3.7.3" [metadata.hashes] +antlr4-python3-runtime = ["168cdcec8fb9152e84a87ca6fd261b3d54c8f6358f42ab3b813b14a7193bb50b"] asn1crypto = ["2f1adbb7546ed199e3c90ef23ec95c5cf3585bac7d11fb7eb562a3fe89c64e87", "9d5c20441baf0cb60a4ac34cc447c6c189024b6b4c6cd7877034f4965c464e49"] astroid = ["6560e1e1749f68c64a4b5dee4e091fce798d2f0d84ebe638cf0e0585a343acf4", "b65db1bbaac9f9f4d190199bb8680af6f6f84fd3769a5ea883df8a91fe68b4c4"] atomicwrites = ["03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4", "75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"] @@ -836,11 +930,13 @@ cryptography = ["24b61e5fcb506424d3ec4e18bca995833839bf13c59fc43e530e488f28d46b8 cycler = ["1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d", "cd7b2d1018258d7247a71425e9f26463dfb444d411c39569972f4ce586b0c9d8"] decorator = ["86156361c50488b84a3f148056ea716ca587df2f0de1d34750d35c21312725de", "f069f3a01830ca754ba5258fde2278454a0b5b79e0d7f5c13b3b97e57d4acff6"] enum34 = ["2d81cbbe0e73112bdfe6ef8576f2238f2ba27dd0d55752a776c41d38b7da2850", "644837f692e5f550741432dd3f223bbb9852018674981b1664e5dc339387588a", "6bd0f6ad48ec2aa117d3d141940d484deccda84d4fcd884f5c3d93c23ecd8c79", "8ad8c4783bf61ded74527bffb48ed9b54166685e4230386a9ed9b1279e2df5b1"] +future = ["67045236dcfd6816dc439556d009594abf643e5eb48992e36beac09c2ca659b8"] google-api-python-client = ["048da0d68564380ee23b449e5a67d4666af1b3b536d2fb0a02cee1ad540fa5ec", "5def5a485b1cbc998b8f869456c7bde0c0e6d3d0a5ea1f300b5ef57cb4b1ce8f"] google-auth = ["0f7c6a64927d34c1a474da92cfc59e552a5d3b940d3266606c6a28b72888b9e4", "20705f6803fd2c4d1cc2dcb0df09d4dfcb9a7d51fd59e94a3a28231fd93119ed"] google-auth-httplib2 = ["098fade613c25b4527b2c08fa42d11f3c2037dda8995d86de0745228e965d445", "f1c437842155680cf9918df9bc51c1182fda41feef88c34004bd1978c8157e08"] httplib2 = ["158fbd0ffbba536829d664bf3f32c4f45df41f8f791663665162dfaf21ffd075", "d1146939d270f1f1eb8cbf8f5aa72ff37d897faccca448582bb1e180aeb4c6b2"] idna = ["c357b3f628cf53ae2c4c05627ecc484553142ca23264e593d327bcde5e9c3407", "ea8b7f6188e6fa117537c3df7da9fc686d485087abf6ac197f9c46432f7e4a3c"] +immutables = ["1e4f4513254ef11e0230a558ee0dcb4551b914993c330005d15338da595d3750", "228e38dc7a810ba4ff88909908ac47f840e5dc6c4c0da6b25009c626a9ae771c", "2ae88fbfe1d04f4e5859c924e97313edf70e72b4f19871bf329b96a67ede9ba0", "2d32b61c222cba1dd11f0faff67c7fb6204ef1982454e1b5b001d4b79966ef17", "35af186bfac5b62522fdf2cab11120d7b0547f405aa399b6a1e443cf5f5e318c", "63023fa0cceedc62e0d1535cd4ca7a1f6df3120a6d8e5c34e89037402a6fd809", "6bf5857f42a96331fd0929c357dc0b36a72f339f3b6acaf870b149c96b141f69", "7bb1590024a032c7a57f79faf8c8ff5e91340662550d2980e0177f67e66e9c9c", "7c090687d7e623d4eca22962635b5e1a1ee2d6f9a9aca2f3fb5a184a1ffef1f2", "bc36a0a8749881eebd753f696b081bd51145e4d77291d671d2e2f622e5b65d2f", "d9fc6a236018d99af6453ead945a6bb55f98d14b1801a2c229dd993edc753a00"] importlib-metadata = ["6dfd58dfe281e8d240937776065dd3624ad5469c835248219bd16cf2e12dbeb7", "cb6ee23b46173539939964df59d3d72c3e0c1b5d54b84f1d8a7e912fe43612db"] isort = ["c40744b6bc5162bbb39c1257fe298b7a393861d50978b565f3ccd9cb9de0182a", "f57abacd059dc3bd666258d1efb0377510a89777fda3e3274e3c01f7c03ae22d"] jsonschema = ["000e68abd33c972a5248544925a0cae7d1125f9bf6c58280d37546b946769a08", "6ff5f3180870836cae40f06fa10419f557208175f13ad7bc26caa77beb1f6e02"] @@ -852,6 +948,7 @@ matplotlib = ["029620799e581802961ac1dcff5cb5d3ee2f602e0db9c0f202a90495b37d2126" mccabe = ["ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42", "dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"] more-itertools = ["2112d2ca570bb7c3e53ea1a35cd5df42bb0fd10c45f0fb97178679c3c03d64c7", "c3e4748ba1aad8dba30a4886b0b1a2004f9a863837b8654e7059eebf727afa5a"] mpmath = ["fc17abe05fbab3382b61a123c398508183406fa132e0223874578e20946499f6"] +msgpack = ["26cb40116111c232bc235ce131cc3b4e76549088cb154e66a2eb8ff6fcc907ec", "300fd3f2c664a3bf473d6a952f843b4a71454f4c592ed7e74a36b205c1782d28", "3129c355342853007de4a2a86e75eab966119733eb15748819b6554363d4e85c", "31f6d645ee5a97d59d3263fab9e6be76f69fa131cddc0d94091a3c8aca30d67a", "3ce7ef7ee2546c3903ca8c934d09250531b80c6127e6478781ae31ed835aac4c", "4008c72f5ef2b7936447dcb83db41d97e9791c83221be13d5e19db0796df1972", "62bd8e43d204580308d477a157b78d3fee2fb4c15d32578108dc5d89866036c8", "70cebfe08fb32f83051971264466eadf183101e335d8107b80002e632f425511", "72cb7cf85e9df5251abd7b61a1af1fb77add15f40fa7328e924a9c0b6bc7a533", "7c55649965c35eb32c499d17dadfb8f53358b961582846e1bc06f66b9bccc556", "86b963a5de11336ec26bc4f839327673c9796b398b9f1fe6bb6150c2a5d00f0f", "8c73c9bcdfb526247c5e4f4f6cf581b9bb86b388df82cfcaffde0a6e7bf3b43a", "8e68c76c6aff4849089962d25346d6784d38e02baa23ffa513cf46be72e3a540", "97ac6b867a8f63debc64f44efdc695109d541ecc361ee2dce2c8884ab37360a1", "9d4f546af72aa001241d74a79caec278bcc007b4bcde4099994732e98012c858", "a28e69fe5468c9f5251c7e4e7232286d71b7dfadc74f312006ebe984433e9746", "fd509d4aa95404ce8d86b4e32ce66d5d706fd6646c205e1c2a715d87078683a2"] networkx = ["8311ddef63cf5c5c5e7c1d0212dd141d9a1fe3f474915281b73597ed5f1d4e3d"] ntlm-auth = ["bb2fd03c665f0f62c5f65695b62dcdb07fb7a45df6ebc86c770be2054d6902dd", "ce5b4483ed761f341a538a426a71a52e5a9cf5fd834ebef1d2090f9eef14b3f8"] numpy = ["0778076e764e146d3078b17c24c4d89e0ecd4ac5401beff8e1c87879043a0633", "141c7102f20abe6cf0d54c4ced8d565b86df4d3077ba2343b61a6db996cefec7", "14270a1ee8917d11e7753fb54fc7ffd1934f4d529235beec0b275e2ccf00333b", "27e11c7a8ec9d5838bc59f809bfa86efc8a4fd02e58960fa9c49d998e14332d5", "2a04dda79606f3d2f760384c38ccd3d5b9bb79d4c8126b67aff5eb09a253763e", "3c26010c1b51e1224a3ca6b8df807de6e95128b0908c7e34f190e7775455b0ca", "52c40f1a4262c896420c6ea1c6fda62cf67070e3947e3307f5562bd783a90336", "6e4f8d9e8aa79321657079b9ac03f3cf3fd067bf31c1cca4f56d49543f4356a5", "7242be12a58fec245ee9734e625964b97cf7e3f2f7d016603f9e56660ce479c7", "7dc253b542bfd4b4eb88d9dbae4ca079e7bf2e2afd819ee18891a43db66c60c7", "94f5bd885f67bbb25c82d80184abbf7ce4f6c3c3a41fbaa4182f034bba803e69", "a89e188daa119ffa0d03ce5123dee3f8ffd5115c896c2a9d4f0dbb3d8b95bfa3", "ad3399da9b0ca36e2f24de72f67ab2854a62e623274607e37e0ce5f5d5fa9166", "b0348be89275fd1d4c44ffa39530c41a21062f52299b1e3ee7d1c61f060044b8", "b5554368e4ede1856121b0dfa35ce71768102e4aa55e526cb8de7f374ff78722", "cbddc56b2502d3f87fda4f98d948eb5b11f36ff3902e17cb6cc44727f2200525", "d79f18f41751725c56eceab2a886f021d70fd70a6188fd386e29a045945ffc10", "dc2ca26a19ab32dc475dbad9dfe723d3a64c835f4c23f625c2b6566ca32b9f29", "dd9bcd4f294eb0633bb33d1a74febdd2b9018b8b8ed325f861fffcd2c7660bb8", "e8baab1bc7c9152715844f1faca6744f2416929de10d7639ed49555a85549f52", "ec31fe12668af687b99acf1567399632a7c47b0e17cfb9ae47c098644ef36797", "f12b4f7e2d8f9da3141564e6737d79016fe5336cc92de6814eba579744f65b0a", "f58ac38d5ca045a377b3b377c84df8175ab992c970a53332fa8ac2373df44ff7"] @@ -873,14 +970,19 @@ pylatexenc = ["ef2d5260c38e2cb4d2829e8b918914a558557820d4f57cb6588a81e827de2bb3" pylint = ["5d77031694a5fb97ea95e828c8d10fc770a1df6eb3906067aaed42201a8a6a09", "723e3db49555abaf9bf79dc474c6b9e2935ad82230b10c1138a71ea41ac0fff1"] pylint-runner = ["9e04d72471a9225db6734334ec578ac37b47130625553df149ca6a20ecd565a9", "bc44a39ad93ffa865f282dff26632ac78b60ce53c417d4b1de82b52842d1e6e8"] pyparsing = ["1873c03321fc118f4e9746baf201ff990ceb915f433f23b395f5580d1840cb2a", "9b6323ef4ab914af344ba97510e966d64ba91055d6b9afa6b30799340e89cc03"] +pyquil = ["4bc4fa3efea9cc78b26a215b87e6a38463cd575addf0d0cb24750532ddbf93b6"] pytest = ["4a784f1d4f2ef198fe9b7aef793e9fa1a3b2f84e822d9b3a64a181293a572d45", "926855726d8ae8371803f7b2e6ec0a69953d9c6311fa7c3b6c1b929ff92d27da"] python-dateutil = ["7e6584c74aeed623791615e26efd690f29817a27c73085b78e4bad02493df2fb", "c89805f6f4d64db21ed966fda138f8a5ed7a4fdbc1a8ee329ce1b74e3c74da9e"] +python-rapidjson = ["0710751aaf31738c102f41af4330b62df8023914ce9481244a2b3cc964776ceb", "090a0c8604759a47db56fad0a7817eaa072bb7eb3aa76f71a4fa6c58c1302b74", "0d32c2b0f5fc2b29f8317ec77ae141655814fe151ef530adb007b33f8b48abdf", "14929156740a37bc3ec18aa6ac8b17013f4e9ecf2f2ac31267b8b4d601654ea4", "16d7cbf00709a8d849359fa41c5cd462354af1dea10d9e1fe6e2865c36d533ec", "1a6e6e023a42b48f3a440723cca8cc16be3a5db9ea8f5c3e48aa63bc2d5fe79f", "2c639e8f064a1bfa8285fec1cd72361a5ccd8adc64497ab9f9e3799edbbc5694", "3656dba8038ec08fa6aec1ccb9b8b04e4f3d747c41ae2a63a3b40076653d7439", "3e15b1fda6f8b4dc15528c473d1bdb178b942c260a7822f112292059228cf057", "467ca7ee00f20683161c868ce16a3deb68b233a4a4fcc072b41f1cb7c89171f4", "6a09c0bb905fdc30527c0147ba530b26f3091ecdba19eb1aa4a6c0fcfa4230ee", "795e3a0fdaccbf229b7b2b78f2f2b83a6884a6f3690ae49e64e90465401b1a9b", "7bf4c40ad402eacce5a4e80f4bfb39e38fa9662a95c2a58f3f497f590bfd1c7d", "7d38228984ced0a95da469e5f77c5affb67fc6c6dd2214fd738af63d386fc48a", "93804ffffda7bb7db43cd3d736623805adf147372eed4d10ce9464663881acf3", "94a25d52c434439afb6a64930a4dd3ea85fbcbb164a7bddea3ade3552c7e877e", "9c62b96d22203f58183e3cebdbcab407babbad13ed6ccc8b3fd461d9c475157f", "af97a0c37747bf9b9e0176394ebbfe2bb8543eecff91d38824dafbd27fef4a20", "c745bbac3047d9d2dd6dc55d7fdfc34bb08f40a1873ac8c8e2a5bf9a144fb1e5", "eaf930000666aabdb62253201f291406e1dc407655788d8074c91ba361fb1909", "fd665648dc3b4416ceafb7dc155061b639a350c28650b3d028f769a91184ce69"] pytz = ["303879e36b721603cc54604edcac9d20401bdbe31e1e4fdee5b9f98d5d31dfda", "d747dd3d23d77ef44c6a3526e274af6efeb0a6f1afd5a69ba4d5be4098c8e141"] +pyzmq = ["00dd015159eaeb1c0731ad49310e1f5d839c9a35a15e4f3267f5052233fad99b", "03913b6beb8e7b417b9910b0ee1fd5d62e9626d218faefbe879d70714ceab1a2", "13f17386df81d5e6efb9a4faea341d8de22cdc82e49a326dded26e33f42a3112", "16c6281d96885db1e15f7047ddc1a8f48ff4ea35d31ca709f4d2eb39f246d356", "17efab4a804e31f58361631256d660214204046f9e2b962738b171b9ad674ea7", "2b79919ddeff3d3c96aa6087c21d294c8db1c01f6bfeee73324944683685f419", "2f832e4711657bb8d16ea1feba860f676ec5f14fb9fe3b449b5953a60e89edae", "31a11d37ac73107363b47e14c94547dbfc6a550029c3fe0530be443199026fc2", "33a3e928e6c3138c675e1d6702dd11f6b7050177d7aab3fc322db6e1d2274490", "34a38195a6d3a9646cbcdaf8eb245b4d935c7a57f7e1b3af467814bc1a92467e", "42900054f1500acef6df7428edf806abbf641bf92eb9ceded24aa863397c3bae", "4ccc7f3c63aa9d744dadb62c49eda2d0e7de55649b80c45d7c684d70161a69af", "5b220c37c346e6575db8c88a940c1fc234f99ce8e0068c408919bb8896c4b6d2", "6074848da5c8b44a1ca40adf75cf65aa92bc80f635e8249aa8f37a69b2b9b6f5", "61a4155964bd4a14ef95bf46cb1651bcf8dcbbed8c0108e9c974c1fcbb57788f", "62b5774688326600c52f587f7a033ca6b6284bef4c8b1b5fda32480897759eac", "65a9ffa4f9f085d696f16fd7541f34b3c357d25fe99c90e3bce2ea59c3b5b4b6", "76a077d2c30f8adc5e919a55985a784b96aeca69b53c1ea6fd5723d3ae2e6f53", "8e5b4c51557071d6379d6dc1f54f35e9f6a137f5e84e102efb869c8d3c13c8ff", "917f73e07cc04f0678a96d93e7bb8b1adcccdde9ccfe202e622814f4d1d1ecfd", "91c75d3c4c357f9643e739db9e79ab9681b2f6ae8ec5678d6ef2ea0d01532596", "923dd91618b100bb4c92ab9ed7b65825a595b8524a094ce03c7cb2aaae7d353b", "9849054e0355e2bc7f4668766a25517ba76095031c9ff5e39ae8949cee5bb024", "c9d453933f0e3f44b9759189f2a18aa765f7f1a4345c727c18ebe8ad0d748d26", "cb7514936277abce64c2f4c56883e5704d85ed04d98d2d432d1c6764003bb003"] qiskit-ibmq-provider = ["5fc05803ead012ed38601ae7fab5846ee23806929b1056a243c53ef615f92986"] qiskit-terra = ["00ec6540c6bd67bc9fbd0cfa96fe7e78b0ba880d2fbc4d9a0dd96e57e22cff5e", "1433898f50c50fcaf8479abf0fee5ddaf58600e7039b74dc2e5cd2b4c0d91cc0", "1bb07d9c9ae27c7cefca991b973489b3c25b0d1a3ee641f9112bd76b7a9742b2", "278ed6f44fb4d7602cfa99f23c8e64c44c05e3231179d457b5be69c599d8882c", "5e6a20bafb8da900edee07834530be92fdb5c3117ddab2094861a7959d81299a", "7901b111c2b699bac20a66d036e043915099a463576cda4808e6198bb61de95a", "839a58ec5a9847d0670cec54883bfefffa0b90e749ab2c26afdd640bbcd4b83e", "948dd75c6ea78356ea8e6e6cd55ed7d7c7c77f8b9c658b49c93009f2d8e27edb", "9ba5111fdd0c417f5257c703b6c64f3f1873c6538792e527ceb3f1cfbc558031", "abf2c59d4a3a5fab2f1d6c7a67118a178a55178c1e4d893ecca5b3dbb6271a76", "b1fc4c3b82ef72b53d37dfaf25489ffaa7601220e7e86d9a3a8563ca0d60f8dd", "b5334e8c8b4b8c5f26aba2f7a289d74e82add1ec8fdcda4d6600e25019c6cb53", "ba87d8e1f8b0a7f1152878f738d4279d5839cca8d51b9a6a512f4df34b7b8c52", "e4259ebda66dc753315b428be528002caf34ed6d01062de9794873c81763b286", "e51ef8b187006a81ad2eb677cade958cff6788b643f901e4f23c9e4319b6a5e3", "ffa218f1b14c736aae025c99aed58f9d38cf287766c00e7d78024c037e012fa0"] requests = ["11e007a8a2aa0323f5a921e9e6a2d7e4e67d9877e85773fba9ba6419025cbeb4", "9cf5292fcd0f598c671cfc1e0d7d1a7f13bb8085e9a590f48c010551dc6c4b31"] requests-ntlm = ["1eb43d1026b64d431a8e0f1e8a8c8119ac698e72e9b95102018214411a8463ea", "9189c92e8c61ae91402a64b972c4802b2457ce6a799d658256ebf084d5c7eb71"] +rpcq = ["21356e3ba4d5068f9b73e08013a8342073d55d367830310ab02874c558d924ed"] rsa = ["14ba45700ff1ec9eeb206a2ce76b32814958a98e372006c8fb76ba820211be66", "1a836406405730121ae9823e19c6e806c62bbad73f890574fff50efa4122c487"] +"ruamel.yaml" = ["17dbf6b7362e7aee8494f7a0f5cffd44902a6331fe89ef0853b855a7930ab845", "23731c9efb79f3f5609dedffeb6c5c47a68125fd3d4b157d9fc71b1cd49076a9", "2bbdd598ae57bac20968cf9028cc67d37d83bdb7942a94b9478110bc72193148", "34586084cdd60845a3e1bece2b58f0a889be25450db8cc0ea143ddf0f40557a2", "35957fedbb287b01313bb5c556ffdc70c0277c3500213b5e73dfd8716f748d77", "414cb87a40974a575830b406ffab4ab8c6cbd82eeb73abd2a9d1397c1f0223e1", "428775be75db68d908b17e4e8dda424c410222f170dc173246aa63e972d094b3", "514f670f7d36519bda504d507edfe63e3c20489f86c86d42bc4d9a6dbdf82c7b", "5cb962c1ac6887c5da29138fbbe3b4b7705372eb54e599907fa63d4cd743246d", "5f6e30282cf70fb7754e1a5f101e27b5240009766376e131b31ab49f14fe81be", "86f8e010af6af0b4f42de2d0d9b19cb441e61d3416082186f9dd03c8552d13ad", "8d47ed1e557d546bd2dfe54f504d7274274602ff7a0652cde84c258ad6c2d96d", "98668876720bce1ac08562d8b93a564a80e3397e442c7ea19cebdcdf73da7f74", "9e1f0ddc18d8355dcf5586a5d90417df56074f237812b8682a93b62cca9d2043", "a7bc812a72a79d6b7dbb96fa5bee3950464b65ec055d3abc4db6572f2373a95c", "b72e13f9f206ee103247b07afd5a39c8b1aa98e8eba80ddba184d030337220ba", "bcff8ea9d916789e85e24beed8830c157fb8bc7c313e554733a8151540e66c01", "c76e78b3bab652069b8d6f7889b0e72f3455c2b854b2e0a8818393d149ad0a0d"] scipy = ["03b1e0775edbe6a4c64effb05fff2ce1429b76d29d754aa5ee2d848b60033351", "09d008237baabf52a5d4f5a6fcf9b3c03408f3f61a69c404472a16861a73917e", "10325f0ffac2400b1ec09537b7e403419dcd25d9fee602a44e8a32119af9079e", "1db9f964ed9c52dc5bd6127f0dd90ac89791daa690a5665cc01eae185912e1ba", "409846be9d6bdcbd78b9e5afe2f64b2da5a923dd7c1cd0615ce589489533fdbb", "4907040f62b91c2e170359c3d36c000af783f0fa1516a83d6c1517cde0af5340", "6c0543f2fdd38dee631fb023c0f31c284a532d205590b393d72009c14847f5b1", "826b9f5fbb7f908a13aa1efd4b7321e36992f5868d5d8311c7b40cf9b11ca0e7", "a7695a378c2ce402405ea37b12c7a338a8755e081869bd6b95858893ceb617ae", "a84c31e8409b420c3ca57fd30c7589378d6fdc8d155d866a7f8e6e80dec6fd06", "adadeeae5500de0da2b9e8dd478520d0a9945b577b2198f2462555e68f58e7ef", "b283a76a83fe463c9587a2c88003f800e08c3929dfbeba833b78260f9c209785", "c19a7389ab3cd712058a8c3c9ffd8d27a57f3d84b9c91a931f542682bb3d269d", "c3bb4bd2aca82fb498247deeac12265921fe231502a6bc6edea3ee7fe6c40a7a", "c5ea60ece0c0c1c849025bfc541b60a6751b491b6f11dd9ef37ab5b8c9041921", "db61a640ca20f237317d27bc658c1fc54c7581ff7f6502d112922dc285bdabee"] six = ["3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c", "d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"] snowballstemmer = ["919f26a68b2c17a7634da993d91339e288964f93c274f1343e3bbbe2096e1128", "9f3bcd3c401c3e862ec0ebe6d2c069ebc012ce142cce209c098ccb5b09136e89"] diff --git a/pyproject.toml b/pyproject.toml index 8f744637..c597bfa5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,6 +38,7 @@ scipy = "^1.3" qiskit-terra = "^0.8.1" qiskit-ibmq-provider = "^0.2.2" cirq = "^0.5.0" +pyquil = "^2.9" [tool.poetry.dev-dependencies] pytest = "*" diff --git a/setup.py b/setup.py index a474ffd2..e8b68da5 100644 --- a/setup.py +++ b/setup.py @@ -35,6 +35,6 @@ classifiers=['Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Intended Audience :: Education', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: Apache Software License', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3.6', 'Topic :: Scientific/Engineering :: Physics', 'Topic :: Scientific/Engineering :: Visualization', 'Topic :: Software Development :: Embedded Systems', 'Topic :: System :: Distributed Computing'], packages=['qctrlopencontrols', 'qctrlopencontrols.base', 'qctrlopencontrols.cirq', 'qctrlopencontrols.driven_controls', 'qctrlopencontrols.dynamic_decoupling_sequences', 'qctrlopencontrols.exceptions', 'qctrlopencontrols.globals', 'qctrlopencontrols.pyquil', 'qctrlopencontrols.qiskit'], package_data={}, - install_requires=['cirq==0.*,>=0.5.0', 'numpy==1.*,>=1.16.0', 'qiskit-ibmq-provider==0.*,>=0.2.2', 'qiskit-terra==0.*,>=0.8.1', 'scipy==1.*,>=1.3.0'], + install_requires=['cirq==0.*,>=0.5.0', 'numpy==1.*,>=1.16.0', 'pyquil==2.*,>=2.9.0', 'qiskit-ibmq-provider==0.*,>=0.2.2', 'qiskit-terra==0.*,>=0.8.1', 'scipy==1.*,>=1.3.0'], extras_require={'dev': ['pylama', 'pylint', 'pylint-runner', 'pytest']}, ) From e48474182d957eb5da7ef8dc10dd464289c632ad Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Tue, 2 Jul 2019 15:55:56 +1000 Subject: [PATCH 15/16] Reviews addressed --- qctrlopencontrols/cirq/circuit.py | 57 ++++++++------------- qctrlopencontrols/pyquil/program.py | 51 ++++++------------ qctrlopencontrols/qiskit/quantum_circuit.py | 51 ++++++------------ tests/test_pyquil_sequence.py | 4 +- 4 files changed, 57 insertions(+), 106 deletions(-) diff --git a/qctrlopencontrols/cirq/circuit.py b/qctrlopencontrols/cirq/circuit.py index fc23ba36..7ba7dcc8 100644 --- a/qctrlopencontrols/cirq/circuit.py +++ b/qctrlopencontrols/cirq/circuit.py @@ -108,8 +108,7 @@ def convert_dds_to_cirq_circuit( 'Time delay of gates must be greater than zero.', {'gate_time': gate_time}) - if target_qubits is None: - target_qubits = [cirq.LineQubit(0)] + target_qubits = target_qubits or [cirq.LineQubit(0)] if algorithm not in [FIX_DURATION_UNITARY, INSTANT_UNITARY]: raise ArgumentsValueError('Algorithm must be one of {} or {}'.format( @@ -123,42 +122,32 @@ def convert_dds_to_cirq_circuit( azimuthal_angles = dynamic_decoupling_sequence.azimuthal_angles detuning_rotations = dynamic_decoupling_sequence.detuning_rotations - if len(rabi_rotations.shape) == 1: - rabi_rotations = rabi_rotations[np.newaxis, :] - if len(azimuthal_angles.shape) == 1: - azimuthal_angles = azimuthal_angles[np.newaxis, :] - if len(detuning_rotations.shape) == 1: - detuning_rotations = detuning_rotations[np.newaxis, :] - - operations = np.vstack((rabi_rotations, azimuthal_angles, detuning_rotations)) offsets = dynamic_decoupling_sequence.offsets time_covered = 0 circuit = cirq.Circuit() - for operation_idx in range(operations.shape[1]): + for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( + list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): - offset_distance = offsets[operation_idx] - time_covered + offset_distance = offset - time_covered if np.isclose(offset_distance, 0.0): offset_distance = 0.0 if offset_distance < 0: raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': operations}) - - if offset_distance > 0: - while (time_covered+gate_time) <= offsets[operation_idx]: - gate_list = [] - for qubit in target_qubits: - gate_list.append(cirq.I(qubit)) - time_covered += gate_time - circuit.append(gate_list) - - rabi_rotation = operations[0, operation_idx] - azimuthal_angle = operations[1, operation_idx] + {'sequence_operations': str(dynamic_decoupling_sequence)}) + + while (time_covered+gate_time) <= offset: + gate_list = [] + for qubit in target_qubits: + gate_list.append(cirq.I(qubit)) + time_covered += gate_time + circuit.append(gate_list) + x_rotation = rabi_rotation * np.cos(azimuthal_angle) y_rotation = rabi_rotation * np.sin(azimuthal_angle) - z_rotation = operations[2, operation_idx] + z_rotation = detuning_rotation rotations = np.array([x_rotation, y_rotation, z_rotation]) zero_pulses = np.isclose(rotations, 0.0).astype(np.int) @@ -169,13 +158,10 @@ def convert_dds_to_cirq_circuit( 'valid pulse at any offset. Found sequence ' 'with multiple rotation operations at an offset.', {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': dynamic_decoupling_sequence.offsets[operation_idx], - 'rabi_rotation': dynamic_decoupling_sequence.rabi_rotations[ - operation_idx], - 'azimuthal_angle': dynamic_decoupling_sequence.azimuthal_angles[ - operation_idx], - 'detuning_rotaion': dynamic_decoupling_sequence.detuning_rotations[ - operation_idx]} + 'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotaion': detuning_rotation} ) gate_list = [] @@ -190,10 +176,9 @@ def convert_dds_to_cirq_circuit( elif not np.isclose(rotations[2], 0.): gate_list.append(cirq.Rz(rotations[2])(qubit)) circuit.append(gate_list) - if np.isclose(np.sum(rotations), 0.0): - time_covered = offsets[operation_idx] - else: - time_covered = offsets[operation_idx] + unitary_time + + time_covered = offset + unitary_time + if add_measurement: gate_list = [] for idx, qubit in enumerate(target_qubits): diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index 8a86c1d1..d52fcd87 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -46,7 +46,7 @@ def convert_dds_to_pyquil_program( The dynamic decoupling sequence target_qubits : list, optional List of integers specifying target qubits for the sequence operation; - defaults to None + defaults to None in which case 0-th Qubit is used gate_time : float, optional Time (in seconds) delay introduced by a gate; defaults to 0.1 add_measurement : bool, optional @@ -103,8 +103,7 @@ def convert_dds_to_pyquil_program( {'type(dynamic_decoupling_sequence)': type(dynamic_decoupling_sequence)}) - if target_qubits is None: - target_qubits = [0] + target_qubits = target_qubits or [0] if gate_time <= 0: raise ArgumentsValueError( @@ -113,7 +112,7 @@ def convert_dds_to_pyquil_program( if np.any(target_qubits) < 0: raise ArgumentsValueError( - 'Every target qubits index must be positive.', + 'Every target qubits index must be non-negative.', {'target_qubits': target_qubits}) if algorithm not in [FIX_DURATION_UNITARY, INSTANT_UNITARY]: @@ -128,42 +127,32 @@ def convert_dds_to_pyquil_program( azimuthal_angles = dynamic_decoupling_sequence.azimuthal_angles detuning_rotations = dynamic_decoupling_sequence.detuning_rotations - if len(rabi_rotations.shape) == 1: - rabi_rotations = rabi_rotations[np.newaxis, :] - if len(azimuthal_angles.shape) == 1: - azimuthal_angles = azimuthal_angles[np.newaxis, :] - if len(detuning_rotations.shape) == 1: - detuning_rotations = detuning_rotations[np.newaxis, :] - - operations = np.vstack((rabi_rotations, azimuthal_angles, detuning_rotations)) offsets = dynamic_decoupling_sequence.offsets time_covered = 0 program = Program() program += Pragma('PRESERVE_BLOCK') - for operation_idx in range(operations.shape[1]): + for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( + list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): - offset_distance = offsets[operation_idx] - time_covered + offset_distance = offset - time_covered if np.isclose(offset_distance, 0.0): offset_distance = 0.0 if offset_distance < 0: raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': operations}) + {'sequence_operations': str(dynamic_decoupling_sequence)}) - if offset_distance > 0: - while (time_covered+gate_time) <= offsets[operation_idx]: - for qubit in target_qubits: - program += I(qubit) - time_covered += gate_time + while (time_covered+gate_time) <= offset: + for qubit in target_qubits: + program += I(qubit) + time_covered += gate_time - rabi_rotation = operations[0, operation_idx] - azimuthal_angle = operations[1, operation_idx] x_rotation = rabi_rotation * np.cos(azimuthal_angle) y_rotation = rabi_rotation * np.sin(azimuthal_angle) - z_rotation = operations[2, operation_idx] + z_rotation = detuning_rotation rotations = np.array([x_rotation, y_rotation, z_rotation]) zero_pulses = np.isclose(rotations, 0.0).astype(np.int) @@ -174,13 +163,10 @@ def convert_dds_to_pyquil_program( 'valid pulse at any offset. Found sequence ' 'with multiple rotation operations at an offset.', {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': dynamic_decoupling_sequence.offsets[operation_idx], - 'rabi_rotation': dynamic_decoupling_sequence.rabi_rotations[ - operation_idx], - 'azimuthal_angle': dynamic_decoupling_sequence.azimuthal_angles[ - operation_idx], - 'detuning_rotaion': dynamic_decoupling_sequence.detuning_rotations[ - operation_idx]} + 'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotaion': detuning_rotation} ) for qubit in target_qubits: @@ -194,10 +180,7 @@ def convert_dds_to_pyquil_program( elif not np.isclose(rotations[2], 0.): program += RZ(rotations[2], qubit) - if np.isclose(np.sum(rotations), 0.0): - time_covered = offsets[operation_idx] - else: - time_covered = offsets[operation_idx] + unitary_time + time_covered = offset + unitary_time if add_measurement: readout = program.declare('ro', 'BIT', len(target_qubits)) diff --git a/qctrlopencontrols/qiskit/quantum_circuit.py b/qctrlopencontrols/qiskit/quantum_circuit.py index e5177453..f8878fd2 100644 --- a/qctrlopencontrols/qiskit/quantum_circuit.py +++ b/qctrlopencontrols/qiskit/quantum_circuit.py @@ -107,8 +107,7 @@ def convert_dds_to_qiskit_quantum_circuit( {'type(dynamic_decoupling_sequence)': type(dynamic_decoupling_sequence)}) - if target_qubits is None: - target_qubits = [0] + target_qubits = target_qubits or [0] if gate_time <= 0: raise ArgumentsValueError( @@ -117,7 +116,7 @@ def convert_dds_to_qiskit_quantum_circuit( if np.any(target_qubits) < 0: raise ArgumentsValueError( - 'Every target qubits index must be positive.', + 'Every target qubits index must be non-negative.', {'target_qubits': target_qubits}) if algorithm not in [FIX_DURATION_UNITARY, INSTANT_UNITARY]: @@ -152,40 +151,30 @@ def convert_dds_to_qiskit_quantum_circuit( azimuthal_angles = dynamic_decoupling_sequence.azimuthal_angles detuning_rotations = dynamic_decoupling_sequence.detuning_rotations - if len(rabi_rotations.shape) == 1: - rabi_rotations = rabi_rotations[np.newaxis, :] - if len(azimuthal_angles.shape) == 1: - azimuthal_angles = azimuthal_angles[np.newaxis, :] - if len(detuning_rotations.shape) == 1: - detuning_rotations = detuning_rotations[np.newaxis, :] - - operations = np.vstack((rabi_rotations, azimuthal_angles, detuning_rotations)) offsets = dynamic_decoupling_sequence.offsets time_covered = 0 - for operation_idx in range(operations.shape[1]): + for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( + list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): - offset_distance = offsets[operation_idx] - time_covered + offset_distance = offset - time_covered if np.isclose(offset_distance, 0.0): offset_distance = 0.0 if offset_distance < 0: raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': operations}) + {'sequence_operations': str(dynamic_decoupling_sequence)}) - if offset_distance > 0: - while (time_covered+gate_time) <= offsets[operation_idx]: - for qubit in target_qubits: - quantum_circuit.iden(quantum_registers[qubit]) # pylint: disable=no-member - quantum_circuit.barrier(quantum_registers[qubit]) # pylint: disable=no-member - time_covered += gate_time + while (time_covered+gate_time) <= offset: + for qubit in target_qubits: + quantum_circuit.iden(quantum_registers[qubit]) # pylint: disable=no-member + quantum_circuit.barrier(quantum_registers[qubit]) # pylint: disable=no-member + time_covered += gate_time - rabi_rotation = operations[0, operation_idx] - azimuthal_angle = operations[1, operation_idx] x_rotation = rabi_rotation * np.cos(azimuthal_angle) y_rotation = rabi_rotation * np.sin(azimuthal_angle) - z_rotation = operations[2, operation_idx] + z_rotation = detuning_rotation rotations = np.array([x_rotation, y_rotation, z_rotation]) zero_pulses = np.isclose(rotations, 0.0).astype(np.int) @@ -196,13 +185,10 @@ def convert_dds_to_qiskit_quantum_circuit( 'valid pulse at any offset. Found sequence ' 'with multiple rotation operations at an offset.', {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': dynamic_decoupling_sequence.offsets[operation_idx], - 'rabi_rotation': dynamic_decoupling_sequence.rabi_rotations[ - operation_idx], - 'azimuthal_angle': dynamic_decoupling_sequence.azimuthal_angles[ - operation_idx], - 'detuning_rotaion': dynamic_decoupling_sequence.detuning_rotations[ - operation_idx]} + 'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotaion': detuning_rotation} ) for qubit in target_qubits: @@ -225,10 +211,7 @@ def convert_dds_to_qiskit_quantum_circuit( quantum_registers[qubit]) quantum_circuit.barrier(quantum_registers[qubit]) # pylint: disable=no-member - if np.isclose(np.sum(rotations), 0.0): - time_covered = offsets[operation_idx] - else: - time_covered = offsets[operation_idx] + unitary_time + time_covered = offset + unitary_time if add_measurement: for q_index, qubit in enumerate(target_qubits): diff --git a/tests/test_pyquil_sequence.py b/tests/test_pyquil_sequence.py index 4fec845a..fd38ac5a 100644 --- a/tests/test_pyquil_sequence.py +++ b/tests/test_pyquil_sequence.py @@ -30,7 +30,7 @@ def test_pyquil_program(): """Tests if the Dynamic Decoupling Sequence gives rise to Identity - operation in Qiskit + operation in Pyquil """ _duration = 5e-6 _offsets = [0, 1e-6, 2.5e-6, 4e-6, 5e-6] @@ -64,4 +64,4 @@ def test_pyquil_program(): assert program[9] == RX(np.pi / 2, 0) if __name__ == '__main__': - pass + test_pyquil_program() From fb4abca009278df3828e888d9b8a3a2d2eb3a437 Mon Sep 17 00:00:00 2001 From: Rajib Chakravorty Date: Fri, 5 Jul 2019 10:54:34 +1000 Subject: [PATCH 16/16] error messages updated --- qctrlopencontrols/cirq/circuit.py | 23 +++++++++++++-------- qctrlopencontrols/pyquil/program.py | 23 +++++++++++++-------- qctrlopencontrols/qiskit/quantum_circuit.py | 23 +++++++++++++-------- 3 files changed, 42 insertions(+), 27 deletions(-) diff --git a/qctrlopencontrols/cirq/circuit.py b/qctrlopencontrols/cirq/circuit.py index 7ba7dcc8..8595946e 100644 --- a/qctrlopencontrols/cirq/circuit.py +++ b/qctrlopencontrols/cirq/circuit.py @@ -127,7 +127,8 @@ def convert_dds_to_cirq_circuit( time_covered = 0 circuit = cirq.Circuit() for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( - list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): + list(offsets), list(rabi_rotations), + list(azimuthal_angles), list(detuning_rotations)): offset_distance = offset - time_covered @@ -135,8 +136,12 @@ def convert_dds_to_cirq_circuit( offset_distance = 0.0 if offset_distance < 0: - raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': str(dynamic_decoupling_sequence)}) + raise ArgumentsValueError( + "Offsets cannot be placed properly. Spacing between the rotations" + "is smaller than the time required to perform the rotation. Provide" + "a longer dynamic decoupling sequence or shorted gate time.", + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence, + 'gate_time': gate_time}) while (time_covered+gate_time) <= offset: gate_list = [] @@ -155,13 +160,13 @@ def convert_dds_to_cirq_circuit( if nonzero_pulse_counts > 1: raise ArgumentsValueError( 'Open Controls support a sequence with one ' - 'valid pulse at any offset. Found sequence ' + 'valid rotation at any offset. Found a sequence ' 'with multiple rotation operations at an offset.', - {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': offset, - 'rabi_rotation': rabi_rotation, - 'azimuthal_angle': azimuthal_angle, - 'detuning_rotaion': detuning_rotation} + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence}, + extras={'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotation': detuning_rotation} ) gate_list = [] diff --git a/qctrlopencontrols/pyquil/program.py b/qctrlopencontrols/pyquil/program.py index d52fcd87..52e18a29 100644 --- a/qctrlopencontrols/pyquil/program.py +++ b/qctrlopencontrols/pyquil/program.py @@ -134,7 +134,8 @@ def convert_dds_to_pyquil_program( program += Pragma('PRESERVE_BLOCK') for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( - list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): + list(offsets), list(rabi_rotations), + list(azimuthal_angles), list(detuning_rotations)): offset_distance = offset - time_covered @@ -142,8 +143,12 @@ def convert_dds_to_pyquil_program( offset_distance = 0.0 if offset_distance < 0: - raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': str(dynamic_decoupling_sequence)}) + raise ArgumentsValueError( + "Offsets cannot be placed properly. Spacing between the rotations" + "is smaller than the time required to perform the rotation. Provide" + "a longer dynamic decoupling sequence or shorted gate time.", + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence, + 'gate_time': gate_time}) while (time_covered+gate_time) <= offset: for qubit in target_qubits: @@ -160,13 +165,13 @@ def convert_dds_to_pyquil_program( if nonzero_pulse_counts > 1: raise ArgumentsValueError( 'Open Controls support a sequence with one ' - 'valid pulse at any offset. Found sequence ' + 'valid rotation at any offset. Found a sequence ' 'with multiple rotation operations at an offset.', - {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': offset, - 'rabi_rotation': rabi_rotation, - 'azimuthal_angle': azimuthal_angle, - 'detuning_rotaion': detuning_rotation} + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence}, + extras={'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotation': detuning_rotation} ) for qubit in target_qubits: diff --git a/qctrlopencontrols/qiskit/quantum_circuit.py b/qctrlopencontrols/qiskit/quantum_circuit.py index f8878fd2..ca348cab 100644 --- a/qctrlopencontrols/qiskit/quantum_circuit.py +++ b/qctrlopencontrols/qiskit/quantum_circuit.py @@ -155,7 +155,8 @@ def convert_dds_to_qiskit_quantum_circuit( time_covered = 0 for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip( - list(offsets), list(rabi_rotations), list(azimuthal_angles), list(detuning_rotations)): + list(offsets), list(rabi_rotations), + list(azimuthal_angles), list(detuning_rotations)): offset_distance = offset - time_covered @@ -163,8 +164,12 @@ def convert_dds_to_qiskit_quantum_circuit( offset_distance = 0.0 if offset_distance < 0: - raise ArgumentsValueError("Offsets cannot be placed properly", - {'sequence_operations': str(dynamic_decoupling_sequence)}) + raise ArgumentsValueError( + "Offsets cannot be placed properly. Spacing between the rotations" + "is smaller than the time required to perform the rotation. Provide" + "a longer dynamic decoupling sequence or shorted gate time.", + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence, + 'gate_time': gate_time}) while (time_covered+gate_time) <= offset: for qubit in target_qubits: @@ -182,13 +187,13 @@ def convert_dds_to_qiskit_quantum_circuit( if nonzero_pulse_counts > 1: raise ArgumentsValueError( 'Open Controls support a sequence with one ' - 'valid pulse at any offset. Found sequence ' + 'valid rotation at any offset. Found a sequence ' 'with multiple rotation operations at an offset.', - {'dynamic_decoupling_sequence': str(dynamic_decoupling_sequence), - 'offset': offset, - 'rabi_rotation': rabi_rotation, - 'azimuthal_angle': azimuthal_angle, - 'detuning_rotaion': detuning_rotation} + {'dynamic_decoupling_sequence': dynamic_decoupling_sequence}, + extras={'offset': offset, + 'rabi_rotation': rabi_rotation, + 'azimuthal_angle': azimuthal_angle, + 'detuning_rotation': detuning_rotation} ) for qubit in target_qubits: