Docs: Add getting started example, QCS docs links (#14)

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

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": [
+       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐     ┌─┐   \n",
+       " q_0: ┤ H ├──■──┤M├───\n",
+       "      └───┘┌─┴─┐└╥┘┌─┐\n",
+       " q_1: ─────┤ X ├─╫─┤M├\n",
+       "           └───┘ ║ └╥┘\n",
+       "ro: 2/═══════════╩══╩═\n",
+       "                 0  1 </pre>"
+      ],
+      "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": [
+       "<Figure size 504x360 with 1 Axes>"
+      ]
+     },
+     "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
+}

docs/examples/qaoa_pyquil.ipynb → 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
-}
+}

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}