From c0a0d2d06dbe5dd7afaab17f91ba79c30ab43e23 Mon Sep 17 00:00:00 2001 From: Andrew Meyer <75644492+ameyer-rigetti@users.noreply.github.com> Date: Wed, 28 Jul 2021 13:38:08 -0700 Subject: [PATCH] Docs: Add getting started example, QCS docs links (#14) --- README.md | 5 + docs/examples/GettingStarted.ipynb | 183 ++++++++++++++++++ .../{qaoa_qiskit.ipynb => QAOA.ipynb} | 0 ...qaoa_pyquil.ipynb => QAOAFromPyQuil.ipynb} | 4 +- docs/index.md | 5 +- 5 files changed, 193 insertions(+), 4 deletions(-) create mode 100644 docs/examples/GettingStarted.ipynb rename docs/examples/{qaoa_qiskit.ipynb => QAOA.ipynb} (100%) rename docs/examples/{qaoa_pyquil.ipynb => QAOAFromPyQuil.ipynb} (99%) diff --git a/README.md b/README.md index d02ec3c..2f2df2f 100644 --- a/README.md +++ b/README.md @@ -61,6 +61,11 @@ print("Result memory:", memory) print("Result counts:", counts) ``` +### Rigetti Quantum Cloud Services (QCS) + +Execution against a QPU requires a [reservation via QCS](https://docs.rigetti.com/qcs/guides/reserving-time-on-a-qpu). +For more information on using QCS, see the [QCS documentation](https://docs.rigetti.com). + ## Advanced ### Lifecycle Hooks diff --git a/docs/examples/GettingStarted.ipynb b/docs/examples/GettingStarted.ipynb new file mode 100644 index 0000000..2969d36 --- /dev/null +++ b/docs/examples/GettingStarted.ipynb @@ -0,0 +1,183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting Started\n", + "\n", + "Using Qiskit with Rigetti QPUs and simulators is easy!\n", + "\n", + "To start out, let's import the necessary components:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import (\n", + " QuantumCircuit,\n", + " QuantumRegister,\n", + " ClassicalRegister,\n", + " execute\n", + ")\n", + "from qiskit_rigetti import RigettiQCSProvider" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Now, we'll instantiate a provider and get a backend. Use `provider.get_simulator()` to retrieve a simulator,\n", + "or use `provider.get_backend()` to retrieve a remote QPU backend (requires a reservation via [Rigetti Quantum Cloud Services (QCS)](https://docs.rigetti.com/qcs/guides/reserving-time-on-a-qpu))." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "provider = RigettiQCSProvider()\n", + "backend = provider.get_simulator(num_qubits=2, noisy=True) # or provider.get_backend(name=\"Aspen-9\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Now, let's create a simple Bell state circuit:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
      ┌───┐     ┌─┐   \n",
+       " q_0: ┤ H ├──■──┤M├───\n",
+       "      └───┘┌─┴─┐└╥┘┌─┐\n",
+       " q_1: ─────┤ X ├─╫─┤M├\n",
+       "           └───┘ ║ └╥┘\n",
+       "ro: 2/═══════════╩══╩═\n",
+       "                 0  1
" + ], + "text/plain": [ + " ┌───┐ ┌─┐ \n", + " q_0: ┤ H ├──■──┤M├───\n", + " └───┘┌─┴─┐└╥┘┌─┐\n", + " q_1: ─────┤ X ├─╫─┤M├\n", + " └───┘ ║ └╥┘\n", + "ro: 2/═══════════╩══╩═\n", + " 0 1 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit = QuantumCircuit(QuantumRegister(2, \"q\"), ClassicalRegister(2, \"ro\"))\n", + "circuit.h(0)\n", + "circuit.cx(0, 1)\n", + "circuit.measure([0, 1], [0, 1])\n", + "\n", + "circuit.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The circuit can now be run against the backend with Qiskit's `execute()` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counts for experiment: {'01': 57, '11': 405, '00': 476, '10': 62}\n" + ] + } + ], + "source": [ + "job = execute(circuit, backend, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "print(\"Counts for experiment:\", counts)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.tools.visualization import plot_histogram\n", + "\n", + "plot_histogram(counts)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum Cloud Services\n", + "\n", + "For more information on using Rigetti Quantum Cloud Services, see the [QCS documentation](https://docs.rigetti.com)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/qaoa_qiskit.ipynb b/docs/examples/QAOA.ipynb similarity index 100% rename from docs/examples/qaoa_qiskit.ipynb rename to docs/examples/QAOA.ipynb diff --git a/docs/examples/qaoa_pyquil.ipynb b/docs/examples/QAOAFromPyQuil.ipynb similarity index 99% rename from docs/examples/qaoa_pyquil.ipynb rename to docs/examples/QAOAFromPyQuil.ipynb index 62d0940..4a041e3 100644 --- a/docs/examples/qaoa_pyquil.ipynb +++ b/docs/examples/QAOAFromPyQuil.ipynb @@ -7,7 +7,7 @@ "source": [ "# Max-Cut QAOA on QCS with Qiskit\n", "\n", - "> ℹ️ Originally written to demonstrate pyQuil, this notebook demonstrates how to take existing pyQuil work and run it on a Rigetti backend using Qiskit.\n", + "> ℹ️ Originally written to demonstrate pyQuil, this notebook shows how to take existing pyQuil work and run it on a Rigetti backend using Qiskit.\n", "\n", "In this notebook, we will walk through how to run the **Max-Cut QAOA** algorithm using the Qiskit Rigetti Provider." ] @@ -333,4 +333,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/docs/index.md b/docs/index.md index 8e815ff..6c7b72a 100644 --- a/docs/index.md +++ b/docs/index.md @@ -13,8 +13,9 @@ This documentation supports light ☀️ and dark 🌙 modes and will automatica :maxdepth: 1 :caption: Examples -examples/qaoa_qiskit.ipynb -examples/qaoa_pyquil.ipynb +examples/GettingStarted.ipynb +examples/QAOA.ipynb +examples/QAOAFromPyQuil.ipynb ``` ```{toctree}