diff --git a/.circleci/config.yml b/.circleci/config.yml index f7799b20..96f2eaf9 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1,15 +1,46 @@ -version: 2 +version: 2.1 -jobs: - build: - working_directory: ~/open-controls - docker: - - image: continuumio/anaconda3 - steps: - - run: apt-get -y install build-essential - - checkout - - run: python3 setup.py install - - run: pytest - - run: pytest --nbval-lax examples/*.ipynb --sanitize-with examples/notebook-sanitize.cfg - - run: pylint qctrlopencontrols --rcfile=.pylintrc - - run: pylint tests --rcfile=.pylintrc \ No newline at end of file +orbs: + q-ctrl: q-ctrl/python@dev:0.1.0 + +workflows: + version: 2 + + "PyPi Project": + jobs: + - q-ctrl/pytest_python_36_open: + context: q-ctrl-api-development + filters: + tags: # Tag filter required because the release job has a tag filter + only: /.*/ + - q-ctrl/open_build: + context: q-ctrl-api-development + filters: + branches: + only: + - master + - development + tags: # Tag filter required because the release job has a tag filter + only: /.*/ + - q-ctrl/pypi_publish: + context: q-ctrl-api-development + requires: + - q-ctrl/pytest_python_36_open + - q-ctrl/open_build + filters: + branches: + only: + - development + tags: + only: /^v?\d+(\.\d+){1,2}rc\d+$/ # RC version required for publish from development + - q-ctrl/pypi_publish: + context: q-ctrl-api-production + requires: + - q-ctrl/pytest_python_36_open + - q-ctrl/open_build + filters: + branches: + only: + - master + tags: + only: /^v?\d+(\.\d+){1,2}$/ diff --git a/.gitignore b/.gitignore index 23e84f85..5fc11071 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Example controls +*.csv + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] @@ -102,6 +105,7 @@ ENV/ # pytest .pytest_cache/* +junit.xml #Mac related files *.DS_Store @@ -112,3 +116,4 @@ qctrl_library.code-workspace # docs docs-source docs + diff --git a/README.md b/README.md index 1dae9d6f..0d7a4176 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,14 @@ # Q-CTRL Open Controls -Q-CTRL Open Controls is an open-source Python package that makes it easy to create and deploy established error-robust quantum control protocols from the open literature. The aim of the package is to be the most comprehensive library of published and tested quantum control techniques developed by the community, with easy to use export functions allowing users to deploy these controls on: +Q-CTRL Open Controls is an open-source Python package that makes it easy to create +and deploy established error-robust quantum control protocols from the open literature. +The aim of the package is to be the most comprehensive library of published and +tested quantum control techniques developed by the community, with easy to use +export functions allowing users to deploy these controls on: -* Custom quantum hardware -* Publicly available cloud quantum computers -* The [Q-CTRL product suite](https://q-ctrl.com/products/) +- Custom quantum hardware +- Publicly available cloud quantum computers +- The [Q-CTRL product suite](https://q-ctrl.com/products/) Anyone interested in quantum control is welcome to contribute to this project. @@ -18,65 +22,108 @@ Anyone interested in quantum control is welcome to contribute to this project. ## Installation -Q-CTRL Open Controls can be install through `pip` or from source. We recommend the `pip` distribution to get the most recent stable release. If you want the latest features then install from source. +Q-CTRL Open Controls can be install through `pip` or from source. We recommend +the `pip` distribution to get the most recent stable release. If you want the +latest features then install from source. ### Requirements -To use Q-CTRL Open Controls you will need an installation of Python. We recommend using the [Anaconda](https://www.anaconda.com/) distribution of Python. Anaconda includes standard numerical and scientific Python packages which are optimally compiled for your machine. Follow the [Anaconda Installation](https://docs.anaconda.com/anaconda/install/) instructions and consult the [Anaconda User guide](https://docs.anaconda.com/anaconda/user-guide/) to get started. +To use Q-CTRL Open Controls you will need an installation of Python. We recommend +using the [Anaconda](https://www.anaconda.com/) distribution of Python. Anaconda +includes standard numerical and scientific Python packages which are optimally +compiled for your machine. Follow the [Anaconda Installation](https://docs.anaconda.com/anaconda/install/) +instructions and consult the [Anaconda User guide](https://docs.anaconda.com/anaconda/user-guide/) +to get started. -We use interactive jupyter notebooks for our usage examples. The Anaconda python distribution comes with editors for these files, or you can [install the jupyter notebook editor](https://jupyter.org/install) on its own. +We use interactive jupyter notebooks for our usage examples. The Anaconda python +distribution comes with editors for these files, or you can [install the jupyter +notebook editor](https://jupyter.org/install) on its own. ### Using PyPi Use `pip` to install the latest version of Q-CTRL Open Controls. ```shell -$ pip install qctrl-open-controls +pip install qctrl-open-controls ``` ### From Source -The source code is hosted on [Github](https://github.com/qctrl/python-open-controls). The repository can be cloned using +The source code is hosted on [Github](https://github.com/qctrl/python-open-controls). +The repository can be cloned using ```shell -$ git clone git@github.com:qctrl/python-open-controls.git +git clone git@github.com:qctrl/python-open-controls.git ``` -Once the clone is complete, you can run the install script. +Once the clone is complete, you have two options: -```shell -$ cd python-open-controls -$ python setup.py develop -``` +1. Using setup.py + + ```shell + cd python-open-controls + python setup.py develop + ``` + + **Note:** We recommend installing using `develop` to point your installation at + the source code in the directory where you cloned the repository. -**Note:** We recommend installing using `develop` to point your installation at the source code in the directory where you cloned the repository. +1. Using Poetry -To test your installation run `pytest` in the `python-open-controls` directory. + ```shell + cd python-open-controls + ./setup-poetry.sh + ``` + + **Note:** if you are on Windows, you'll need to install [Poetry](https://poetry.eustace.io) + manually, and use: + + ```cmd + cd python-open-controls + poetry install + ``` + +Once installed via one of the above methods, test your installation by running `pytest` +in the `python-open-controls` directory. ```shell -$ pytest +pytest ``` ## Usage -Usage depends on the application. We've provided a set of [example Jupyter notebooks](examples) addressing a variety of quantum control problems. Below is a short description of each notebook grouped by application. For further details on usage, use the inline documentation in the source code. +Usage depends on the application. We've provided a set of [example Jupyter notebooks](examples) +addressing a variety of quantum control problems. Below is a short description +of each notebook grouped by application. For further details on usage, use the +inline documentation in the source code. ### Dynamical Decoupling Sequences (DDS) -Q-CTRL Open Controls can create a large library of standard DDS which can be exported in a variety of formats. +Q-CTRL Open Controls can create a large library of standard DDS which can be exported +in a variety of formats. #### Create a DDS -[`examples/creating_a_dds.ipynb`](examples/creating_a_dds.ipynb) demonstrates how to use Q-CTRL Open Controls to create a DDS from a large library of published dynamical decoupling protocols. It also shows how to make Custom DDS with timings, offsets and unitaries defined by the user. The notebook shows how to export a DDS for deployment in the [Q-CTRL products](https://q-ctrl.com/products/) or your quantum hardware. +[`examples/creating_a_dds.ipynb`](examples/creating_a_dds.ipynb) demonstrates +how to use Q-CTRL Open Controls to create a DDS from a large library of published +dynamical decoupling protocols. It also shows how to make Custom DDS with timings, +offsets and unitaries defined by the user. The notebook shows how to export a +DDS for deployment in the [Q-CTRL products](https://q-ctrl.com/products/) or your +quantum hardware. #### Export a DDS to Qiskit -[`examples/export_a_dds_to_qiskit.ipynb`](examples/export_a_dds_to_qiskit.ipynb) demonstrates how to take a DDS and convert it to a Qiskit circuit so it can be run on IBM's quantum computers. It also demonstrates using a DDS to improve the performance of a quantum circuit execution by extending the coherence time of a qubit. +[`examples/export_a_dds_to_qiskit.ipynb`](examples/export_a_dds_to_qiskit.ipynb) +demonstrates how to take a DDS and convert it to a Qiskit circuit so it can be +run on IBM's quantum computers. It also demonstrates using a DDS to improve the +performance of a quantum circuit execution by extending the coherence time of +a qubit. #### Export a DDS to Cirq -[`examples/export_a_dds_to_cirq.ipynb`](examples/export_a_dds_to_cirq.ipynb) demonstrates how to take a DDS and convert it to a Cirq circuit or schdule. It also shows how to run a circuit or schedule in a Cirq simulator. - +[`examples/export_a_dds_to_cirq.ipynb`](examples/export_a_dds_to_cirq.ipynb) demonstrates +how to take a DDS and convert it to a Cirq circuit or schdule. It also shows how +to run a circuit or schedule in a Cirq simulator. ## Contributing diff --git a/README.rst b/README.rst new file mode 100644 index 00000000..aa60e1a0 --- /dev/null +++ b/README.rst @@ -0,0 +1,158 @@ + +Q-CTRL Open Controls +==================== + +Q-CTRL Open Controls is an open-source Python package that makes it easy to create +and deploy established error-robust quantum control protocols from the open literature. +The aim of the package is to be the most comprehensive library of published and +tested quantum control techniques developed by the community, with easy to use +export functions allowing users to deploy these controls on: + + +* Custom quantum hardware +* Publicly available cloud quantum computers +* The `Q-CTRL product suite `_ + +Anyone interested in quantum control is welcome to contribute to this project. + +Table of Contents +----------------- + + +* `Installation <#installation>`_ +* `Usage <#usage>`_ +* `Contributing <#contributing>`_ +* `Credits <#credits>`_ +* `License <#license>`_ + +Installation +------------ + +Q-CTRL Open Controls can be install through ``pip`` or from source. We recommend +the ``pip`` distribution to get the most recent stable release. If you want the +latest features then install from source. + +Requirements +^^^^^^^^^^^^ + +To use Q-CTRL Open Controls you will need an installation of Python. We recommend +using the `Anaconda `_ distribution of Python. Anaconda +includes standard numerical and scientific Python packages which are optimally +compiled for your machine. Follow the `Anaconda Installation `_ +instructions and consult the `Anaconda User guide `_ +to get started. + +We use interactive jupyter notebooks for our usage examples. The Anaconda python +distribution comes with editors for these files, or you can `install the jupyter +notebook editor `_ on its own. + +Using PyPi +^^^^^^^^^^ + +Use ``pip`` to install the latest version of Q-CTRL Open Controls. + +.. code-block:: shell + + pip install qctrl-open-controls + +From Source +^^^^^^^^^^^ + +The source code is hosted on `Github `_. +The repository can be cloned using + +.. code-block:: shell + + git clone git@github.com:qctrl/python-open-controls.git + +Once the clone is complete, you have two options: + + +#. + Using setup.py + + .. code-block:: shell + + cd python-open-controls + python setup.py develop + + **Note:** We recommend installing using ``develop`` to point your installation at + the source code in the directory where you cloned the repository. + +#. + Using Poetry + + .. code-block:: shell + + cd python-open-controls + ./setup-poetry.sh + + **Note:** if you are on Windows, you'll need to install `Poetry `_ + manually, and use: + + .. code-block:: cmd + + cd python-open-controls + poetry install + +Once installed via one of the above methods, test your installation by running ``pytest`` +in the ``python-open-controls`` directory. + +.. code-block:: shell + + pytest + +Usage +----- + +Usage depends on the application. We've provided a set of `example Jupyter notebooks `_ +addressing a variety of quantum control problems. Below is a short description +of each notebook grouped by application. For further details on usage, use the +inline documentation in the source code. + +Dynamical Decoupling Sequences (DDS) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Q-CTRL Open Controls can create a large library of standard DDS which can be exported +in a variety of formats. + +Create a DDS +~~~~~~~~~~~~ + +`\ ``examples/creating_a_dds.ipynb`` `_ demonstrates +how to use Q-CTRL Open Controls to create a DDS from a large library of published +dynamical decoupling protocols. It also shows how to make Custom DDS with timings, +offsets and unitaries defined by the user. The notebook shows how to export a +DDS for deployment in the `Q-CTRL products `_ or your +quantum hardware. + +Export a DDS to Qiskit +~~~~~~~~~~~~~~~~~~~~~~ + +`\ ``examples/export_a_dds_to_qiskit.ipynb`` `_ +demonstrates how to take a DDS and convert it to a Qiskit circuit so it can be +run on IBM's quantum computers. It also demonstrates using a DDS to improve the +performance of a quantum circuit execution by extending the coherence time of +a qubit. + +Export a DDS to Cirq +~~~~~~~~~~~~~~~~~~~~ + +`\ ``examples/export_a_dds_to_cirq.ipynb`` `_ demonstrates +how to take a DDS and convert it to a Cirq circuit or schdule. It also shows how +to run a circuit or schedule in a Cirq simulator. + +Contributing +------------ + +See `Contributing `_. + +Credits +------- + +See `Contributors `_. + +License +------- + +See `LICENSE `_. 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_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 -} 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": "iVBORw0KGgoAAAANSUhEUgAAAdAAAAE1CAYAAABX1LExAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzt3X98XnV99/HXh7YBim1pSlYSuraUdiG0rARqFRQoMCb4gyHyoDoUGVNuFJ2Iij/ujVvmrLdVFG4RmWx7AOLNjWgdstGJUBQFptiWrL/MCrFlJaGEUkulpYHyuf+4rnYhpG1ySK6kzev5eFyPXud7vudcn5OL8M759T2RmUiSpN7Zb6ALkCRpb2SASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFTB8oAsYSOPGjcuJEycOdBmSpEHk0UcffSYza/bUb0gH6MSJE1m0aNFAlyFJGkSqq6vX9qSfh3AlSSrAAJUkqQADVJKkAgxQSZIKMEAlSSrAAJUkqQADVJKkAgxQSZIKMEAlSSrAAJUkqQADVJKkAgxQSZIKMEAlSSqgogEaESdFxI8i4smIyIi4sAfLHB0RP4uIreXlroyI6NLnXRGxMiK2lf99Z79thCRJVH4P9HXAcuBjwNY9dY6I0cBPgPXA68vLfQq4vFOf44Hbge8Cx5T/vSMi3tDXxUuStENFnweamXcDdwNExE09WOR8YCTw/szcCiyPiCOByyPia5mZwGXA/Zn5xfIyX4yIU8rt7+nrbZAkCQb/OdDjgZ+Xw3OHHwN1wOROfe7pstyPgRP6vTpJ0pBV0T3QAg4F1nVpW99p3m/L/67vps+h3a0wIi4GLgaora1lyZIlANTV1TFy5Egee+wxAMaMGcOUKVNYunQpAMOGDWPmzJk0Nzfz/PPPA9DQ0MCzzz7L+vWlj58wYQJVVVW0tLQAMHbsWCZOnEhTUxMAI0aM4Oijj2bVqlVs3Vr6m+Coo46ivb2d9vZ2ACZNmkREsGbNGgDGjRtHbW0ty5cvB2D//fdn+vTprFixgm3btgEwY8YM2tra2LBhAwCTJ08mM1m7tvRQ9ZqaGmpqali5ciUABx54IA0NDSxbtowXX3wRgJkzZ/LEE0+wceNGAKZMmUJHRwfr1pV+/OPHj6e6uppVq1YBcNBBB1FfX09TUxPbt28HoLGxkZaWFjZt2gTA1KlT2bJlC62trez4eY8ePZrm5mYARo0axbRp01i6dCmZSUTQ2NjI6tWr2bx5MwD19fU899xztLW1+T35Pfk9+T1V5HvqqSgdBa28iPg98JHMvGk3fe4B1mXmRZ3aJgJrgRMy8+GI6AA+kJm3dOpzAXBjZu6/uxoaGxtz0aJFr3FLJEn7kurq6sWZOWtP/Qb7IdyngPFd2sZ3mre7Pk8hSVI/GewB+jBwYkQc0KntdKAVWNOpz+ldljsdeKjfq5MkDVmVvg/0dRFxTEQcU/7sieXpieX5X4qI+zot8n+BLcBNETEjIs4BPgPsuAIX4Frg1Ij4TEQcGRGfBU4BrqnYhkmShpxK74HOApaWXwcCV5Xf/215fi1wxI7OmbmJ0t5kHfBr4JvA1cDXOvV5CHg3cCHwH8AFwNzM/GX/bookaSiraIBm5k8zM7p5XVief2FmTu6yzLLMPCkzD8jM2sy8Krtc+ZSZ38/MIzOzKjMbMnNB5bZKkirj3nvvZfbs2Rx33HFcc82rD7KtW7eOs846i5NPPpk3v/nN/OQnPwGgo6ODSy+9lDe96U2ceOKJ/OIXv9i5TEdHB5dddhmvf/3recMb3sCPfvSjim3P3m6w38YiSQK2b9/OFVdcwYIFC6irq+O0007jjDPO4Mgjj9zZ56tf/Spnn302F110Eb/5zW+YO3cuTU1N3HJL6SaFBx98kPb2ds477zzuu+8+9ttvP66++mpqamp45JFHePnll3fe0qE9G+wXEUmSgMWLF3P44YczefJkqqqqOOecc1i4cOEr+kTEzns+n3vuOQ49tHQ7fHNzMyeddBJQuj9yzJgxO+/1/O53v8tll10GwH777ce4ceMqtUl7PQNUkvYCbW1tHHbYYTun6+rqdg6IsMOnP/1pvve97zF9+nTmzp3Ll7/8ZQCmT5/OwoULeemll1i7di2PPvooTz755M5BGubNm8ecOXO48MILefrppyu3UXs5A1SS9hE/+MEPeM973sOKFSu4/fbbueSSS3j55Zd573vfS11dHaeeeiqf+9znmD17NsOGDeOll16itbWV2bNn89Of/pTXv/71XHnllQO9GXsNz4FK0l6gtraWJ598cud0a2srtbW1r+hz6623cscddwAwe/Zstm3bxoYNG6ipqWHevHk7+73lLW/hiCOOoLq6mpEjR/KOd7wDgD/7sz/j1ltvrcDW7BvcA5WkvcCxxx5LS0sLa9eupaOjgwULFnDGGWe8os+ECRN44IEHgNJ5z23btnHIIYewZcuWnWPZ3n///QwfPpwjjzySiOAtb3nLzqtyH3jgAerr6yu7YXsx90AlaS8wfPhw5s+fz7nnnsv27ds5//zzaWhoYN68eTQ2NnLmmWfyhS98gcsuu4xvfetbRATXXXcdEcEzzzzDueeeS0RQV1fHDTfcsHO9n//857nkkkv43Oc+xyGHHMJ11103gFu5dxmwweQHAweTlyR1ta8MJi9J0qBkgEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQ4mL2nIueLmsQNdgvrB/PdvrOjnuQcqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUQMUDNCI+HBG/jYgXImJxRJy4m743RUR283q+U585u+hzZGW2SJI0FFU0QCNiLnAtMA9oBB4CFkbExF0s8jGgtsurBfheN32nd+m3uk+LlySpk0rvgV4O3JSZN2bmqsz8KNAGfKi7zpm5KTOf2vECjgCmADd20/3pzn0zc3u/bYUkacirWIBGRBVwHHBPl1n3ACf0cDUfBFZk5kPdzPt1RLRFxH0RccprKFWSpD0aXsHPOgQYBqzv0r4e+JM9LRwRY4DzgM92mbVjD/YRoAp4H3BfRJycmT/vZj0XAxcD1NbWsmTJEgDq6uoYOXIkjz32GABjxoxhypQpLF26FIBhw4Yxc+ZMmpubef750inYhoYGnn32WdavL23ShAkTqKqqoqWlBYCxY8cyceJEmpqaABgxYgRHH300q1atYuvWrQAcddRRtLe3097eDsCkSZOICNasWQPAuHHjqK2tZfny5QDsv//+TJ8+nRUrVrBt2zYAZsyYQVtbGxs2bABg8uTJZCZr164FoKamhpqaGlauXAnAgQceSENDA8uWLePFF18EYObMmTzxxBNs3LgRgClTptDR0cG6desAGD9+PNXV1axatQqAgw46iPr6epqamti+vbSz39jYSEtLC5s2bQJg6tSpbNmyhdbWVnb8vEePHk1zczMAo0aNYtq0aSxdupTMJCJobGxk9erVbN68GYD6+nqee+452tra/J78nvrse9K+acOGDX3y+9RTkZl9vAm7+KCIOuBJ4OTMfKBT+5XA+ZlZv4flLwWuBuoy89k99L0beCkzz9pdv8bGxly0aFFPN0HSPuKKm8cOdAnqB/Pfv7FP1lNdXb04M2ftqV8lz4E+A2wHxndpHw881YPlPwj8YE/hWfZLYFrvypMkqecqFqCZ2QEsBk7vMut0Slfj7lJEzAZm0v3FQ905htKhXUmS+kUlz4ECfA34TkT8CngQuASoA24AiIhbADLzgi7LXQyszsyfdl1hRFwGrAFWUDoH+l7gbOBd/bIFkiRR4QDNzNsjYhzw15Tu1VwOvDUz15a7vOp+0IgYBbwb+NtdrLYK+AowAdhKKUjflpl393H5kiTtVOk9UDLzeuD6Xcyb003bZuB1u1nffGB+X9UnSVJPOBauJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAb0K0Ig4LyL+tNP0lRGxLiJ+HBE+I0iSNGT0dg/08zveRMSxwOeA/wOMoPSoMUmShoTeDuU3CWguv38n8M+ZOT8i7gF+3KeVSZI0iPV2D/QFYFT5/WnAveX3mzq1S5K0z+vtHujPgasj4hfALODccvsfAf/Vl4VJkjSY9XYP9CNAB6XgvCQzW8vtZ+IhXEnSENKrPdDMXAe8o5v2y/qsIkmS9gK9vg80Ig6IiHMj4tMRcXC57YiIqO778iRJGpx6tQcaEVMpXTj0OuBg4A7gd8CHytMf6OsCJUkajHq7B3oNcA8wHtjaqf1HwCl9VZQkSYNdb6/CPQF4Y2Zuj4jO7U8AdX1WlSRJg1yRsXBHdNM2kdK9oJIkDQm9DdB7gMs7TWdEjAauAv61z6qSJGmQ6+0h3MuB+yOiGTgAuB2YCqwHzuvj2iRJGrR6ex9oa0QcA7wHOJbSHuy3ge9m5tbdLixJ0j6kt3uglIPyn8ovSZKGpD0GaEScA9yVmS+W3+9SZi7os8okSRrEerIH+n3gUODp8vtdSWBYXxQlSdJgt8cAzcz9unsvSdJQ1qtAjIiTIuJVoRsRwyLipL4rS5Kkwa23e5T3A90NGn9weZ4kSUNCbwM0KJ3r7Goc8PxrL0eSpL1Dj25jiYgfld8mcGtEbOs0exgwA3ioj2uTJGnQ6ul9oBvK/wawkVc+iaUD+AVwYx/WJUnSoNajAM3MvwCIiDXAVzPTw7WSpCGtt0P5XdVfhUiStDfpyUhE/wGcnJkbI2IZ3V9EBEBm/nFfFidJ0mDVkz3QHwA7Lhra3UhEkiQNGT0Zieiq7t5LkjSUOTSfJEkF9OQc6G7Pe3bmOVBJ0lDR06exSJKkTnp1DlSSJJV4DlSSpAK8D1SSpAK8D1SSpAK8D1SSpAJ6NRbuDhFxBNBQnlyVmY/3XUmSJA1+vQrQiBgH/CNwFvDyfzfHvwAXZeaGXS4sSdI+pLdX4f4DMBU4ETig/DoJOByfBypJGkJ6ewj3LcBpmflwp7YHI+J/APf2XVmSJA1uvd0DbQe6e5j2FsDDt5KkIaO3Afq3wDURcdiOhvL7q8vzJEkaEooMJn84sCYinixPHwa8APwBpXOkkiTt8xxMXpKkAio+mHxEfBj4FFALrAAuy8yf76LvHOD+bmY1ZOZvOvV7F/AF4AjgceB/ZuYP+7JuSZI6q+hg8hExF7gWmAc0Ag8BCyNi4h4WnU4pcHe8Vnda5/HA7cB3gWPK/94REW/o8w2QJKmsVwEaEVURcVVE/GdEvBAR2zu/erCKy4GbMvPGzFyVmR8F2oAP7WG5pzPzqU6vzp91GXB/Zn6xvM4vAj8tt0uS1C96ex/oF4C5wJeAr1M6FDsZeDfwN7tbMCKqgOOAr3aZdQ9wwh4+99cRsT+wEvi7zOx8WPd44Btd+v8Y+Mgu6rgYuBigtraWJUuWAFBXV8fIkSN57LHHABgzZgxTpkxh6dKlAAwbNoyZM2fS3NzM88+X7uRpaGjg2WefZf369QBMmDCBqqoqWlpaABg7diwTJ06kqakJgBEjRnD00UezatUqtm7dCsBRRx1Fe3s77e3tAEyaNImIYM2aNQCMGzeO2tpali9fDsD+++/P9OnTWbFiBdu2lcb4nzFjBm1tbWzYULqTaPLkyWQma9euBaCmpoaamhpWrlwJwIEHHkhDQwPLli3jxRdfBGDmzJk88cQTbNy4EYApU6bQ0dHBunXrABg/fjzV1dWsWrUKgIMOOoj6+nqamprYvr3090xjYyMtLS1s2rQJgKlTp7JlyxZaW1vZ8fMePXo0zc3NAIwaNYpp06axdOlSMpOIoLGxkdWrV7N582YA6uvree6552hra/N78nvqs+9J+6YNGzb0ye9TT0XmLp9O9urOEb8FPpSZ/xYRm4FjMvPxiPgQpQEWzt3NsnXAk5QejfZAp/YrgfMzs76bZeqBU4BHgCrgfcAl5XX8vNynA/hAZt7SabkLgBszc//dbU9jY2MuWrSop5svaR9xxc1jB7oE9YP579/YJ+uprq5enJmz9tSvt3ug4yntBQL8Hji4/P7fgC/3cl17lJnNQHOnpocjYjKlPd9uLzySJKkSensR0RNAXfn9Y5SG9oPSYdSte1j2GWA7pRDubDzwVC9q+CUwrdP0U32wTkmSeqW3AfpD4LTy+2uBq8qHdW9iD4MoZGYHsBg4vcus0yldjdtTx1C68GiHh/tgnZIk9UqvDuFm5mc7vf9+RKyjdAHQf2bmv/RgFV8DvhMRvwIepHQ+sw64ASAibimv+4Ly9GXAGkr3i1YB7wXOBt7VaZ3XAg9ExGeAfwbeSem86Zt7s22SJPVGoQdq75CZ/w78ey/6315+puhfU7qfcznw1sxcW+7S9X7QKuArwARKh4hXAG/LzLs7rfOhiHg38HeUxuN9HJibmb8stlWSJO1ZrwM0Io6ldI/lUeWmVcDXM3NJT5bPzOuB63cxb06X6fnA/B6s8/s45KAkqYJ6O5DC+ZRuKakF7i6/xgO/ioj39n15kiQNTr3dA/0i8DeZOa9zY0R8ltIh1Fv7qjBJkgaz3l6FWwN8r5v2Oyg9zkySpCGhtwF6PzCnm/Y5wM9eazGSJO0tevJA7XM6TS4EvhQRs/jvq2/fCJwDfL7Pq5MkaZAq+kDtnQOyd/INdnF1rSRJ+5qePFC7os8MlSRpb2A4SpJUQK8DNCLeFhEPRMQzEdEeET+LiLf2R3GSJA1WvR1I4QOUBpR/HPg08Bngt8API+Kivi9PkqTBqbcDKXwauDwzr+vU9o8RsZhSmP5Tn1UmSdIg1ttDuBMpPTy7q4XApNdejiRJe4ciD9Tu+uxNgD8F1nbTLknSPqm3h3C/Cnyj/ESWHQ+sfhPwPuCjfVmYJEmDWW8fqP33EfE08AlKow9B6XFm52XmnX1dnCRJg1WPAzQihlM6VPtAZv6w/0qSJGnw6/E50Mx8CVgAjOq/ciRJ2jv09iKiJmBqfxQiSdLepLcB+nng6og4OyL+MCKqO7/6oT5Jkgal3l6F+6/lfxcA2ak9ytPD+qIoSZIGu94G6Cn9UoUkSXuZHgVoRIwEvgKcDYwA7gX+KjOf6cfaJEkatHp6DvQq4EJKh3BvozQa0bf6qSZJkga9nh7CPQf4y8z8fwAR8V3gwYgYlpnb+606SZIGqZ7ugf4h8PMdE5n5K+AloK4/ipIkabDraYAOAzq6tL1E7y9CkiRpn9DTAAzg1ojY1qntAODGiNiyoyEzz+rL4iRJGqx6GqA3d9N2a18WIknS3qRHAZqZf9HfhUiStDfp7VB+kiQJA1SSpEIMUEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCqh4gEbEhyPitxHxQkQsjogTd9P3nIi4JyLaI2JzRPwyIs7q0ufCiMhuXgf0/9ZIkoaqigZoRMwFrgXmAY3AQ8DCiJi4i0VOBhYBbyv3vxv4YTehuwWo7fzKzBf6fgskSSoZXuHPuxy4KTNvLE9/NCLOAD4EfLZr58z8WJemqyLibcDZwM9f2TWf6o+CJUnqTsUCNCKqgOOAr3aZdQ9wQi9WNQrY2KXtwIhYCwwDHgX+JjOX7qKOi4GLAWpra1myZAkAdXV1jBw5ksceewyAMWPGMGXKFJYuLa1m2LBhzJw5k+bmZp5//nkAGhoaePbZZ1m/fj0AEyZMoKqqipaWFgDGjh3LxIkTaWpqAmDEiBEcffTRrFq1iq1btwJw1FFH0d7eTnt7OwCTJk0iIlizZg0A48aNo7a2luXLlwOw//77M336dFasWMG2bdsAmDFjBm1tbWzYsAGAyZMnk5msXbsWgJqaGmpqali5cmXph3XggTQ0NLBs2TJefPFFAGbOnMkTTzzBxo2lH+2UKVPo6Ohg3bp1AIwfP57q6mpWrVoFwEEHHUR9fT1NTU1s374dgMbGRlpaWti0aRMAU6dOZcuWLbS2trLj5z169Giam5tLX+SoUUybNo2lS5eSmUQEjY2NrF69ms2bNwNQX1/Pc889R1tbm9+T31OffU/aN23YsKFPfp96KjKzjzdhFx8UUQc8CZycmQ90ar8SOD8z63uwjkuB/w3MyMy15bbjgT8CmiiF68eAtwIzM3P17tbX2NiYixYtKrhFkvZWV9w8dqBLUD+Y//6u+1bFVFdXL87MWXvqV+lDuIVFxLuArwBzd4QnQGY+DDzcqd9DlPZCPwr8VaXrlCQNDZW8iOgZYDswvkv7eGC35y8j4lzgO8AFmXnX7vpm5nbg18C04qVKkrR7FQvQzOwAFgOnd5l1OqWrcbsVEedRCs8LM/P7e/qciAjgj4G24tVKkrR7lT6E+zXgOxHxK+BB4BKgDrgBICJuAcjMC8rT76YUnp8EHoiIQ8vr6cjMZ8t9/hfw78BqYDSlw7Z/TOnKXkmS+kVFAzQzb4+IccBfU7pfcznw1k7nNLveD3oJpRqvKb92+Bkwp/z+YODbwKHAJmApcFJm/qo/tkGSJBiAi4gy83rg+l3Mm7O76V0s83Hg431RmyRJPeVYuJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBqgkSQUYoJIkFWCASpJUgAEqSVIBBugQd++99zJ79myOO+44rrnmmlfNf+ihh5gzZw41NTXceeedr5h32223MWvWLGbNmsVtt932qmX//M//nBNOOKHfapekgTR8oAvQwNm+fTtXXHEFCxYsoK6ujtNOO40zzjiDI488cmefCRMm8M1vfpPrrrvuFctu3LiR+fPns2jRIiKCU045hTPPPJODDz4YgLvuuouDDjqootsjSZXkHugQtnjxYg4//HAmT55MVVUV55xzDgsXLnxFn4kTJzJ9+nT22++V/6ksWrSIOXPmMHbsWA4++GDmzJnDfffdB8Dvf/97rr/+ej7xiU9UbFskqdIM0CGsra2Nww47bOd0XV0dbW1tPVq2tbX1Vcu2trYCMG/ePC699FJGjhzZtwVL0iBigKpPLVu2jDVr1vD2t799oEuRpH5lgA5htbW1PPnkkzunW1tbqa2t7dGydXV1r1q2rq6ORx55hEcffZSZM2dy5pln8vjjj/OOd7yjz2uXpIFmgA5hxx57LC0tLaxdu5aOjg4WLFjAGWec0aNlTz31VO6//35+97vf8bvf/Y7777+fU089lYsuuoiVK1fS1NTEwoULOeKII7jrrrv6eUskqfIM0CFs+PDhzJ8/n3PPPZc3vvGNnH322TQ0NDBv3rydFxMtWbKE6dOnc+edd3L55Zdz/PHHAzB27Fg++clPctppp3HaaafxqU99irFjxw7k5khSRUVmDnQNA6axsTEXLVo00GVIqrArbvaPvX3R/Pdv7JP1VFdXL87MWXvq5x6oJEkFOJBCH/Cv2X1TX/01K2nf5B6oJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVggEqSVIABKklSAQaoJEkFGKCSJBVQ8QCNiA9HxG8j4oWIWBwRJ+6h/8nlfi9EREtEXPJa1ylJ0mtV0QCNiLnAtcA8oBF4CFgYERN30f9w4O5yv0bgS8A3IuJdRdcpSVJfqPQe6OXATZl5Y2auysyPAm3Ah3bR/xKgNTM/Wu5/I3Az8MnXsE5Jkl6zigVoRFQBxwH3dJl1D3DCLhY7vpv+PwZmRcSIguuUJOk1G17BzzoEGAas79K+HviTXSxzKHBvN/2Hl9cXvV1nRFwMXFye/H11dXVzT4rXTocAzwx0EZXwDx8f6AqkPuHvbO9N6kmnSgbooJCZ3wa+PdB17K0i4teZOWug65DUM/7O9p9KBugzwHZgfJf28cBTu1jmqV30f6m8viiwTkmSXrOKnQPNzA5gMXB6l1mnU7pytjsP76L/rzPzxYLrlCTpNav0IdyvAd+JiF8BD1K6yrYOuAEgIm4ByMwLyv1vAD4SEdcAfw+8CbgQeE9P16k+5+Fvae/i72w/icys7AdGfBi4AqgFlgMfz8wHyvN+CpCZczr1Pxn4OjAdaAW+nJk39HSdkiT1h4oHqCRJ+wLHwpUkqQADVJKkAgxQ7VFETIuIrrcKSdKQ5jlQdSsi/gB4H/BxoJ3SvbdtwPeBH2Tm8wNYniQNOANU3YqIm4CjgH8BNgDjgGOABmAdMD8zfzJgBUrSADNA9SoREcBm4K2dbjEKYALwRuCDlMaKnJuZjw5YoZJeISJGA5vT/7FXhOdA1Z2jgN8CHTsasuS/MvMO4O2UAnbuANUnqXtfAS6KiKPLYfoqETGuwjXtswxQdacFeBr4evkColf8d1IeQvFm4MyBKE7Sq0XEeygdHboauBP4SkS8MyKOiIgDy30OBP4xIo4ewFL3GR7CVbci4o2UhkPcSmkYxfuAjZn5+4gYCdwCvJCZ7x3AMiWVRcSNlB6uMR84B3g/cATQDNxN6Xe4Hrg2M6sGqs59iQGqXYqIGcDfAGcBz1Ma3L+d0rNW24APZOaygatQEkBEDKc0nOnozPxMp/bplPZKzwUOAA4Gbs7MvxyQQvcxBqj2qHxLy9uAs4EXKI03fEdm/mZAC5O0U0SMBcZn5m8iogp4sfPFRBExF7gNONaL//qGAapeiYj9MvPlga5D0p6Vr1+IzNweER+kdPh25EDXta+o9OPMtJczPKW9R5ff11HA/xql1mGbAAAAOElEQVSoWvZF7oFK0hAQESOA7f4R3HcMUEmSCvA+UEmSCjBAJUkqwACVJKkAA1SSpAIMUEmSCvj/YHPRHDVyBeoAAAAASUVORK5CYII=\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 diff --git a/matplotlibrc b/matplotlibrc new file mode 100644 index 00000000..ee3279e2 --- /dev/null +++ b/matplotlibrc @@ -0,0 +1 @@ +backend: agg \ No newline at end of file diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 00000000..d6493097 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,999 @@ +[[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" +name = "asn1crypto" +optional = false +python-versions = "*" +version = "0.24.0" + +[[package]] +category = "dev" +description = "An abstract syntax tree for Python with inference support." +name = "astroid" +optional = false +python-versions = ">=3.4.*" +version = "2.2.5" + +[package.dependencies] +lazy-object-proxy = "*" +six = "*" +typed-ast = ">=1.3.0" +wrapt = "*" + +[[package]] +category = "dev" +description = "Atomic file writes." +name = "atomicwrites" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "1.3.0" + +[[package]] +category = "dev" +description = "Classes Without Boilerplate" +name = "attrs" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "19.1.0" + +[package.extras] +dev = ["coverage", "hypothesis", "pympler", "pytest", "six", "zope.interface", "sphinx", "pre-commit"] +docs = ["sphinx", "zope.interface"] +tests = ["coverage", "hypothesis", "pympler", "pytest", "six", "zope.interface"] + +[[package]] +category = "main" +description = "Extensible memoizing collections and decorators" +name = "cachetools" +optional = false +python-versions = "*" +version = "3.1.1" + +[[package]] +category = "main" +description = "Python package for providing Mozilla's CA Bundle." +name = "certifi" +optional = false +python-versions = "*" +version = "2019.3.9" + +[[package]] +category = "main" +description = "Foreign Function Interface for Python calling C code." +name = "cffi" +optional = false +python-versions = "*" +version = "1.12.3" + +[package.dependencies] +pycparser = "*" + +[[package]] +category = "main" +description = "Universal encoding detector for Python 2 and 3" +name = "chardet" +optional = false +python-versions = "*" +version = "3.0.4" + +[[package]] +category = "main" +description = "A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits." +name = "cirq" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*, !=3.5.0, !=3.5.1" +version = "0.5.0" + +[package.dependencies] +enum34 = "*" +google-api-python-client = ">=1.6,<2.0" +matplotlib = ">=2.1,<3.0" +networkx = ">=2.1,<3.0" +numpy = ">=1.12,<2.0" +protobuf = ">=3.5,<4.0" +scipy = ">=1.1,<2.0" +sortedcontainers = ">=1.5,<2.0" +sympy = "*" +typing = ">=3.6,<4.0" +typing-extensions = "*" + +[[package]] +category = "dev" +description = "Cross-platform colored terminal text." +name = "colorama" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "0.4.1" + +[[package]] +category = "main" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +name = "cryptography" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "2.7" + +[package.dependencies] +asn1crypto = ">=0.21.0" +cffi = ">=1.8,<1.11.3 || >1.11.3" +six = ">=1.4.1" + +[package.extras] +docs = ["sphinx (>=1.6.5,<1.8.0 || >1.8.0)", "sphinx-rtd-theme"] +docstest = ["doc8", "pyenchant (>=1.6.11)", "twine (>=1.12.0)", "sphinxcontrib-spelling (>=4.0.1)"] +idna = ["idna (>=2.1)"] +pep8test = ["flake8", "flake8-import-order", "pep8-naming"] +test = ["pytest (>=3.6.0,<3.9.0 || >3.9.0,<3.9.1 || >3.9.1,<3.9.2 || >3.9.2)", "pretend", "iso8601", "pytz", "hypothesis (>=1.11.4,<3.79.2 || >3.79.2)"] + +[[package]] +category = "main" +description = "Composable style cycles" +name = "cycler" +optional = false +python-versions = "*" +version = "0.10.0" + +[package.dependencies] +six = "*" + +[[package]] +category = "main" +description = "Better living through Python with decorators" +name = "decorator" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*" +version = "4.4.0" + +[[package]] +category = "main" +description = "Python 3.4 Enum backported to 3.3, 3.2, 3.1, 2.7, 2.6, 2.5, and 2.4" +name = "enum34" +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" +name = "google-api-python-client" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "1.7.9" + +[package.dependencies] +google-auth = ">=1.4.1" +google-auth-httplib2 = ">=0.0.3" +httplib2 = ">=0.9.2,<1dev" +six = ">=1.6.1,<2dev" +uritemplate = ">=3.0.0,<4dev" + +[[package]] +category = "main" +description = "Google Authentication Library" +name = "google-auth" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "1.6.3" + +[package.dependencies] +cachetools = ">=2.0.0" +pyasn1-modules = ">=0.2.1" +rsa = ">=3.1.4" +six = ">=1.9.0" + +[[package]] +category = "main" +description = "Google Authentication Library: httplib2 transport" +name = "google-auth-httplib2" +optional = false +python-versions = "*" +version = "0.0.3" + +[package.dependencies] +google-auth = "*" +httplib2 = ">=0.9.1" + +[[package]] +category = "main" +description = "A comprehensive HTTP client library." +name = "httplib2" +optional = false +python-versions = "*" +version = "0.13.0" + +[[package]] +category = "main" +description = "Internationalized Domain Names in Applications (IDNA)" +name = "idna" +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" +name = "importlib-metadata" +optional = false +python-versions = ">=2.7,!=3.0,!=3.1,!=3.2,!=3.3" +version = "0.18" + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +docs = ["sphinx", "docutils (0.12)", "rst.linker"] + +[[package]] +category = "dev" +description = "A Python utility / library to sort Python imports." +name = "isort" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "4.3.20" + +[package.extras] +pipfile = ["pipreqs", "requirementslib"] +pyproject = ["toml"] +requirements = ["pipreqs", "pip-api"] +xdg_home = ["appdirs (>=1.4.0)"] + +[[package]] +category = "main" +description = "An implementation of JSON Schema validation for Python" +name = "jsonschema" +optional = false +python-versions = "*" +version = "2.6.0" + +[package.extras] +format = ["rfc3987", "strict-rfc3339", "webcolors"] + +[[package]] +category = "main" +description = "A fast implementation of the Cassowary constraint solver" +name = "kiwisolver" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "1.1.0" + +[package.dependencies] +setuptools = "*" + +[[package]] +category = "dev" +description = "A fast and thorough lazy object proxy." +name = "lazy-object-proxy" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "1.4.1" + +[[package]] +category = "main" +description = "A lightweight library for converting complex datatypes to and from native Python datatypes." +name = "marshmallow" +optional = false +python-versions = "*" +version = "2.19.2" + +[package.extras] +dev = ["python-dateutil", "simplejson", "pytest", "pytz", "flake8 (3.7.4)", "tox"] +lint = ["flake8 (3.7.4)"] +reco = ["python-dateutil", "simplejson"] +tests = ["pytest", "pytz"] + +[[package]] +category = "main" +description = "An unofficial extension to Marshmallow to allow for polymorphic fields" +name = "marshmallow-polyfield" +optional = false +python-versions = "*" +version = "3.2" + +[package.dependencies] +marshmallow = ">=2.0.0" + +[[package]] +category = "main" +description = "Python plotting package" +name = "matplotlib" +optional = false +python-versions = "*" +version = "2.2.4" + +[package.dependencies] +cycler = ">=0.10" +kiwisolver = ">=1.0.1" +numpy = ">=1.7.1" +pyparsing = ">=2.0.1,<2.0.4 || >2.0.4,<2.1.2 || >2.1.2,<2.1.6 || >2.1.6" +python-dateutil = ">=2.1" +pytz = "*" +six = ">=1.10" + +[[package]] +category = "dev" +description = "McCabe checker, plugin for flake8" +name = "mccabe" +optional = false +python-versions = "*" +version = "0.6.1" + +[[package]] +category = "dev" +description = "More routines for operating on iterables, beyond itertools" +marker = "python_version > \"2.7\"" +name = "more-itertools" +optional = false +python-versions = ">=3.4" +version = "7.0.0" + +[[package]] +category = "main" +description = "Python library for arbitrary-precision floating-point arithmetic" +name = "mpmath" +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" +name = "networkx" +optional = false +python-versions = ">=3.5" +version = "2.3" + +[package.dependencies] +decorator = ">=4.3.0" + +[package.extras] +all = ["numpy", "scipy", "pandas", "matplotlib", "pygraphviz", "pydot", "pyyaml", "gdal", "lxml", "nose"] +gdal = ["gdal"] +lxml = ["lxml"] +matplotlib = ["matplotlib"] +nose = ["nose"] +numpy = ["numpy"] +pandas = ["pandas"] +pydot = ["pydot"] +pygraphviz = ["pygraphviz"] +pyyaml = ["pyyaml"] +scipy = ["scipy"] + +[[package]] +category = "main" +description = "Creates NTLM authentication structures" +name = "ntlm-auth" +optional = false +python-versions = ">=2.6,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "1.3.0" + +[package.extras] +cryptography = ["cryptography (<2.2)", "cryptography"] + +[[package]] +category = "main" +description = "NumPy is the fundamental package for array computing with Python." +name = "numpy" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "1.16.4" + +[[package]] +category = "dev" +description = "Core utilities for Python packages" +name = "packaging" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "19.0" + +[package.dependencies] +pyparsing = ">=2.0.2" +six = "*" + +[[package]] +category = "main" +description = "Python Imaging Library (Fork)" +name = "pillow" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +version = "6.0.0" + +[[package]] +category = "dev" +description = "plugin and hook calling mechanisms for python" +name = "pluggy" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "0.12.0" + +[package.dependencies] +importlib-metadata = ">=0.12" + +[package.extras] +dev = ["pre-commit", "tox"] + +[[package]] +category = "main" +description = "Python Lex & Yacc" +name = "ply" +optional = false +python-versions = "*" +version = "3.11" + +[[package]] +category = "main" +description = "Protocol Buffers" +name = "protobuf" +optional = false +python-versions = "*" +version = "3.8.0" + +[package.dependencies] +setuptools = "*" +six = ">=1.9" + +[[package]] +category = "main" +description = "Cross-platform lib for process and system monitoring in Python." +name = "psutil" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "5.6.3" + +[package.extras] +enum = ["enum34"] + +[[package]] +category = "dev" +description = "library with cross-python path, ini-parsing, io, code, log facilities" +name = "py" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "1.8.0" + +[[package]] +category = "main" +description = "ASN.1 types and codecs" +name = "pyasn1" +optional = false +python-versions = "*" +version = "0.4.5" + +[[package]] +category = "main" +description = "A collection of ASN.1-based protocols modules." +name = "pyasn1-modules" +optional = false +python-versions = "*" +version = "0.2.5" + +[package.dependencies] +pyasn1 = ">=0.4.1,<0.5.0" + +[[package]] +category = "dev" +description = "Python style guide checker" +name = "pycodestyle" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "2.5.0" + +[[package]] +category = "main" +description = "C parser in Python" +name = "pycparser" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "2.19" + +[[package]] +category = "dev" +description = "Python docstring style checker" +name = "pydocstyle" +optional = false +python-versions = "*" +version = "3.0.0" + +[package.dependencies] +six = "*" +snowballstemmer = "*" + +[[package]] +category = "dev" +description = "passive checker of Python programs" +name = "pyflakes" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "2.1.1" + +[[package]] +category = "dev" +description = "pylama -- Code audit tool for python" +name = "pylama" +optional = false +python-versions = "*" +version = "7.7.1" + +[package.dependencies] +mccabe = ">=0.5.2" +pycodestyle = ">=2.3.1" +pydocstyle = ">=2.0.0" +pyflakes = ">=1.5.0" + +[[package]] +category = "main" +description = "Python library for encoding unicode to latex and for parsing LaTeX to generate unicode text" +name = "pylatexenc" +optional = false +python-versions = "*" +version = "1.5" + +[[package]] +category = "dev" +description = "python code static checker" +name = "pylint" +optional = false +python-versions = ">=3.4.*" +version = "2.3.1" + +[package.dependencies] +astroid = ">=2.2.0,<3" +colorama = "*" +isort = ">=4.2.5,<5" +mccabe = ">=0.6,<0.7" + +[[package]] +category = "dev" +description = "Run pylint recursively on all py files in current and sub directories" +name = "pylint-runner" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" +version = "0.5.4" + +[package.dependencies] +colorama = "*" +pylint = "*" + +[[package]] +category = "main" +description = "Python parsing module" +name = "pyparsing" +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" +name = "pytest" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +version = "4.6.3" + +[package.dependencies] +atomicwrites = ">=1.0" +attrs = ">=17.4.0" +colorama = "*" +importlib-metadata = ">=0.12" +packaging = "*" +pluggy = ">=0.12,<1.0" +py = ">=1.5.0" +six = ">=1.10.0" +wcwidth = "*" + +[package.dependencies.more-itertools] +python = ">=2.8" +version = ">=4.0.0" + +[package.extras] +testing = ["argcomplete", "hypothesis (>=3.56)", "nose", "requests", "mock"] + +[[package]] +category = "main" +description = "Extensions to the standard Python datetime module" +name = "python-dateutil" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +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" +name = "pytz" +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" +name = "qiskit-ibmq-provider" +optional = false +python-versions = ">=3.5" +version = "0.2.2" + +[package.dependencies] +qiskit-terra = ">=0.8" +requests = ">=2.19" +requests-ntlm = ">=1.1.0" +websockets = ">=7,<8" + +[[package]] +category = "main" +description = "Software for developing quantum computing programs" +name = "qiskit-terra" +optional = false +python-versions = ">=3.5" +version = "0.8.1" + +[package.dependencies] +jsonschema = ">=2.6,<2.7" +marshmallow = ">=2.17.0,<3" +marshmallow-polyfield = ">=3.2,<4" +networkx = ">=2.2" +numpy = ">=1.13" +pillow = ">=4.2.1" +ply = ">=3.10" +psutil = ">=5" +pylatexenc = ">=1.4" +scipy = ">=1.0" +sympy = ">=1.3" + +[package.extras] +full-featured-simulators = ["qiskit-aer (>=0.1)"] +visualization = ["matplotlib (>=2.1)", "nxpd (>=0.2)", "ipywidgets (>=7.3.0)", "pydot"] + +[[package]] +category = "main" +description = "Python HTTP for Humans." +name = "requests" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +version = "2.22.0" + +[package.dependencies] +certifi = ">=2017.4.17" +chardet = ">=3.0.2,<3.1.0" +idna = ">=2.5,<2.9" +urllib3 = ">=1.21.1,<1.25.0 || >1.25.0,<1.25.1 || >1.25.1,<1.26" + +[package.extras] +security = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)"] +socks = ["PySocks (>=1.5.6,<1.5.7 || >1.5.7)", "win-inet-pton"] + +[[package]] +category = "main" +description = "This package allows for HTTP NTLM authentication using the requests library." +name = "requests-ntlm" +optional = false +python-versions = "*" +version = "1.1.0" + +[package.dependencies] +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" +name = "rsa" +optional = false +python-versions = "*" +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" +name = "scipy" +optional = false +python-versions = ">=3.5" +version = "1.3.0" + +[package.dependencies] +numpy = ">=1.13.3" + +[[package]] +category = "main" +description = "Python 2 and 3 compatibility utilities" +name = "six" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*" +version = "1.12.0" + +[[package]] +category = "dev" +description = "This package provides 16 stemmer algorithms (15 + Poerter English stemmer) generated from Snowball algorithms." +name = "snowballstemmer" +optional = false +python-versions = "*" +version = "1.2.1" + +[[package]] +category = "main" +description = "Python Sorted Container Types: SortedList, SortedDict, and SortedSet" +name = "sortedcontainers" +optional = false +python-versions = "*" +version = "1.5.10" + +[[package]] +category = "main" +description = "Computer algebra system (CAS) in Python" +name = "sympy" +optional = false +python-versions = "*" +version = "1.4" + +[package.dependencies] +mpmath = ">=0.19" + +[[package]] +category = "dev" +description = "a fork of Python 2 and 3 ast modules with type comment support" +marker = "implementation_name == \"cpython\"" +name = "typed-ast" +optional = false +python-versions = "*" +version = "1.4.0" + +[[package]] +category = "main" +description = "Type Hints for Python" +name = "typing" +optional = false +python-versions = "*" +version = "3.6.6" + +[[package]] +category = "main" +description = "Backported and Experimental Type Hints for Python 3.5+" +name = "typing-extensions" +optional = false +python-versions = "*" +version = "3.7.2" + +[package.dependencies] +typing = ">=3.6.2" + +[[package]] +category = "main" +description = "URI templates" +name = "uritemplate" +optional = false +python-versions = "*" +version = "3.0.0" + +[[package]] +category = "main" +description = "HTTP library with thread-safe connection pooling, file post, and more." +name = "urllib3" +optional = false +python-versions = "*" +version = "1.22" + +[package.extras] +secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"] +socks = ["PySocks (>=1.5.6,<1.5.7 || >1.5.7,<2.0)"] + +[[package]] +category = "dev" +description = "Measures number of Terminal column cells of wide-character codes" +name = "wcwidth" +optional = false +python-versions = "*" +version = "0.1.7" + +[[package]] +category = "main" +description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)" +name = "websockets" +optional = false +python-versions = ">=3.4" +version = "7.0" + +[[package]] +category = "dev" +description = "Module for decorators, wrappers and monkey patching." +name = "wrapt" +optional = false +python-versions = "*" +version = "1.11.1" + +[[package]] +category = "dev" +description = "Backport of pathlib-compatible object wrapper for zip files" +name = "zipp" +optional = false +python-versions = ">=2.7" +version = "0.5.1" + +[package.extras] +docs = ["sphinx", "jaraco.packaging (>=3.2)", "rst.linker (>=1.9)"] +testing = ["pathlib2", "contextlib2", "unittest2"] + +[metadata] +content-hash = "8d9aa4b7bc758be12f7fd3380faa1500f21d8b0295c7a19b283ae38d8dc48b27" +python-versions = ">=3.7.3" + +[metadata.hashes] +antlr4-python3-runtime = ["168cdcec8fb9152e84a87ca6fd261b3d54c8f6358f42ab3b813b14a7193bb50b"] +asn1crypto = ["2f1adbb7546ed199e3c90ef23ec95c5cf3585bac7d11fb7eb562a3fe89c64e87", "9d5c20441baf0cb60a4ac34cc447c6c189024b6b4c6cd7877034f4965c464e49"] +astroid = ["6560e1e1749f68c64a4b5dee4e091fce798d2f0d84ebe638cf0e0585a343acf4", "b65db1bbaac9f9f4d190199bb8680af6f6f84fd3769a5ea883df8a91fe68b4c4"] +atomicwrites = ["03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4", "75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"] +attrs = ["69c0dbf2ed392de1cb5ec704444b08a5ef81680a61cb899dc08127123af36a79", "f0b870f674851ecbfbbbd364d6b5cbdff9dcedbc7f3f5e18a6891057f21fe399"] +cachetools = ["428266a1c0d36dc5aca63a2d7c5942e88c2c898d72139fca0e97fdd2380517ae", "8ea2d3ce97850f31e4a08b0e2b5e6c34997d7216a9d2c98e0f3978630d4da69a"] +certifi = ["59b7658e26ca9c7339e00f8f4636cdfe59d34fa37b9b04f6f9e9926b3cece1a5", "b26104d6835d1f5e49452a26eb2ff87fe7090b89dfcaee5ea2212697e1e1d7ae"] +cffi = ["041c81822e9f84b1d9c401182e174996f0bae9991f33725d059b771744290774", "046ef9a22f5d3eed06334d01b1e836977eeef500d9b78e9ef693f9380ad0b83d", "066bc4c7895c91812eff46f4b1c285220947d4aa46fa0a2651ff85f2afae9c90", "066c7ff148ae33040c01058662d6752fd73fbc8e64787229ea8498c7d7f4041b", "2444d0c61f03dcd26dbf7600cf64354376ee579acad77aef459e34efcb438c63", "300832850b8f7967e278870c5d51e3819b9aad8f0a2c8dbe39ab11f119237f45", "34c77afe85b6b9e967bd8154e3855e847b70ca42043db6ad17f26899a3df1b25", "46de5fa00f7ac09f020729148ff632819649b3e05a007d286242c4882f7b1dc3", "4aa8ee7ba27c472d429b980c51e714a24f47ca296d53f4d7868075b175866f4b", "4d0004eb4351e35ed950c14c11e734182591465a33e960a4ab5e8d4f04d72647", "4e3d3f31a1e202b0f5a35ba3bc4eb41e2fc2b11c1eff38b362de710bcffb5016", "50bec6d35e6b1aaeb17f7c4e2b9374ebf95a8975d57863546fa83e8d31bdb8c4", "55cad9a6df1e2a1d62063f79d0881a414a906a6962bc160ac968cc03ed3efcfb", "5662ad4e4e84f1eaa8efce5da695c5d2e229c563f9d5ce5b0113f71321bcf753", "59b4dc008f98fc6ee2bb4fd7fc786a8d70000d058c2bbe2698275bc53a8d3fa7", "73e1ffefe05e4ccd7bcea61af76f36077b914f92b76f95ccf00b0c1b9186f3f9", "a1f0fd46eba2d71ce1589f7e50a9e2ffaeb739fb2c11e8192aa2b45d5f6cc41f", "a2e85dc204556657661051ff4bab75a84e968669765c8a2cd425918699c3d0e8", "a5457d47dfff24882a21492e5815f891c0ca35fefae8aa742c6c263dac16ef1f", "a8dccd61d52a8dae4a825cdbb7735da530179fea472903eb871a5513b5abbfdc", "ae61af521ed676cf16ae94f30fe202781a38d7178b6b4ab622e4eec8cefaff42", "b012a5edb48288f77a63dba0840c92d0504aa215612da4541b7b42d849bc83a3", "d2c5cfa536227f57f97c92ac30c8109688ace8fa4ac086d19d0af47d134e2909", "d42b5796e20aacc9d15e66befb7a345454eef794fdb0737d1af593447c6c8f45", "dee54f5d30d775f525894d67b1495625dd9322945e7fee00731952e0368ff42d", "e070535507bd6aa07124258171be2ee8dfc19119c28ca94c9dfb7efd23564512", "e1ff2748c84d97b065cc95429814cdba39bcbd77c9c85c89344b317dc0d9cbff", "ed851c75d1e0e043cbf5ca9a8e1b13c4c90f3fbd863dacb01c0808e2b5204201"] +chardet = ["84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae", "fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"] +cirq = ["2b0d366285bdafd9f6713a67a327aab97628683448d73c13c5c09fc35043f088", "e235d758146bec6bb74f0f5783d735a1953e6dfe39c2569aee295f977a1485c4"] +colorama = ["05eed71e2e327246ad6b38c540c4a3117230b19679b875190486ddd2d721422d", "f8ac84de7840f5b9c4e3347b3c1eaa50f7e49c2b07596221daec5edaabbd7c48"] +cryptography = ["24b61e5fcb506424d3ec4e18bca995833839bf13c59fc43e530e488f28d46b8c", "25dd1581a183e9e7a806fe0543f485103232f940fcfc301db65e630512cce643", "3452bba7c21c69f2df772762be0066c7ed5dc65df494a1d53a58b683a83e1216", "41a0be220dd1ed9e998f5891948306eb8c812b512dc398e5a01846d855050799", "5751d8a11b956fbfa314f6553d186b94aa70fdb03d8a4d4f1c82dcacf0cbe28a", "5f61c7d749048fa6e3322258b4263463bfccefecb0dd731b6561cb617a1d9bb9", "72e24c521fa2106f19623a3851e9f89ddfdeb9ac63871c7643790f872a305dfc", "7b97ae6ef5cba2e3bb14256625423413d5ce8d1abb91d4f29b6d1a081da765f8", "961e886d8a3590fd2c723cf07be14e2a91cf53c25f02435c04d39e90780e3b53", "96d8473848e984184b6728e2c9d391482008646276c3ff084a1bd89e15ff53a1", "ae536da50c7ad1e002c3eee101871d93abdc90d9c5f651818450a0d3af718609", "b0db0cecf396033abb4a93c95d1602f268b3a68bb0a9cc06a7cff587bb9a7292", "cfee9164954c186b191b91d4193989ca994703b2fff406f71cf454a2d3c7327e", "e6347742ac8f35ded4a46ff835c60e68c22a536a8ae5c4422966d06946b6d4c6", "f27d93f0139a3c056172ebb5d4f9056e770fdf0206c2f422ff2ebbad142e09ed", "f57b76e46a58b63d1c6375017f4564a28f19a5ca912691fd2e4261b3414b618d"] +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"] +kiwisolver = ["05b5b061e09f60f56244adc885c4a7867da25ca387376b02c1efc29cc16bcd0f", "26f4fbd6f5e1dabff70a9ba0d2c4bd30761086454aa30dddc5b52764ee4852b7", "3b2378ad387f49cbb328205bda569b9f87288d6bc1bf4cd683c34523a2341efe", "400599c0fe58d21522cae0e8b22318e09d9729451b17ee61ba8e1e7c0346565c", "47b8cb81a7d18dbaf4fed6a61c3cecdb5adec7b4ac292bddb0d016d57e8507d5", "53eaed412477c836e1b9522c19858a8557d6e595077830146182225613b11a75", "58e626e1f7dfbb620d08d457325a4cdac65d1809680009f46bf41eaf74ad0187", "5a52e1b006bfa5be04fe4debbcdd2688432a9af4b207a3f429c74ad625022641", "5c7ca4e449ac9f99b3b9d4693debb1d6d237d1542dd6a56b3305fe8a9620f883", "682e54f0ce8f45981878756d7203fd01e188cc6c8b2c5e2cf03675390b4534d5", "79bfb2f0bd7cbf9ea256612c9523367e5ec51d7cd616ae20ca2c90f575d839a2", "7f4dd50874177d2bb060d74769210f3bce1af87a8c7cf5b37d032ebf94f0aca3", "8944a16020c07b682df861207b7e0efcd2f46c7488619cb55f65882279119389", "8aa7009437640beb2768bfd06da049bad0df85f47ff18426261acecd1cf00897", "939f36f21a8c571686eb491acfffa9c7f1ac345087281b412d63ea39ca14ec4a", "9733b7f64bd9f807832d673355f79703f81f0b3e52bfce420fc00d8cb28c6a6c", "a02f6c3e229d0b7220bd74600e9351e18bc0c361b05f29adae0d10599ae0e326", "a0c0a9f06872330d0dd31b45607197caab3c22777600e88031bfe66799e70bb0", "acc4df99308111585121db217681f1ce0eecb48d3a828a2f9bbf9773f4937e9e", "b64916959e4ae0ac78af7c3e8cef4becee0c0e9694ad477b4c6b3a536de6a544", "d3fcf0819dc3fea58be1fd1ca390851bdb719a549850e708ed858503ff25d995", "d52e3b1868a4e8fd18b5cb15055c76820df514e26aa84cc02f593d99fef6707f", "db1a5d3cc4ae943d674718d6c47d2d82488ddd94b93b9e12d24aabdbfe48caee", "e3a21a720791712ed721c7b95d433e036134de6f18c77dbe96119eaf7aa08004", "e8bf074363ce2babeb4764d94f8e65efd22e6a7c74860a4f05a6947afc020ff2", "f16814a4a96dc04bf1da7d53ee8d5b1d6decfc1a92a63349bb15d37b6a263dd9", "f2b22153870ca5cf2ab9c940d7bc38e8e9089fa0f7e5856ea195e1cf4ff43d5a", "f790f8b3dff3d53453de6a7b7ddd173d2e020fb160baff578d578065b108a05f"] +lazy-object-proxy = ["159a745e61422217881c4de71f9eafd9d703b93af95618635849fe469a283661", "23f63c0821cc96a23332e45dfaa83266feff8adc72b9bcaef86c202af765244f", "3b11be575475db2e8a6e11215f5aa95b9ec14de658628776e10d96fa0b4dac13", "3f447aff8bc61ca8b42b73304f6a44fa0d915487de144652816f950a3f1ab821", "4ba73f6089cd9b9478bc0a4fa807b47dbdb8fad1d8f31a0f0a5dbf26a4527a71", "4f53eadd9932055eac465bd3ca1bd610e4d7141e1278012bd1f28646aebc1d0e", "64483bd7154580158ea90de5b8e5e6fc29a16a9b4db24f10193f0c1ae3f9d1ea", "6f72d42b0d04bfee2397aa1862262654b56922c20a9bb66bb76b6f0e5e4f9229", "7c7f1ec07b227bdc561299fa2328e85000f90179a2f44ea30579d38e037cb3d4", "7c8b1ba1e15c10b13cad4171cfa77f5bb5ec2580abc5a353907780805ebe158e", "8559b94b823f85342e10d3d9ca4ba5478168e1ac5658a8a2f18c991ba9c52c20", "a262c7dfb046f00e12a2bdd1bafaed2408114a89ac414b0af8755c696eb3fc16", "acce4e3267610c4fdb6632b3886fe3f2f7dd641158a843cf6b6a68e4ce81477b", "be089bb6b83fac7f29d357b2dc4cf2b8eb8d98fe9d9ff89f9ea6012970a853c7", "bfab710d859c779f273cc48fb86af38d6e9210f38287df0069a63e40b45a2f5c", "c10d29019927301d524a22ced72706380de7cfc50f767217485a912b4c8bd82a", "dd6e2b598849b3d7aee2295ac765a578879830fb8966f70be8cd472e6069932e", "e408f1eacc0a68fed0c08da45f31d0ebb38079f043328dce69ff133b95c29dc1"] +marshmallow = ["0e497a6447ffaad55578138ca512752de7a48d12f444996ededc3d6bf8a09ca2", "e21a4dea20deb167c723e0ffb13f4cf33bcbbeb8a334e92406a3308cedea2826"] +marshmallow-polyfield = ["72980cb9a43a7c750580b4b08e9d01a8cbd583e1f59360f1924a1ed60f065a4c", "8d85301eb0f46ec184bac534a78472966f9cc3cbfab7fae58ddf8c0a954081cd", "cc57436b6fb65f33912c8f110d710933aa5a3082409cd5f9f0d8df6ec24d4280"] +matplotlib = ["029620799e581802961ac1dcff5cb5d3ee2f602e0db9c0f202a90495b37d2126", "2308f67e085735ed580fcace652339cb517f059cdc9ee8a418c1b55746dbffcb", "280aebaec25575e35bf7d1b3ebb2d8ae7e839edb5a403f1a121b7271744b1ef9", "295099acb5a8a1148d1b4693ad1a93479a20836cd8b7eb38183a98c84cdcb2f1", "75d44c55eb87af653afc3d0a37ab62ab4784c752be0e7c96622713d88ed57e64", "95d9d7c2d7f0c7a4317acbcf1a81efa0a2ce5cb5ddfad606ae4c25a783431f0a", "9703ffc3e7e369f3ab31d0032719710876cb341eb618e1a8a54447e1946a9f0a", "9ff80541d5676207c6e829632b28e22d9875ecaae54eab7a7f8fd82a6552e5e9", "a6a04ebd81b3183e7882c9047a9514b7f547b2bae5e4f61a02eaaa6b446bde54", "b22b0d3b8d8f769c6ac559f6761878d660bd23d67b36430f07161caf1505c29c", "b464d598e36e13f7d798443805f2ba6b4af3d26fc1652c51c77a7847cf665813", "c0fa162920185d5d74e6fdf52c1f8cca0fbf897025a9dd81e030cf08a915865a", "c452b7aff0a9e4612670a4590e6efc30929dad620a121d423c8f3d0bd93715e2", "c90fc796e97815ea3bbbdea63c1e4edf75336361a49b945fdbc2aff1c76008c6", "cc1d376963ea9c97338582f3f9d64757c51e71cf2655efe363a3f2414d84aac2", "d3f5dfaa345539599308bd83826db242e424e3f4e9657952f8738ce1b5b90e8a", "d9e80ba0ffdb0daacaf49e561474d5c5c153d6db853478cf90c8cba5ed8b72b1", "daac44fc77cf36ff01953e2acc57a843fb1f6572eb5bf0af10a2930fa7407715", "de43c85335d71094a254e8538719752e30db3305005dae8dcb3097b72587ed07", "e4621af28a2444f93b5b6d3d60f54767df8ac6daa510a98f68c34377cb474869", "f3755a52aae7fb640f5f57b7b63eb5d65688c84931d7833dbc7d03959cd4f8ce", "f99c43df8ed2b9d1c95a042f3cacf017f9690092feba0b4292eaa6713f92de97"] +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"] +packaging = ["0c98a5d0be38ed775798ece1b9727178c4469d9c3b4ada66e8e6b7849f8732af", "9e1cbf8c12b1f1ce0bb5344b8d7ecf66a6f8a6e91bcb0c84593ed6d3ab5c4ab3"] +pillow = ["0683e80d81e840d401b687ebc00a02bbb23d0793c34d0852a5af64cfa1589540", "09c4e81c3277199898e8dc2d85d94febad87c41251ecbd447ba7d64d94765bd8", "0ee74a23022af9baf997e3016b4e090e4ff08688d37a6f49010338ab46cfe101", "10860baedfe5da7c43cd17835b091494dcc59dda5ad176a011713fe398ea6ac2", "15c056bfa284c30a7f265a41ac4cbbc93bdbfc0dfe0613b9cb8a8581b51a9e55", "1a4e06ba4f74494ea0c58c24de2bb752818e9d504474ec95b0aa94f6b0a7e479", "1c3c707c76be43c9e99cb7e3d5f1bee1c8e5be8b8a2a5eeee665efbf8ddde91a", "1fd0b290203e3b0882d9605d807b03c0f47e3440f97824586c173eca0aadd99d", "24114e4a6e1870c5a24b1da8f60d0ba77a0b4027907860188ea82bd3508c80eb", "258d886a49b6b058cd7abb0ab4b2b85ce78669a857398e83e8b8e28b317b5abb", "2734c55f7d054b0ad889c971136cbb0a5b35a921e27beaa44fdc2436af529c6e", "2ac36ec56727a95bd5a04dfca6abce1db8042c31ee73b65796a42f31fd52d009", "2bc1002b573d107c0b172a5da0f34b4900b2ddc6c3296b82d601e966d5ac1959", "33c79b6dd6bc7f65079ab9ca5bebffb5f5d1141c689c9c6a7855776d1b09b7e8", "367385fc797b2c31564c427430c7a8630db1a00bd040555dfc1d5c52e39fcd72", "3c1884ff078fb8bf5f63d7d86921838b82ed4a7d0c027add773c2f38b3168754", "44e5240e8f4f8861d748f2a58b3f04daadab5e22bfec896bf5434745f788f33f", "46aa988e15f3ea72dddd81afe3839437b755fffddb5e173886f11460be909dce", "492e1e4df823b57f9334f591c78a1e0e65a361e92594534e0568eeeeea56bbba", "50fb9e25d25cfcb50b2e6842c4e104e4f0b424be4624e1724532bf005c67589a", "5ceadd60dbd1e56ab7faffbfee1df5ecb83c3f0420e47f652cd5306d70eb0296", "74d90d499c9c736d52dd6d9b7221af5665b9c04f1767e35f5dd8694324bd4601", "7eeac51fc37e6b19631a4b8e38b8261a074efcf7cc27fc16a6bee4697af7aaa5", "809c0a2ce9032cbcd7b5313f71af4bdc5c8c771cb86eb7559afd954cab82ebb5", "85d1ef2cdafd5507c4221d201aaf62fc9276f8b0f71bd3933363e62a33abc734", "8c3889c7681af77ecfa4431cd42a2885d093ecb811e81fbe5e203abc07e0995b", "9218d81b9fca98d2c47d35d688a0cea0c42fd473159dfd5612dcb0483c63e40b", "9319215530e236822169cbe92426cdc18d16b88c943fdf365a6309a89876e335", "96ec275c83bf839972d6a7dd7d685fdfb6a3233c3c382ecff839d04e7d53955d", "9aa4f3827992288edd37c9df345783a69ef58bd20cc02e64b36e44bcd157bbf1", "9d80f44137a70b6f84c750d11019a3419f409c944526a95219bea0ac31f4dd91", "b7ebd36128a2fe93991293f997e44be9286503c7530ace6a55b938b20be288d8", "c30857e1fbf7d4a4b79d7d376eefaf293ea4307b8293d00a62e6f517f51bfe9b", "c4c78e2c71c257c136cdd43869fd3d5e34fc2162dc22e4a5406b0ebe86958239", "c5472ea3945e8f9eb0659f37fc1f592fd06f4f725f0f03774a8999ad8c130334", "c6a842537f887be1fe115d8abb5daa9bc8cc124e455ff995830cc785624a97af", "cf0a2e040fdf5a6d95f4c286c6ef1df6b36c218b528c8a9158ec2452a804b9b8", "cfd28aad6fc61f7a5d4ee556a997dc6e5555d9381d1390c00ecaf984d57e4232", "d0fd1ec2e7c3e0aeaae999efe83f5d0f42c1160a1f8be5120d40857d20baa452", "dca5660e25932771460d4688ccbb515677caaf8595f3f3240ec16c117deff89a", "de7aedc85918c2f887886442e50f52c1b93545606317956d65f342bd81cb4fc3", "e6c0bbf8e277b74196e3140c35f9a1ae3eafd818f7f2d3a15819c49135d6c062"] +pluggy = ["0825a152ac059776623854c1543d65a4ad408eb3d33ee114dff91e57ec6ae6fc", "b9817417e95936bf75d85d3f8767f7df6cdde751fc40aed3bb3074cbcb77757c"] +ply = ["00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", "096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"] +protobuf = ["03f43eac9d5b651f976e91cf46a25b75e5779d98f0f4114b0abfed83376d75f8", "0c94b21e6de01362f91a86b372555d22a60b59708599ca9d5032ae9fdf8e3538", "2d2a9f30f61f4063fadd7fb68a2510a6939b43c0d6ceeec5c4704f22225da28e", "34a0b05fca061e4abb77dd180209f68d8637115ff319f51e28a6a9382d69853a", "358710fd0db25372edcf1150fa691f48376a134a6c69ce29f38f185eea7699e6", "3761ab21883f1d3add8643413b326a0026776879b13ecf904e1e05fe18532c03", "41e47198b94c27ba05a08b4a95160656105745c462af574e4bcb0807164065c0", "8c61cc8a76e9d381c665aecc5105fa0f1878cf7db8b5cd17202603bcb386d0fc", "a6eebc4db759e58fdac02efcd3028b811effac881d8a5bad1996e4e8ee6acb47", "a9c12f7c98093da0a46ba76ec40ace725daa1ac4038c41e4b1466afb5c45bb01", "cb95068492ba0859b8c9e61fa8ba206a83c64e5d0916fb4543700b2e2b214115", "cd98476ce7bb4dcd6a7b101f5eecdc073dafea19f311e36eb8fba1a349346277", "ce64cfbea18c535176bdaa10ba740c0fc4c6d998a3f511c17bedb0ae4b3b167c", "dcbb59eac73fd454e8f2c5fba9e3d3320fd4707ed6a9d3ea3717924a6f0903ea", "dd67f34458ae716029e2a71ede998e9092493b62a519236ca52e3c5202096c87", "e3c96056eb5b7284a20e256cb0bf783c8f36ad82a4ae5434a7b7cd02384144a7", "f612d584d7a27e2f39e7b17878430a959c1bc09a74ba09db096b468558e5e126", "f6de8a7d6122297b81566e5bd4df37fd5d62bec14f8f90ebff8ede1c9726cd0a", "fa529d9261682b24c2aaa683667253175c9acebe0a31105394b221090da75832"] +psutil = ["028a1ec3c6197eadd11e7b46e8cc2f0720dc18ac6d7aabdb8e8c0d6c9704f000", "503e4b20fa9d3342bcf58191bbc20a4a5ef79ca7df8972e6197cc14c5513e73d", "863a85c1c0a5103a12c05a35e59d336e1d665747e531256e061213e2e90f63f3", "954f782608bfef9ae9f78e660e065bd8ffcfaea780f9f2c8a133bb7cb9e826d7", "b6e08f965a305cd84c2d07409bc16fbef4417d67b70c53b299116c5b895e3f45", "bc96d437dfbb8865fc8828cf363450001cb04056bbdcdd6fc152c436c8a74c61", "cf49178021075d47c61c03c0229ac0c60d5e2830f8cab19e2d88e579b18cdb76", "d5350cb66690915d60f8b233180f1e49938756fb2d501c93c44f8fb5b970cc63", "eba238cf1989dfff7d483c029acb0ac4fcbfc15de295d682901f0e2497e6781a"] +py = ["64f65755aee5b381cea27766a3a147c3f15b9b6b9ac88676de66ba2ae36793fa", "dc639b046a6e2cff5bbe40194ad65936d6ba360b52b3c3fe1d08a82dd50b5e53"] +pyasn1 = ["061442c60842f6d11051d4fdae9bc197b64bd41573a12234a753a0cb80b4f30b", "0ee2449bf4c4e535823acc25624c45a8b454f328d59d3f3eeb82d3567100b9bd", "5f9fb05c33e53b9a6ee3b1ed1d292043f83df465852bec876e93b47fd2df7eed", "65201d28e081f690a32401e6253cca4449ccacc8f3988e811fae66bd822910ee", "79b336b073a52fa3c3d8728e78fa56b7d03138ef59f44084de5f39650265b5ff", "8ec20f61483764de281e0b4aba7d12716189700debcfa9e7935780850bf527f3", "9458d0273f95d035de4c0d5e0643f25daba330582cc71bb554fe6969c015042a", "98d97a1833a29ca61cd04a60414def8f02f406d732f9f0bcb49f769faff1b699", "b00d7bfb6603517e189d1ad76967c7e805139f63e43096e5f871d1277f50aea5", "b06c0cfd708b806ea025426aace45551f91ea7f557e0c2d4fbd9a4b346873ce0", "d14d05984581770333731690f5453efd4b82e1e5d824a1d7976b868a2e5c38e8", "da2420fe13a9452d8ae97a0e478adde1dee153b11ba832a95b223a2ba01c10f7", "da6b43a8c9ae93bc80e2739efb38cc776ba74a886e3e9318d65fe81a8b8a2c6e"] +pyasn1-modules = ["230730c6e63d283df75459b1b791d73648f801fd46ffcc9eb1abd16c67dfa3a6", "27f09b212203f820bc982937bd41952e856610dbd7c48d9366e8e63a551824c8", "490ed2974883c6e3d0ee53f53b32427f29ea030345c11d690788d1ed31ed666b", "49663b587853cd8783427d2fd115c862916bdd3c01656a8110ecd1950699e28f", "4df864e4dd01e600ffe280191a6630bb5b86d46382c1bcec4d03a700cb35c8b9", "6eeef742c31e285c23ebef32d8e0fee5e4ee1a563bb5171684621165b7e65627", "d1c66c80615ee74b1f3867d31b14e81f5f961a0e1afe5429838f21b5065d0161", "d7aa971a8cd79482ec5ae98705b54fdfaf834c24ed93ebc83f422c7700412b47", "e573fcf31e72c2ede48a58c8559fe9083cd007623c99a3eaf0c8f5719c09a2f8", "e980f089e3ec8116d6a5154c80f002ca941ad3446b5048a5b6d225f24ded85bb", "ef721f68f7951fab9b0404d42590f479e30d9005daccb1699b0a51bb4177db96", "f01c6899938f635b2ff4d158e760625416e20f03c612cfc9da7e97798c84e916", "f309b6c94724aeaf7ca583feb1cc70430e10d7551de5e36edfc1ae6909bcfb3c"] +pycodestyle = ["95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56", "e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"] +pycparser = ["a988718abfad80b6b157acce7bf130a30876d27603738ac39f140993246b25b3"] +pydocstyle = ["2258f9b0df68b97bf3a6c29003edc5238ff8879f1efb6f1999988d934e432bd8", "5741c85e408f9e0ddf873611085e819b809fca90b619f5fd7f34bd4959da3dd4", "ed79d4ec5e92655eccc21eb0c6cf512e69512b4a97d215ace46d17e4990f2039"] +pyflakes = ["17dbeb2e3f4d772725c777fabc446d5634d1038f234e77343108ce445ea69ce0", "d976835886f8c5b31d47970ed689944a0262b5f3afa00a5a7b4dc81e5449f8a2"] +pylama = ["9bae53ef9c1a431371d6a8dca406816a60d547147b60a4934721898f553b7d8f", "fd61c11872d6256b019ef1235be37b77c922ef37ac9797df6bd489996dddeb15"] +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"] +sortedcontainers = ["566cf5f8dbada3aed99737a19d98f03d15d76bf2a6c27e4fb0f4a718a99be761", "fa96e9920a37bde76bfdcaca919a125c1d2e581af1137e25de54ee0da7835282"] +sympy = ["71a11e5686ae7ab6cb8feb5bd2651ef4482f8fd43a7c27e645a165e4353b23e1", "f9b00ec76151c98470e84f1da2d7d03633180b71fb318428ddccce1c867d3eaa"] +typed-ast = ["18511a0b3e7922276346bcb47e2ef9f38fb90fd31cb9223eed42c85d1312344e", "262c247a82d005e43b5b7f69aff746370538e176131c32dda9cb0f324d27141e", "2b907eb046d049bcd9892e3076c7a6456c93a25bebfe554e931620c90e6a25b0", "354c16e5babd09f5cb0ee000d54cfa38401d8b8891eefa878ac772f827181a3c", "4e0b70c6fc4d010f8107726af5fd37921b666f5b31d9331f0bd24ad9a088e631", "630968c5cdee51a11c05a30453f8cd65e0cc1d2ad0d9192819df9978984529f4", "66480f95b8167c9c5c5c87f32cf437d585937970f3fc24386f313a4c97b44e34", "71211d26ffd12d63a83e079ff258ac9d56a1376a25bc80b1cdcdf601b855b90b", "95bd11af7eafc16e829af2d3df510cecfd4387f6453355188342c3e79a2ec87a", "bc6c7d3fa1325a0c6613512a093bc2a2a15aeec350451cbdf9e1d4bffe3e3233", "cc34a6f5b426748a507dd5d1de4c1978f2eb5626d51326e43280941206c209e1", "d755f03c1e4a51e9b24d899561fec4ccaf51f210d52abdf8c07ee2849b212a36", "d7c45933b1bdfaf9f36c579671fec15d25b06c8398f113dab64c18ed1adda01d", "d896919306dd0aa22d0132f62a1b78d11aaf4c9fc5b3410d3c666b818191630a", "ffde2fbfad571af120fcbfbbc61c72469e72f550d676c3342492a9dfdefb8f12"] +typing = ["4027c5f6127a6267a435201981ba156de91ad0d1d98e9ddc2aa173453453492d", "57dcf675a99b74d64dacf6fba08fb17cf7e3d5fdff53d4a30ea2a5e7e52543d4", "a4c8473ce11a65999c8f59cb093e70686b6c84c98df58c1dae9b3b196089858a"] +typing-extensions = ["07b2c978670896022a43c4b915df8958bec4a6b84add7f2c87b2b728bda3ba64", "f3f0e67e1d42de47b5c67c32c9b26641642e9170fe7e292991793705cd5fef7c", "fb2cd053238d33a8ec939190f30cfd736c00653a85a2919415cecf7dc3d9da71"] +uritemplate = ["01c69f4fe8ed503b2951bef85d996a9d22434d2431584b5b107b2981ff416fbd", "1b9c467a940ce9fb9f50df819e8ddd14696f89b9a8cc87ac77952ba416e0a8fd", "c02643cebe23fc8adb5e6becffe201185bf06c40bda5c0b4028a93f1527d011d"] +urllib3 = ["06330f386d6e4b195fbfc736b297f58c5a892e4440e54d294d7004e3a9bbea1b", "cc44da8e1145637334317feebd728bd869a35285b93cbb4cca2577da7e62db4f"] +wcwidth = ["3df37372226d6e63e1b1e1eda15c594bca98a22d33a23832a90998faa96bc65e", "f4ebe71925af7b40a864553f761ed559b43544f8f71746c2d756c7fe788ade7c"] +websockets = ["04b42a1b57096ffa5627d6a78ea1ff7fad3bc2c0331ffc17bc32a4024da7fea0", "08e3c3e0535befa4f0c4443824496c03ecc25062debbcf895874f8a0b4c97c9f", "10d89d4326045bf5e15e83e9867c85d686b612822e4d8f149cf4840aab5f46e0", "232fac8a1978fc1dead4b1c2fa27c7756750fb393eb4ac52f6bc87ba7242b2fa", "4bf4c8097440eff22bc78ec76fe2a865a6e658b6977a504679aaf08f02c121da", "51642ea3a00772d1e48fb0c492f0d3ae3b6474f34d20eca005a83f8c9c06c561", "55d86102282a636e195dad68aaaf85b81d0bef449d7e2ef2ff79ac450bb25d53", "564d2675682bd497b59907d2205031acbf7d3fadf8c763b689b9ede20300b215", "5d13bf5197a92149dc0badcc2b699267ff65a867029f465accfca8abab95f412", "5eda665f6789edb9b57b57a159b9c55482cbe5b046d7db458948370554b16439", "5edb2524d4032be4564c65dc4f9d01e79fe8fad5f966e5b552f4e5164fef0885", "79691794288bc51e2a3b8de2bc0272ca8355d0b8503077ea57c0716e840ebaef", "7fcc8681e9981b9b511cdee7c580d5b005f3bb86b65bde2188e04a29f1d63317", "8e447e05ec88b1b408a4c9cde85aa6f4b04f06aa874b9f0b8e8319faf51b1fee", "90ea6b3e7787620bb295a4ae050d2811c807d65b1486749414f78cfd6fb61489", "9e13239952694b8b831088431d15f771beace10edfcf9ef230cefea14f18508f", "d40f081187f7b54d7a99d8a5c782eaa4edc335a057aa54c85059272ed826dc09", "e1df1a58ed2468c7b7ce9a2f9752a32ad08eac2bcd56318625c3647c2cd2da6f", "e98d0cec437097f09c7834a11c69d79fe6241729b23f656cfc227e93294fc242", "f8d59627702d2ff27cb495ca1abdea8bd8d581de425c56e93bff6517134e0a9b", "fc30cdf2e949a2225b012a7911d1d031df3d23e99b7eda7dfc982dc4a860dae9"] +wrapt = ["4aea003270831cceb8a90ff27c4031da6ead7ec1886023b80ce0dfe0adf61533"] +zipp = ["8c1019c6aad13642199fbe458275ad6a84907634cc9f0989877ccc4a2840139d", "ca943a7e809cc12257001ccfb99e3563da9af99d52f261725e96dfe0f9275bc3"] diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..c597bfa5 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,68 @@ +[tool.poetry] +name = "qctrl-open-controls" +version = "1.2.1" +description = "Q-CTRL Open Controls" +license = "Apache-2.0" +authors = ["Q-CTRL "] +readme = "README.md" +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" + ] +repository = "https://github.com/qctrl/python-open-controls" +packages = [ + { include = "qctrlopencontrols" }, +] + +[tool.poetry.dependencies] # https://poetry.eustace.io/docs/versions +python = ">=3.7.3" +numpy = "^1.16" +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 = "*" +pylama = "*" +pylint = "*" +pylint_runner = "*" + +[tool.dephell.main] +from = {format = "poetry", path = "pyproject.toml"} +to = {format = "setuppy", path = "setup.py"} +versioning = "pep" +prereleases = true + +[build-system] +requires = ["poetry>=0.12"] +build-backend = "poetry.masonry.api" + +# _______________________________________ +# / If you update this file, please run \ +# \ poetry update && dephell deps convert / +# --------------------------------------- +# \ ^__^ +# \ (oo)\_______ +# (__)\ )\/\ +# ||----w | +# || || + diff --git a/setup-poetry.sh b/setup-poetry.sh new file mode 100755 index 00000000..19ab3b9e --- /dev/null +++ b/setup-poetry.sh @@ -0,0 +1,42 @@ +#!/bin/bash + +echo "--- Checking appropriate prerequisites are installed." + +# Check correct version of Python +python -V | grep 3.7 +if [ $? -ne 0 ] +then + echo "Please ensure you have Python 3.7 activated. Pyenv is recommended." + exit 1 +fi + +# Check Poetry installed +poetry --version | grep 0.12 +if [ $? -ne 0 ] +then + echo "--- Poetry not detected, installing..." + curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python +fi + +# Do dry run to create virtual environment +echo "--- Using Poetry to create virtual environment" +poetry install --dry-run -q + +# Activate created virtual environment +echo "--- Activating virtual environment" +VIRTUAL_ENV=$(poetry run python -c "import os; print(os.environ['VIRTUAL_ENV'])") +echo "Virtual environment path is $VIRTUAL_ENV" +source $VIRTUAL_ENV/bin/activate +if [ $? -ne 0 ] +then + echo "Could not activate the virtual environment!" + exit 2 +fi + +echo "--- Updating pip and setuptools" +pip install -q --upgrade pip setuptools +deactivate + +# Do the final install +echo "--- Installing dependencies" +poetry update \ No newline at end of file diff --git a/setup.py b/setup.py index 23a593e0..e8b68da5 100644 --- a/setup.py +++ b/setup.py @@ -1,75 +1,40 @@ -# 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. -""" -Setup script for Q-CTRL Open Controls -""" -from __future__ import absolute_import, division, print_function, unicode_literals - -from setuptools import setup, find_packages - - -def read_version(): - """Reads the version - """ - version={} - with open('qctrlopencontrols/version.py') as version_file: - exec(version_file.read(), version) - return version - - -def read_license(): - """ - Reads the LICENSE file. - """ - with open('LICENSE') as license_file: - return license_file.read() - - -def main(): - version = read_version() - setup( - name='qctrl-open-controls', - version=version['__version__'], - packages=find_packages(), - setup_requires=['pytest-runner'], - tests_require=['pytest'], - install_requires=['numpy', 'scipy', 'pytest', 'nbval', - 'qiskit-terra', 'qiskit-ibmq-provider', - 'cirq', 'pyquil'], - author='Q-CTRL', - author_email='support@q-ctrl.com', - description='Q-CTRL Open Controls', - 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' - ], - ) - - -if __name__ == '__main__': - main() +# -*- coding: utf-8 -*- + +# DO NOT EDIT THIS FILE! +# This file has been autogenerated by dephell <3 +# https://github.com/dephell/dephell + +try: + from setuptools import setup +except ImportError: + from distutils.core import setup + + +import os.path + +readme = '' +here = os.path.abspath(os.path.dirname(__file__)) +readme_path = os.path.join(here, 'README.rst') +if os.path.exists(readme_path): + with open(readme_path, 'rb') as stream: + readme = stream.read().decode('utf8') + + +setup( + long_description=readme, + name='qctrl-open-controls', + version='1.2.1', + description='Q-CTRL Open Controls', + python_requires='>=3.7.3', + project_urls={'repository': 'https://github.com/qctrl/python-open-controls'}, + author='Q-CTRL', + author_email='support@q-ctrl.com', + 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.pyquil', 'qctrlopencontrols.qiskit'], + package_data={}, + 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']}, +)