diff --git a/bootstrap.ps1 b/bootstrap.ps1
index 0ca15813a99..b60a938cce2 100644
--- a/bootstrap.ps1
+++ b/bootstrap.ps1
@@ -1,4 +1,4 @@
-# Copyright (c) Microsoft Corporation. All rights reserved.
+# Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
 $ErrorActionPreference = 'Stop'
diff --git a/documentation/examples/open-systems-concepts.ipynb b/documentation/examples/open-systems-concepts.ipynb
new file mode 100644
index 00000000000..eadce998f26
--- /dev/null
+++ b/documentation/examples/open-systems-concepts.ipynb
@@ -0,0 +1,2012 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "floating-horse",
+   "metadata": {},
+   "source": [
+    "# Quantum Concepts: Open quantum systems"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "average-arena",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "    \\newcommand{\\ket}[1]{\\left|#1\\right\\rangle}\n",
+    "    \\newcommand{\\bra}[1]{\\left\\langle#1\\right|}\n",
+    "    \\newcommand{\\Tr}[0]{\\operatorname{Tr}}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "significant-louisville",
+   "metadata": {},
+   "source": [
+    "## Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "national-angle",
+   "metadata": {},
+   "source": [
+    "Often in quantum computing, we'll talk about quantum systems that are very well isolated from their environments, such that no noise affects the qubits in such systems. We say that quantum systems that are isolated in this way are _closed quantum systems_.\n",
+    "\n",
+    "By contrast, a device that is subject to some amount of noise from its environment is an _open quantum system_. In this notebook, we'll cover some of the basics on representing the states of open quantum systems, and how quantum operations affect the states of open systems."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "progressive-mandate",
+   "metadata": {},
+   "source": [
+    "## Preamble"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "unexpected-parameter",
+   "metadata": {},
+   "source": [
+    "We start by importing the [QuTiP](https://qutip.org/) library, a popular Python library for manipulating states and processes of closed and open quantum systems."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "amended-tattoo",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qutip as qt\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "posted-brand",
+   "metadata": {},
+   "source": [
+    "We next import Q# ↔ Python interoperability and enable the preview noisy simulation feature."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "interim-sampling",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qsharp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "found-viking",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qsharp.experimental\n",
+    "qsharp.experimental.enable_noisy_simulation()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "piano-equipment",
+   "metadata": {},
+   "source": [
+    "We'll also open a few Q# namespaces that will be helpful to us in the rest of the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "minute-telephone",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "open Microsoft.Quantum.Diagnostics;\n",
+    "open Microsoft.Quantum.Measurement;\n",
+    "open Microsoft.Quantum.Random;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "protective-enlargement",
+   "metadata": {},
+   "source": [
+    "## Revisiting quantum states"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "civilian-tampa",
+   "metadata": {},
+   "source": [
+    "Before proceeding to discuss representing open quantum systems, it's helpful to quickly revisit representations of closed quantum systems. In particular, we can represent the state of an $n$-qubit register as a vector of $2^n$ complex numbers. For example, the state of a single qubit can be written as a vector of the form\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\ket{\\psi} = \\alpha \\ket{0} + \\beta \\ket{1} = \\left( \\begin{matrix}\n",
+    "        \\alpha \\\\ \\beta\n",
+    "    \\end{matrix} \\right)\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "for complex numbers $\\alpha$ and $\\beta$ such that $|\\alpha|^2 + |\\beta|^2 = 1$.\n",
+    "\n",
+    "In Q#, we can ask the default simulator to dump the state that it uses to simulate quantum programs, getting back a description of that state as a vector of this form."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "premium-parcel",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "operation DumpPlus() : Unit {\n",
+    "    use q = Qubit();\n",
+    "    within {\n",
+    "        H(q);\n",
+    "    } apply {\n",
+    "        DumpMachine();\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "difficult-phenomenon",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/json": "{\"div_id\":\"dump-machine-div-50205b36-432f-41c0-a536-dfceb3920625\",\"qubit_ids\":[0],\"n_qubits\":1,\"amplitudes\":[{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0},{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0}]}",
+      "text/html": [
+       "\r\n",
+       "                    <table style=\"table-layout: fixed; width: 100%\">\r\n",
+       "                        <thead>\r\n",
+       "                            \r\n",
+       "                        <tr>\r\n",
+       "                            <th>Qubit IDs</th>\r\n",
+       "                            <td span=\"3\">0</td>\r\n",
+       "                        </tr>\r\n",
+       "                    \r\n",
+       "                            <tr>\r\n",
+       "                                <th style=\"width: 20ch)\">Basis state (little endian)</th>\r\n",
+       "                                <th style=\"width: 20ch\">Amplitude</th><th style=\"width: calc(100% - 26ch - 20ch)\">Meas. Pr.</th><th style=\"width: 6ch\">Phase</th>\r\n",
+       "                            </tr>\r\n",
+       "                        </thead>\r\n",
+       "                        <tbody>\r\n",
+       "                        \r\n",
+       "                            <tr>\r\n",
+       "                                <td>$\\left|0\\right\\rangle$</td>\r\n",
+       "                                <td>$0.7071 + 0.0000 i$</td>\r\n",
+       "                                \r\n",
+       "                                <td>\r\n",
+       "                                    <progress\r\n",
+       "                                        max=\"100\"\r\n",
+       "                                        value=\"50.000000000000014\"\r\n",
+       "                                        style=\"width: 100%;\"\r\n",
+       "                                    > \r\n",
+       "                                    <td>\r\n",
+       "                                    <p id=\"round-77d99bf1-bb1d-48f8-923b-c437c0f35686\"> \r\n",
+       "                                    <script>\r\n",
+       "                                    var num = 50.000000000000014;\r\n",
+       "                                    num = num.toFixed(4);\r\n",
+       "                                    var num_string = num + \"%\";\r\n",
+       "                                     document.getElementById(\"round-77d99bf1-bb1d-48f8-923b-c437c0f35686\").innerHTML = num_string;\r\n",
+       "                                    </script> </p>\r\n",
+       "                                    </td>\r\n",
+       "                                </td>\r\n",
+       "                            \r\n",
+       "                                \r\n",
+       "                                <td style=\"transform: rotate(0deg);\r\n",
+       "                   text-align: center;\">\r\n",
+       "                                 ↑\r\n",
+       "                                </td>\r\n",
+       "                            \r\n",
+       "                            </tr>\r\n",
+       "                        \n",
+       "\r\n",
+       "                            <tr>\r\n",
+       "                                <td>$\\left|1\\right\\rangle$</td>\r\n",
+       "                                <td>$0.7071 + 0.0000 i$</td>\r\n",
+       "                                \r\n",
+       "                                <td>\r\n",
+       "                                    <progress\r\n",
+       "                                        max=\"100\"\r\n",
+       "                                        value=\"50.000000000000014\"\r\n",
+       "                                        style=\"width: 100%;\"\r\n",
+       "                                    > \r\n",
+       "                                    <td>\r\n",
+       "                                    <p id=\"round-4110d380-357e-42b8-b82c-9ea48ea1dd38\"> \r\n",
+       "                                    <script>\r\n",
+       "                                    var num = 50.000000000000014;\r\n",
+       "                                    num = num.toFixed(4);\r\n",
+       "                                    var num_string = num + \"%\";\r\n",
+       "                                     document.getElementById(\"round-4110d380-357e-42b8-b82c-9ea48ea1dd38\").innerHTML = num_string;\r\n",
+       "                                    </script> </p>\r\n",
+       "                                    </td>\r\n",
+       "                                </td>\r\n",
+       "                            \r\n",
+       "                                \r\n",
+       "                                <td style=\"transform: rotate(0deg);\r\n",
+       "                   text-align: center;\">\r\n",
+       "                                 ↑\r\n",
+       "                                </td>\r\n",
+       "                            \r\n",
+       "                            </tr>\r\n",
+       "                        \r\n",
+       "                        </tbody>\r\n",
+       "                    </table>"
+      ],
+      "text/plain": [
+       "|0⟩\t0.7071067811865476 + 0𝑖\n",
+       "|1⟩\t0.7071067811865476 + 0𝑖"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "()"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "DumpPlus.simulate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "alien-height",
+   "metadata": {},
+   "source": [
+    "The above diagnostic tells us that at the point when `DumpMachine` is called, the state of `q` is given by the vector $\\ket{+} \\mathrel{:=} (\\ket{0} + \\ket{1}) / \\sqrt{2} \\approx 0.7071 \\ket{0} + 0.7071 \\ket{1}$.\n",
+    "\n",
+    "We can also write this state in QuTiP notation, using `qt.basis(2, i)` to represent $\\ket{i}$ on a single qubit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "atmospheric-biodiversity",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}0.707\\\\0.707\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
+       "Qobj data =\n",
+       "[[0.70710678]\n",
+       " [0.70710678]]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ket0 = qt.basis(2, 0)\n",
+    "ket1 = qt.basis(2, 1)\n",
+    "ket_plus = (1 / np.sqrt(2)) * (ket0 + ket1)\n",
+    "ket_plus"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "welcome-ground",
+   "metadata": {},
+   "source": [
+    "When we measure a qubit in the $\\ket{+}$ state in the $Z$-basis, we get `Zero` and `One` with equal probability:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "after-division",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation SampleRandomBit() : Result {\n",
+    "    use q = Qubit();\n",
+    "    H(q);\n",
+    "    return MResetZ(q);\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "limited-tuner",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "54"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum(SampleRandomBit.simulate() for _ in range(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "robust-sally",
+   "metadata": {},
+   "source": [
+    "Importantly, though, the $\\ket{+}$ state is not inherently random — we can determinstically return to the $\\ket{0}$ state by applying another `H` operation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "blocked-ivory",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation ApplyHTwiceAndMeasure() : Result {\n",
+    "    use q = Qubit();\n",
+    "    H(q);\n",
+    "    H(q);\n",
+    "    return MResetZ(q);\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "average-facial",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum(ApplyHTwiceAndMeasure.simulate() for _ in range(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "unexpected-reply",
+   "metadata": {},
+   "source": [
+    "## Preparing random states"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "clean-nickname",
+   "metadata": {},
+   "source": [
+    "As opposed to preparing $\\ket{+}$ and measuring, we could also consider flipping a coin classically, and using the outcome to prepare either the $\\ket{0}$ or $\\ket{1}$ state.\n",
+    "\n",
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "insured-islam",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation PrepareAndMeasureRandomState() : Result {\n",
+    "    use q = Qubit();\n",
+    "    if DrawRandomBool(0.5) {\n",
+    "        X(q);\n",
+    "    }\n",
+    "    return MResetZ(q);\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "sapphire-album",
+   "metadata": {},
+   "source": [
+    "Doing so, we get the same 50/50 outcomes that we saw before:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "violent-proceeding",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "45"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum(PrepareAndMeasureRandomState.simulate() for _ in range(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "delayed-corps",
+   "metadata": {},
+   "source": [
+    "This time, however, when we apply `H` again, we don't get back to a determinstic outcome:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "coated-recognition",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation ApplyHToRandomStateAndMeasure() : Result {\n",
+    "    use q = Qubit();\n",
+    "    if DrawRandomBool(0.5) {\n",
+    "        X(q);\n",
+    "    }\n",
+    "    H(q); // ← Doesn't get us back to |0⟩!\n",
+    "    return MResetZ(q);\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "progressive-reception",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum(ApplyHToRandomStateAndMeasure.simulate() for _ in range(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "august-dealing",
+   "metadata": {},
+   "source": [
+    "As it turns out, there is no single vector that we can use to represent the state prepared by `ApplyHToRandomStateAndMeasure` unless we know the outcome of the random coin flip (`DrawRandomBool(0.5)`) in our description. If we don't know the outcome of the coin flip, we have an _ensemble_ of state vectors,\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\rho =\n",
+    "        \\left\\{\n",
+    "            \\ket{0} \\text{ with probability 50%}, \\quad\n",
+    "            \\ket{1} \\text{ with probability 50%}\n",
+    "        \\right\\}.\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "choice-salvation",
+   "metadata": {},
+   "source": [
+    "Just as with the quantum states that we're used to, we can predict measurements of such ensembles using Born's rule,\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\Pr(\\phi | \\psi) & = \\left|\\left\\langle \\phi | \\psi \\right\\rangle\\right|^2 \\\\\n",
+    "                     & = \\left\\langle \\phi | \\psi \\right\\rangle \\left\\langle \\psi | \\phi \\right\\rangle.\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "The trick here is to average over the different state vectors that could be prepared by our operation:\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\Pr(\\phi | \\rho)\n",
+    "        & = \\mathbb{E}_{\\psi \\sim \\rho} \\left[\n",
+    "            \\Pr(\\phi | \\psi)\n",
+    "        \\right] \\\\\n",
+    "        & = \\mathbb{E}_{\\psi \\sim \\rho} \\left [\n",
+    "            \\left\\langle \\phi | \\psi \\right\\rangle \\left\\langle \\psi | \\phi \\right\\rangle\n",
+    "        \\right] \\\\\n",
+    "        & = \\sum_i \\Pr(\\psi_i) \\left\\langle \\phi | \\psi_i \\right\\rangle \\left\\langle \\psi_i | \\phi \\right\\rangle \\\\\n",
+    "        & = \\left\\langle\n",
+    "            \\phi \\Bigg| \\left(\n",
+    "                \\sum_i \\Pr(\\psi_i) \\ket{\\psi_i} \\bra{\\psi_i}\n",
+    "            \\right) \\Bigg| \\phi\n",
+    "        \\right\\rangle.\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "freelance-procurement",
+   "metadata": {},
+   "source": [
+    "Factoring out $\\bra{\\phi}$ and $\\ket{\\phi}$ in the last step gives us a neat new way of writing out ensembles of state vectors as matrices called _density operators_. For example, the ensemble $\\rho$ above can also be written out as a density operator,\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\rho & = \\sum_i \\Pr(\\psi_i) \\ket{\\psi_i} \\bra{\\psi_i} \\\\\n",
+    "         & = \\frac12 \\ket{0} \\bra{0} + \\frac12 \\ket{1} \\bra{1} \\\\\n",
+    "         & = \\frac12 \\left( \\begin{matrix}\n",
+    "             1 & 0 \\\\ 0 & 1\n",
+    "         \\end{matrix} \\right).\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "sustained-expansion",
+   "metadata": {},
+   "source": [
+    "Using density operators, we can write both ensembles of states, as well as the kinds of closed system states that we're used to as _projectors_ on to those state vectors. For example, the $\\ket{+}$ state from above can be written as the density operator\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\ket{+}\\bra{+} = \n",
+    "    \\frac12 \\left( \\begin{matrix}\n",
+    "        1 & 1 \\\\ 1 & 1\n",
+    "    \\end{matrix} \\right).\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "foreign-breeding",
+   "metadata": {},
+   "source": [
+    "That is, even though both `SampleRandomBit` and `PrepareAndMeasureRandomState` both prepare density operators with the same diagonal elements (and thus have the same measurement probabilies in the $Z$-basis), the two density operators have different off-diagonal elements. We say that density operators in general represent _mixed states_, and that states that can be written as $\\ket{\\psi}\\bra{\\psi}$ for some state vector $\\ket{\\psi}$ (e.g.: $\\ket{+}\\bra{+}$)  are _pure states_.\n",
+    "\n",
+    "To tell how close a given density operator $\\rho$ is to being pure, we can look at the trace (that is the sum of the diagonal elements) of $\\rho^2$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "apart-plenty",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.0\\\\0.0 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.5 0. ]\n",
+       " [0.  0.5]]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rho_mixed = (ket0 * ket0.dag() + ket1 * ket1.dag()) / 2\n",
+    "rho_mixed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "touched-region",
+   "metadata": {},
+   "source": [
+    "The trace of $\\rho$ is written as $\\Tr(\\rho)$ and can be calculated using QuTiP's `.tr()` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "collectible-inventory",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.5"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(rho_mixed ** 2).tr()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "arabic-stress",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.500\\\\0.500 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.5 0.5]\n",
+       " [0.5 0.5]]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rho_pure = ket_plus * ket_plus.dag()\n",
+    "rho_pure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "ambient-lewis",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9999999999999996"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(rho_pure ** 2).tr()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "royal-viewer",
+   "metadata": {},
+   "source": [
+    "> #### 💡 TIP\n",
+    ">\n",
+    "> More generally, a given matrix $\\rho$ is a valid density operator if:\n",
+    ">\n",
+    "> 1. $\\rho$ is a matrix of complex numbers,\n",
+    "> 2. $\\rho = \\rho^{\\dagger}$ (that is, $\\rho$ is Hermitian),\n",
+    "> 3. Every eigenvalue $p$ of $\\rho$ is $0 <= p <= 1$, and\n",
+    "> 4. All the eigenvalues of $\\rho$ sum to 1.\n",
+    ">\n",
+    "> Together, these conditions guarantee that $\\rho$ can be thought of as an ensemble, as we saw above. In particular, if $\\rho = \\sum_i p_i \\ket{\\psi_i} \\bra{\\psi_i}$ is an eigenvalue decomposition of $\\rho$, then $\\rho$ describes the ensemble $\\rho = \\{\\ket{\\psi_i} \\text{ with probability } p_i\\}$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "embedded-range",
+   "metadata": {},
+   "source": [
+    "For single qubit systems, we can even plot mixed states on the Bloch sphere in the same way we plot state vectors — doing so, pure states are those states that lie on the surface of the Bloch sphere, while mixed states in general can be \"inside\" the Bloch sphere."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "sapphire-vermont",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x432 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(6, 6))\n",
+    "bloch = qt.bloch.Bloch()\n",
+    "bloch.add_states([rho_pure], kind='point')\n",
+    "bloch.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "mineral-keeping",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\cgran\\Anaconda3\\lib\\site-packages\\qutip\\bloch.py:587: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  if any(abs(dist - dist[0]) / dist[0] > 1e-12):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x432 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(6, 6))\n",
+    "bloch = qt.bloch.Bloch()\n",
+    "bloch.add_states([rho_mixed], kind='point')\n",
+    "bloch.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "wicked-oasis",
+   "metadata": {},
+   "source": [
+    "We say that the state at the very center of the Bloch sphere is the _maximally mixed state_. Unlike pure states, the maximally mixed state returns 50/50 outcomes for any ideal Pauli measurement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "political-finger",
+   "metadata": {},
+   "source": [
+    "## Representing quantum processes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "familiar-receptor",
+   "metadata": {},
+   "source": [
+    "Armed with the concept of a mixed state, we can now talk more concretely about how noisy processes affect the state of quantum registers. As before, it helps to take a step and consider how ideal unitary operations affect pure states.\n",
+    "\n",
+    "Considering the [`H` operation](https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.intrinsic.h), we can simulate its action on a pure state $\\ket{\\psi}$ as $H \\ket{\\psi}$. By direct analogy, we can simulate what `H` does to a density operator by multiplying on the left and right both:\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\rho \\longmapsto H\\rho H^{\\dagger} = H \\rho H.\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "More generally, though, we can also represent processes in which one of several unitary operations is applied at random. For example, suppose our `H` operation works 95% of the time, but the other 5% of the time does nothing. Just as we added different preparations together, we can simply add the density operators we get in each case, weighted by the probability of each case:\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\rho \\longmapsto 0.95 H \\rho H + 0.05 \\rho.\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "developing-queens",
+   "metadata": {},
+   "source": [
+    "One way to model this is by thinking of the `H` operation not as being represented by a unitary matrix, but by a function from density operators to density operators\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\Lambda_H(\\rho) = H\\rho H.\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "Since density functions represent an averge over different preparations, and since averages are linear, such functions must in general must also be linear.\n",
+    "\n",
+    "We say that a linear function from density operators to density operators is a _quantum process_.\n",
+    "\n",
+    "> **💡 TIP**:\n",
+    "> Quantum processes that can be realized in practice have a few other conditions as well as linearity, known as *complete positivity* and *trace preservingness*. We say that a process that is both completely positive and trace preserving (CPTP) is a _channel_.\n",
+    ">\n",
+    "> You may see this terminology in contexts where the CPTP property is assumed.\n",
+    "\n",
+    "There's a few different ways to represent quantum processes, but the one we'll most commonly encounter in working with noise models for open quantum systems is known as _superoperators_. Just as operators are linear functions from vectors to vectors, superoperators are linear functions from operators to operators, and can be written using matrices.\n",
+    "\n",
+    "For example, let's use `qt.to_super` to convert a few unitary matrices that we're already used to into superoperators. We start by noting that the 2 × 2 identity operator $𝟙$ we use to simulate the `Microsoft.Quantum.Intrinsic.I` operation is a 4 × 4 identity matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "atmospheric-handbook",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.0\\\\0.0 & 1.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 1.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 1.0\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[1. 0. 0. 0.]\n",
+       " [0. 1. 0. 0.]\n",
+       " [0. 0. 1. 0.]\n",
+       " [0. 0. 0. 1.]]"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Convert the 𝟙 matrix used to simulate Microsoft.Quantum.Intrinsic.I (single qubit no-op) into a superoperator.\n",
+    "qt.to_super(qt.qeye(2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "german-prevention",
+   "metadata": {},
+   "source": [
+    "That is, as we would expect, the superoperator we get from the identity operator maps all operators to themselves.\n",
+    "\n",
+    "On the other hand, we get something quite different for the $X$ matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "integrated-appendix",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.0 & 0.0 & 0.0 & 1.0\\\\0.0 & 0.0 & 1.0 & 0.0\\\\0.0 & 1.0 & 0.0 & 0.0\\\\1.0 & 0.0 & 0.0 & 0.0\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0. 0. 0. 1.]\n",
+       " [0. 0. 1. 0.]\n",
+       " [0. 1. 0. 0.]\n",
+       " [1. 0. 0. 0.]]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Convert the 𝑋 matrix used to simulate Microsoft.Quantum.Intrinsic.X into a superoperator.\n",
+    "qt.to_super(qt.sigmax())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "through-range",
+   "metadata": {},
+   "source": [
+    "What's happening above is that each column is a stack of the elements in an operator output by the function $\\Lambda_X(\\rho) = X \\rho X^{\\dagger} = X \\rho X$.\n",
+    "\n",
+    "Since $\\Lambda(\\ket{0}\\bra{0}) = X\\ket{0} \\bra{0}X = \\ket{1}\\bra{1}$, the first column is a stack of the elements of $\\ket{1}\\bra{1} = \\left(\\begin{matrix} 0 & 0 \\\\ 0 & 1 \\end{matrix}\\right)$. Similarly, the second column is a stack of the elements of $\\Lambda_X(\\ket{0}\\bra{1}) = \\ket{1}\\bra{0}$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "later-productivity",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.array((ket1 * ket0.dag()).data.todense().flat)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "authorized-aging",
+   "metadata": {},
+   "source": [
+    "We can see the same pattern in converting other unitary operators such as $H$ and $Z$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "further-munich",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.500 & 0.500 & 0.500\\\\0.500 & -0.500 & 0.500 & -0.500\\\\0.500 & 0.500 & -0.500 & -0.500\\\\0.500 & -0.500 & -0.500 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[ 0.5  0.5  0.5  0.5]\n",
+       " [ 0.5 -0.5  0.5 -0.5]\n",
+       " [ 0.5  0.5 -0.5 -0.5]\n",
+       " [ 0.5 -0.5 -0.5  0.5]]"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qt.to_super(qt.qip.operations.hadamard_transform())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "advanced-employee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.0\\\\0.0 & -1.0 & 0.0 & 0.0\\\\0.0 & 0.0 & -1.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 1.0\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[ 1.  0.  0.  0.]\n",
+       " [ 0. -1.  0.  0.]\n",
+       " [ 0.  0. -1.  0.]\n",
+       " [ 0.  0.  0.  1.]]"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qt.to_super(qt.sigmaz())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "abandoned-disabled",
+   "metadata": {},
+   "source": [
+    "Looking at the $Z$ example above in slightly more detail, we don't see a $-1$ sign in the lower-right hand corner because of the fact that density operators and superoperators do not have the same global phase ambiguity that state vectors and unitary operators do.\n",
+    "\n",
+    "In particular, consider acting the `Z` operation on a qubit in the $\\ket{1}$ state. Simulating this with state vectors, we get that $Z \\ket{1} = -\\ket{1}$, where the $-$ sign in front of $\\ket{1}$ is in this case an insignificant global phase. On the other hand, using open systems notation, we would simulate the same as $\\Lambda_Z(\\ket{1}\\bra{1}) = Z\\ket{1} \\bra{1}Z^{\\dagger} = Z\\ket{1} \\bra{1}Z = (-\\ket{1})(-\\bra{1}) = \\ket{1}\\bra{1}$, such that the global phases on the \"ket\" and \"bra\" parts of $\\ket{1}\\bra{1}$ cancel each other out.\n",
+    "\n",
+    "More generally, suppose that $U \\ket{\\phi} = e^{i\\phi} \\ket{\\phi}$ for some unitary operator $U$, some phase $\\phi$, and some state vector $\\ket{\\phi}$. Then since $\\bra{\\phi} U^\\dagger = (U \\ket{\\phi})^\\dagger = (e^{i \\phi} \\ket{\\phi})^\\dagger = \\bra{\\phi} e^{-i\\phi}$, we get the same cancellation:\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "    \\Lambda_U(\\ket{\\phi}\\bra{\\phi})\n",
+    "        & = U\\ket{\\phi}\\bra{\\phi}U^\\dagger \\\\\n",
+    "        & = e^{i\\phi} \\ket{\\phi}\\bra{\\phi} e^{-i\\phi} \\\\\n",
+    "        & = \\ket{\\phi}\\bra{\\phi}.\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "On the other hand, relative phases are still represented in open systems notation, as we can confirm by looking at the matrices for $\\ket{+}\\bra{+}$ and $\\ket{-}\\bra{-}$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "every-career",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}0.707\\\\-0.707\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
+       "Qobj data =\n",
+       "[[ 0.70710678]\n",
+       " [-0.70710678]]"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ket_minus = (ket0 - ket1) / np.sqrt(2)\n",
+    "ket_minus"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "detailed-sympathy",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.500\\\\0.500 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.5 0.5]\n",
+       " [0.5 0.5]]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ket_plus * ket_plus.dag()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "opening-coaching",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & -0.500\\\\-0.500 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
+       "Qobj data =\n",
+       "[[ 0.5 -0.5]\n",
+       " [-0.5  0.5]]"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ket_minus * ket_minus.dag()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "painted-relief",
+   "metadata": {},
+   "source": [
+    "That is, the off-diagonal elements of density operators tell us about the relative phases between each computational basis state."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "conceptual-suspension",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "express-luxembourg",
+   "metadata": {},
+   "source": [
+    "## Noisy quantum processes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "distinct-polyester",
+   "metadata": {},
+   "source": [
+    "Using superoperators not only allows us to represent familiar unitary operations, but also those functions from density operators to density operators that arise in describing noise. Returning to the example above, we can write $\\Lambda(\\rho) = 0.95 H\\rho H + 0.05 \\rho$ as a superoperator by simply summing the superoperators for `H` and `I` weighted by the probability for each case:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "convertible-credit",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.525 & 0.475 & 0.475 & 0.475\\\\0.475 & -0.425 & 0.475 & -0.475\\\\0.475 & 0.475 & -0.425 & -0.475\\\\0.475 & -0.475 & -0.475 & 0.525\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[ 0.525  0.475  0.475  0.475]\n",
+       " [ 0.475 -0.425  0.475 -0.475]\n",
+       " [ 0.475  0.475 -0.425 -0.475]\n",
+       " [ 0.475 -0.475 -0.475  0.525]]"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lambda_noisy_h = 0.95 * qt.to_super(qt.qip.operations.hadamard_transform()) + 0.05 * qt.to_super(qt.qeye(2))\n",
+    "lambda_noisy_h"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "supreme-lawsuit",
+   "metadata": {},
+   "source": [
+    "Unlike the unitary matrix $H$ that describes the ideal action of the `H` operation, the above superoperator allows us to simulate what happens when our `H` operation has a 5% probability of doing nothing instead.\n",
+    "\n",
+    "Let's hook this superoperator up to our Q# noise model and run `DumpPlus` again!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "outdoor-belize",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qsharp.config['experimental.simulators.nQubits'] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "hydraulic-cleaners",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qsharp.experimental.set_noise_model_by_name('ideal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "hazardous-liechtenstein",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/json": "{\"Data\":[0.5000000000000001,0.0,0.5000000000000001,0.0,0.5000000000000001,0.0,0.5000000000000001,0.0],\"NQubits\":1}",
+      "text/html": [
+       "\r\n",
+       "                    <table>\r\n",
+       "                        <caption>Mixed state</caption>\r\n",
+       "                        <tr>\r\n",
+       "                            <th># of qubits</th>\r\n",
+       "                            <td>1</td>\r\n",
+       "                        </tr>\r\n",
+       "\r\n",
+       "                        <tr>\r\n",
+       "                            <th>State data</th>\r\n",
+       "                            <td>\r\n",
+       "                                $$\r\n",
+       "                                \\left(\r\n",
+       "                                    \\begin{matrix}\r\n",
+       "                                        0.5000000000000001 + 0 i & 0.5000000000000001 + 0 i\\\\\n",
+       "0.5000000000000001 + 0 i & 0.5000000000000001 + 0 i\r\n",
+       "                                    \\end{matrix}\r\n",
+       "                                \\right)\r\n",
+       "                                $$\r\n",
+       "                            </td>\r\n",
+       "                        </tr>\r\n",
+       "                    </table>\r\n",
+       "                "
+      ],
+      "text/plain": [
+       "Mixed state on 1 qubits: [ [0.5000000000000001 + 0 i, 0.5000000000000001 + 0 i] [0.5000000000000001 + 0 i, 0.5000000000000001 + 0 i] ]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "()"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run with an ideal noise model first.\n",
+    "DumpPlus.simulate_noise()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "centered-cincinnati",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise_model = qsharp.experimental.get_noise_model_by_name('ideal')\n",
+    "noise_model['h'] = lambda_noisy_h\n",
+    "qsharp.experimental.set_noise_model(noise_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "prospective-annual",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/json": "{\"Data\":[0.5249999999999999,0.0,0.47500000000000026,-7.536865798903469E-33,0.47500000000000026,7.536865798903469E-33,0.4750000000000007,0.0],\"NQubits\":1}",
+      "text/html": [
+       "\r\n",
+       "                    <table>\r\n",
+       "                        <caption>Mixed state</caption>\r\n",
+       "                        <tr>\r\n",
+       "                            <th># of qubits</th>\r\n",
+       "                            <td>1</td>\r\n",
+       "                        </tr>\r\n",
+       "\r\n",
+       "                        <tr>\r\n",
+       "                            <th>State data</th>\r\n",
+       "                            <td>\r\n",
+       "                                $$\r\n",
+       "                                \\left(\r\n",
+       "                                    \\begin{matrix}\r\n",
+       "                                        0.5249999999999999 + 0 i & 0.47500000000000026 + -7.536865798903469E-33 i\\\\\n",
+       "0.47500000000000026 + 7.536865798903469E-33 i & 0.4750000000000007 + 0 i\r\n",
+       "                                    \\end{matrix}\r\n",
+       "                                \\right)\r\n",
+       "                                $$\r\n",
+       "                            </td>\r\n",
+       "                        </tr>\r\n",
+       "                    </table>\r\n",
+       "                "
+      ],
+      "text/plain": [
+       "Mixed state on 1 qubits: [ [0.5249999999999999 + 0 i, 0.47500000000000026 + -7.536865798903469E-33 i] [0.47500000000000026 + 7.536865798903469E-33 i, 0.4750000000000007 + 0 i] ]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "()"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run again, using our new noisy superoperator for the `H` operation.\n",
+    "DumpPlus.simulate_noise()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "pointed-sending",
+   "metadata": {},
+   "source": [
+    "Comparing the two, we see that when we add a probability of the `H` operation failing into our noise model, the preview simulator uses the density operator representation together with our noise model to simulate the effect of that noise on the state of our qubits."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "linear-checklist",
+   "metadata": {},
+   "source": [
+    "There are many other kinds of noise as well. For example, if we have an equal probability of applying the `I`, `X`, `Y`, or `Z` operations to a single qubit, then we get _completely depolarizing noise_:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "baking-watson",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[I, X, Y, Z] = map(qt.to_super, [qt.qeye(2), qt.sigmax(), qt.sigmay(), qt.sigmaz()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "unlikely-luxury",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.0 & 0.0 & 0.500\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.500 & 0.0 & 0.0 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.5 0.  0.  0.5]\n",
+       " [0.  0.  0.  0. ]\n",
+       " [0.  0.  0.  0. ]\n",
+       " [0.5 0.  0.  0.5]]"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "completely_depolarizing_process = 0.25 * (I + X + Y + Z)\n",
+    "completely_depolarizing_process"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "romance-excuse",
+   "metadata": {},
+   "source": [
+    "From the above matrix, we can see that completely depolarizing noise maps all input density operators to the same output, namely $𝟙 / 2$. That is, completely depolarizing noise replaces whatever state we had with the maximially mixed state."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "animal-vocabulary",
+   "metadata": {},
+   "source": [
+    "We can also have depolarizing noise of a finite strength (that is, not completely depolarizing) by taking a linear combination of the identity and completely depolarizing processes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "floating-merchant",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def depolarizing_noise(strength=0.05):\n",
+    "    return strength * completely_depolarizing_process + (1 - strength) * qt.to_super(I)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "broad-westminster",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.975 & 0.0 & 0.0 & 0.025\\\\0.0 & 0.950 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.950 & 0.0\\\\0.025 & 0.0 & 0.0 & 0.975\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.975 0.    0.    0.025]\n",
+       " [0.    0.95  0.    0.   ]\n",
+       " [0.    0.    0.95  0.   ]\n",
+       " [0.025 0.    0.    0.975]]"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "depolarizing_noise(0.05)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "concerned-knight",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.875 & 0.0 & 0.0 & 0.125\\\\0.0 & 0.750 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.750 & 0.0\\\\0.125 & 0.0 & 0.0 & 0.875\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.875 0.    0.    0.125]\n",
+       " [0.    0.75  0.    0.   ]\n",
+       " [0.    0.    0.75  0.   ]\n",
+       " [0.125 0.    0.    0.875]]"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "depolarizing_noise(0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "transparent-limitation",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.750 & 0.0 & 0.0 & 0.250\\\\0.0 & 0.500 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.500 & 0.0\\\\0.250 & 0.0 & 0.0 & 0.750\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.75 0.   0.   0.25]\n",
+       " [0.   0.5  0.   0.  ]\n",
+       " [0.   0.   0.5  0.  ]\n",
+       " [0.25 0.   0.   0.75]]"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "depolarizing_noise(0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "religious-casino",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}0.500 & 0.0 & 0.0 & 0.500\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.500 & 0.0 & 0.0 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = True\n",
+       "Qobj data =\n",
+       "[[0.5 0.  0.  0.5]\n",
+       " [0.  0.  0.  0. ]\n",
+       " [0.  0.  0.  0. ]\n",
+       " [0.5 0.  0.  0.5]]"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "depolarizing_noise(1.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "demonstrated-algorithm",
+   "metadata": {},
+   "source": [
+    "So far, every example we've seen can be represented as a mixture of unitary operators, but there's also many kinds of noise that cannot be represented this way. For instance, by analogy to completely depolarizing noise, if we have a process that has some probability of resetting its input state, we can represent that as a mixture of a superoperator that _always_ resets and the identity process."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "certified-image",
+   "metadata": {},
+   "source": [
+    "To see this, let's start by writing down the process $\\Lambda_{\\text{Reset}}(\\rho) = \\Tr(\\rho) \\ket{0}\\bra{0}$. Since this process does the same thing to each density operator we input, the first and fourth columns should be the same, namely $\\left(\\begin{matrix}1 & 0 & 0 & 0\\end{matrix}\\right)^{\\text{T}}$.\n",
+    "\n",
+    "On the other hand, the second and third columns represent the output of $\\Lambda_{\\text{Reset}}$ acting on $\\ket{0}\\bra{1}$ and $\\ket{1}\\bra{0}$ respectively. Neither of these is a valid density operator on their own — indeed, $\\Tr(\\ket{0}\\bra{1}) = \\Tr(\\ket{1}\\bra{0})$ such that the $\\Tr$ factor zeros out both of these columns."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "placed-minneapolis",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lambda_reset = qt.Qobj([\n",
+    "    [1, 0, 0, 1],\n",
+    "    [0, 0, 0, 0],\n",
+    "    [0, 0, 0, 0],\n",
+    "    [0, 0, 0, 0],\n",
+    "], dims=completely_depolarizing_process.dims)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bored-month",
+   "metadata": {},
+   "source": [
+    "We now have what we need to represent _amplitude damping_ noise, in which there's a finite chance of resetting each qubit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "naval-relaxation",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def amplitude_damping_noise(strength=0.05):\n",
+    "    return strength * lambda_reset + (1 - strength) * qt.to_super(I)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "british-wedding",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.050\\\\0.0 & 0.950 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.950 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.950\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\n",
+       "Qobj data =\n",
+       "[[1.   0.   0.   0.05]\n",
+       " [0.   0.95 0.   0.  ]\n",
+       " [0.   0.   0.95 0.  ]\n",
+       " [0.   0.   0.   0.95]]"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amplitude_damping_noise(0.05)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "still-force",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.250\\\\0.0 & 0.750 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.750 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.750\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\n",
+       "Qobj data =\n",
+       "[[1.   0.   0.   0.25]\n",
+       " [0.   0.75 0.   0.  ]\n",
+       " [0.   0.   0.75 0.  ]\n",
+       " [0.   0.   0.   0.75]]"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amplitude_damping_noise(0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "amino-tuner",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 0.500\\\\0.0 & 0.500 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.500 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.500\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\n",
+       "Qobj data =\n",
+       "[[1.  0.  0.  0.5]\n",
+       " [0.  0.5 0.  0. ]\n",
+       " [0.  0.  0.5 0. ]\n",
+       " [0.  0.  0.  0.5]]"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amplitude_damping_noise(0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "capital-reminder",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 0.0 & 0.0 & 1.0\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0 & 0.0\\\\\\end{array}\\right)\\end{equation*}"
+      ],
+      "text/plain": [
+       "Quantum object: dims = [[[2], [2]], [[2], [2]]], shape = (4, 4), type = super, isherm = False\n",
+       "Qobj data =\n",
+       "[[1. 0. 0. 1.]\n",
+       " [0. 0. 0. 0.]\n",
+       " [0. 0. 0. 0.]\n",
+       " [0. 0. 0. 0.]]"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "amplitude_damping_noise(1.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "associate-exclusion",
+   "metadata": {},
+   "source": [
+    "## Example: Decaying Ramsey signal"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "medical-motion",
+   "metadata": {},
+   "source": [
+    "Putting everything together by way of an example, let's see what happens if we repeatedly apply `S` to a qubit and then measure. While this may seem a bit contrived, it's good toy model for a kind of experiment known as _Ramsey interferometry_.\n",
+    "\n",
+    "In the absense of noise, we should see the signal that we get back oscillate with each iteration of `S`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "elegant-recognition",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation ApplySRepeatedlyAndMeasure(nRepetions : Int) : Result {\n",
+    "    use q = Qubit();\n",
+    "    within {\n",
+    "        H(q);\n",
+    "    } apply {\n",
+    "        for _ in 1..nRepetions {\n",
+    "            S(q);\n",
+    "        }\n",
+    "    }\n",
+    "    return MResetZ(q);\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "chief-infection",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qsharp.experimental.set_noise_model_by_name('ideal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "medium-brake",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ns = np.arange(1, 101)\n",
+    "signal_wo_noise = [\n",
+    "    sum(ApplySRepeatedlyAndMeasure.simulate_noise(nRepetions=n) for _ in range(100))\n",
+    "    for n in ns\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "anonymous-distance",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x2064d72a2c8>]"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(ns, signal_wo_noise)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "tropical-amendment",
+   "metadata": {},
+   "source": [
+    "On the other hand, if our `S` has some finite amplitude damping noise, then we'll eventually see this signal decay:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "acoustic-clinton",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "S = qt.Qobj([\n",
+    "    [1, 0],\n",
+    "    [0, 1j]\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "municipal-collection",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise_model = qsharp.experimental.get_noise_model_by_name('ideal')\n",
+    "noise_model['h'] = (\n",
+    "    depolarizing_noise(0.025) *\n",
+    "    qt.to_super(qt.qip.operations.hadamard_transform())\n",
+    ")\n",
+    "noise_model['s'] = (\n",
+    "    amplitude_damping_noise(0.025) *\n",
+    "    qt.to_super(S)\n",
+    ")\n",
+    "qsharp.experimental.set_noise_model(noise_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "stainless-series",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that this cell can take a few moments to run.\n",
+    "signal = [\n",
+    "    sum(ApplySRepeatedlyAndMeasure.simulate_noise(nRepetions=n) for _ in range(100))\n",
+    "    for n in ns\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "interesting-terrain",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x2064e0e7d08>"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(ns, signal_wo_noise, label='Ideal Signal')\n",
+    "plt.plot(ns, signal, label='With Amplitude Damping Noise')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "level-transaction",
+   "metadata": {},
+   "source": [
+    "## Next steps"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "violent-verse",
+   "metadata": {},
+   "source": [
+    "Having explored a bit of how to represent and simulate open quantum systems, there's a lot of great resources out there to help you take the next steps along your journey!\n",
+    "\n",
+    "Here's a couple suggestions for some great places to look for next steps:\n",
+    "\n",
+    "- [QuTiP documentation: Superoperators and Vectorized Operators](https://qutip.org/docs/latest/guide/guide-states.html#superoperators-and-vectorized-operators)\n",
+    "- [Characterization, Verification and Control for Large Quantum Systems: Chapter 1](https://uwspace.uwaterloo.ca/bitstream/handle/10012/9217/Granade_Christopher.pdf)\n",
+    "- [_Theory of Quantum Information_](https://cs.uwaterloo.ca/~watrous/TQI/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "confused-villa",
+   "metadata": {},
+   "source": [
+    "## Epilogue"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "indian-questionnaire",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'iqsharp': LooseVersion ('0.17.210628040-alpha'),\n",
+       " 'Jupyter Core': LooseVersion ('1.5.0.0'),\n",
+       " '.NET Runtime': LooseVersion ('.NETCoreApp,Version=v3.1'),\n",
+       " 'qsharp': LooseVersion ('0.17.2106.27950a1'),\n",
+       " 'experimental': {'simulators': {'features': ['DEFAULT'],\n",
+       "   'name': 'Microsoft.Quantum.Experimental.Simulators',\n",
+       "   'opt_level': '3',\n",
+       "   'target': 'x86_64-pc-windows-msvc',\n",
+       "   'version': '0.17.210628040-alpha'}}}"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qsharp.component_versions()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "floral-organizer",
+   "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.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/documentation/examples/experimental-simulators-from-python.ipynb b/documentation/examples/preview-simulators-from-python.ipynb
similarity index 89%
rename from documentation/examples/experimental-simulators-from-python.ipynb
rename to documentation/examples/preview-simulators-from-python.ipynb
index 66585a75a4c..ec7e642b34e 100644
--- a/documentation/examples/experimental-simulators-from-python.ipynb
+++ b/documentation/examples/preview-simulators-from-python.ipynb
@@ -5,7 +5,7 @@
    "id": "a21769ec",
    "metadata": {},
    "source": [
-    "# Using Experimental Simulators with Q# and Python"
+    "# Using Preview Simulators with Q# and Python"
    ]
   },
   {
@@ -13,7 +13,7 @@
    "id": "a7510c5c",
    "metadata": {},
    "source": [
-    "The experimental simulators use the [QuTiP](https://qutip.org) library for Python to help represent noise models, so we import it here."
+    "The preview open systems and stabilizer simulators for the Quantum Development Kit use the [QuTiP](https://qutip.org) library for Python to help represent noise models, so we import it here."
    ]
   },
   {
@@ -31,7 +31,7 @@
    "id": "67abc680",
    "metadata": {},
    "source": [
-    "To use the experimental simulators, we start by importing Q# interoperability as normal."
+    "To use the preview simulators, we start by importing Q# interoperability as normal."
    ]
   },
   {
@@ -39,16 +39,7 @@
    "execution_count": 2,
    "id": "00c0728f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Preparing Q# environment...\n",
-      "."
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import qsharp"
    ]
@@ -58,7 +49,7 @@
    "id": "a83cdd60",
    "metadata": {},
    "source": [
-    "We can then use `qsharp.experimental.enable_noisy_simulation()` to add support for experimental simulators."
+    "We can then use `qsharp.experimental.enable_noisy_simulation()` to add support for preview simulators."
    ]
   },
   {
@@ -106,14 +97,14 @@
    "outputs": [
     {
      "data": {
-      "application/json": "{\"Data\":[0.5000000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.5000000000000001,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],\"NQubits\":3}",
+      "application/json": "{\"Data\":[0.5000000000000001,0.0,0.5000000000000001,0.0,0.5000000000000001,0.0,0.5000000000000001,0.0],\"NQubits\":1}",
       "text/html": [
        "\r\n",
        "                    <table>\r\n",
        "                        <caption>Mixed state</caption>\r\n",
        "                        <tr>\r\n",
        "                            <th># of qubits</th>\r\n",
-       "                            <td>3</td>\r\n",
+       "                            <td>1</td>\r\n",
        "                        </tr>\r\n",
        "\r\n",
        "                        <tr>\r\n",
@@ -122,14 +113,8 @@
        "                                $$\r\n",
        "                                \\left(\r\n",
        "                                    \\begin{matrix}\r\n",
-       "                                        0.5000000000000001 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0.5000000000000001 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0.5000000000000001 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0.5000000000000001 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\\\\\n",
-       "0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i & 0 + 0 i\r\n",
+       "                                        0.5000000000000001 + 0 i & 0.5000000000000001 + 0 i\\\\\n",
+       "0.5000000000000001 + 0 i & 0.5000000000000001 + 0 i\r\n",
        "                                    \\end{matrix}\r\n",
        "                                \\right)\r\n",
        "                                $$\r\n",
@@ -139,7 +124,7 @@
        "                "
       ],
       "text/plain": [
-       "Mixed state on 3 qubits: [ [0.5000000000000001 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0.5000000000000001 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0.5000000000000001 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0.5000000000000001 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] [0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i, 0 + 0 i] ]"
+       "Mixed state on 1 qubits: [ [0.5000000000000001 + 0 i, 0.5000000000000001 + 0 i] [0.5000000000000001 + 0 i, 0.5000000000000001 + 0 i] ]"
       ]
      },
      "metadata": {},
@@ -167,10 +152,10 @@
    "source": [
     "Looking at the output from the above, we notice two distinct differences with the output from `.simulate()`:\n",
     "\n",
-    "- The experimental simulators use quantum registers of a fixed size (by default, three qubits), and allocate qubits from that register.\n",
-    "- By default, the experimental simulators represent quantum states as density operators ($\\rho = \\left|\\psi\\right\\rangle\\left\\langle\\psi\\right|$) instead of as state vectors ($\\left|\\psi\\right\\rangle$).\n",
+    "- The preview simulators use quantum registers of a fixed size (by default, three qubits), and allocate qubits from that register.\n",
+    "- By default, the preview simulators represent quantum states as density operators ($\\rho = \\left|\\psi\\right\\rangle\\left\\langle\\psi\\right|$) instead of as state vectors ($\\left|\\psi\\right\\rangle$).\n",
     "\n",
-    "For example, in the output above, the experimental simulator has output the density operator $\\rho = \\left|+00\\right\\rangle\\left\\langle+00\\right|$, as we can verify by using QuTiP."
+    "For example, in the output above, the preview simulator has output the density operator $\\rho = \\left|+00\\right\\rangle\\left\\langle+00\\right|$, as we can verify by using QuTiP."
    ]
   },
   {
@@ -278,7 +263,7 @@
    "id": "9aa83aef",
    "metadata": {},
    "source": [
-    "The experimental simulators can be configured by the use of the `qsharp.config` object. For example, to change the size of the register used, we can modify the `experimental.simulators.nQubits` configuration setting:"
+    "The preview simulators can be configured by the use of the `qsharp.config` object. For example, to change the size of the register used, we can modify the `experimental.simulators.nQubits` configuration setting:"
    ]
   },
   {
@@ -692,7 +677,7 @@
    "id": "05d1a8f5",
    "metadata": {},
    "source": [
-    "We can also configure the experimental simulator to use stabilizer (_a.k.a._ CHP) simulation. This time, let's get a new noise model by using `get_noise_model_by_name`:"
+    "We can also configure the preview simulator to use stabilizer (_a.k.a._ CHP) simulation. This time, let's get a new noise model by using `get_noise_model_by_name`:"
    ]
   },
   {
@@ -790,9 +775,7 @@
        "\r\n",
        "                        <tr>\r\n",
        "                            <th>State data</th>\r\n",
-       "                            <td>$$\\left(\\begin{array}{c|c|c}0 & 1 & 0\\\\\n",
-       "\\hline\n",
-       "1 & 0 & 0\\end{array}\\right)$$</td>\r\n",
+       "                            <td>$$\\left\\langle X \\right\\rangle$$</td>\r\n",
        "                        </tr>\r\n",
        "                    </table>\r\n",
        "                "
@@ -857,27 +840,7 @@
        "\r\n",
        "                        <tr>\r\n",
        "                            <th>State data</th>\r\n",
-       "                            <td>$$\\left(\\begin{array}{cccccccccc|cccccccccc|c}0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "\\hline\n",
-       "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\\n",
-       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\end{array}\\right)$$</td>\r\n",
+       "                            <td>$$\\left\\langle X𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙, 𝟙Z𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙, 𝟙𝟙Z𝟙𝟙𝟙𝟙𝟙𝟙𝟙, 𝟙𝟙𝟙Z𝟙𝟙𝟙𝟙𝟙𝟙, 𝟙𝟙𝟙𝟙Z𝟙𝟙𝟙𝟙𝟙, 𝟙𝟙𝟙𝟙𝟙Z𝟙𝟙𝟙𝟙, 𝟙𝟙𝟙𝟙𝟙𝟙Z𝟙𝟙𝟙, 𝟙𝟙𝟙𝟙𝟙𝟙𝟙Z𝟙𝟙, 𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙Z𝟙, 𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙𝟙Z \\right\\rangle$$</td>\r\n",
        "                        </tr>\r\n",
        "                    </table>\r\n",
        "                "
@@ -949,18 +912,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Wall time: 2.85 s\n"
+      "Wall time: 2.79 s\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "[1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
-       " 0,\n",
+       "[0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
@@ -968,99 +926,77 @@
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
-       " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
-       " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
-       " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1069,11 +1005,9 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
@@ -1081,11 +1015,13 @@
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1093,21 +1029,18 @@
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1115,106 +1048,83 @@
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1222,17 +1132,21 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
@@ -1241,19 +1155,20 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1261,6 +1176,7 @@
        " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1270,65 +1186,66 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1336,28 +1253,25 @@
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
@@ -1365,13 +1279,15 @@
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1383,35 +1299,26 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1421,27 +1328,14 @@
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 1,\n",
-       " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
@@ -1451,11 +1345,19 @@
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1465,9 +1367,11 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1479,26 +1383,32 @@
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1506,6 +1416,10 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
@@ -1519,53 +1433,52 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1575,75 +1488,94 @@
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1654,16 +1586,14 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
@@ -1671,45 +1601,38 @@
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
-       " 1,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
@@ -1717,33 +1640,30 @@
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
@@ -1755,34 +1675,36 @@
        " 1,\n",
        " 0,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
-       " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1794,9 +1716,6 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
@@ -1804,15 +1723,14 @@
        " 1,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
+       " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
-       " 1,\n",
-       " 1,\n",
-       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1821,6 +1739,10 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
@@ -1828,24 +1750,29 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
@@ -1854,49 +1781,67 @@
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
-       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
@@ -1904,34 +1849,49 @@
        " 1,\n",
        " 1,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
+       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
+       " 0,\n",
        " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
-       " 0,\n",
        " 1,\n",
        " 1,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
        " 1,\n",
        " 1,\n",
        " 1,\n",
@@ -1943,18 +1903,21 @@
        " 0,\n",
        " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
-       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 0,\n",
+       " 1,\n",
+       " 1,\n",
        " 0,\n",
        " 0,\n",
        " 1,\n",
        " 0,\n",
+       " 0,\n",
+       " 1,\n",
        " 1,\n",
-       " 0]"
+       " 0,\n",
+       " 1]"
       ]
      },
      "execution_count": 31,
@@ -2081,7 +2044,7 @@
    "outputs": [
     {
      "data": {
-      "application/json": "{\"div_id\":\"dump-machine-div-2c22aa8a-df12-4fb0-a61b-91284bd88c5c\",\"qubit_ids\":[0,1],\"n_qubits\":2,\"amplitudes\":[{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0},{\"Real\":0.0,\"Imaginary\":0.0,\"Magnitude\":0.0,\"Phase\":0.0},{\"Real\":0.0,\"Imaginary\":0.0,\"Magnitude\":0.0,\"Phase\":0.0},{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0}]}",
+      "application/json": "{\"div_id\":\"dump-machine-div-47a0d233-2a01-451a-9033-745fed57d860\",\"qubit_ids\":[0,1],\"n_qubits\":2,\"amplitudes\":[{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0},{\"Real\":0.0,\"Imaginary\":0.0,\"Magnitude\":0.0,\"Phase\":0.0},{\"Real\":0.0,\"Imaginary\":0.0,\"Magnitude\":0.0,\"Phase\":0.0},{\"Real\":0.7071067811865476,\"Imaginary\":0.0,\"Magnitude\":0.7071067811865476,\"Phase\":0.0}]}",
       "text/html": [
        "\r\n",
        "                    <table style=\"table-layout: fixed; width: 100%\">\r\n",
@@ -2110,12 +2073,12 @@
        "                                        style=\"width: 100%;\"\r\n",
        "                                    > \r\n",
        "                                    <td>\r\n",
-       "                                    <p id=\"round-c50f074d-8fea-4197-b864-c396051924b6\"> \r\n",
+       "                                    <p id=\"round-86aa2894-03fa-4715-91d9-681385eaf148\"> \r\n",
        "                                    <script>\r\n",
        "                                    var num = 50.000000000000014;\r\n",
        "                                    num = num.toFixed(4);\r\n",
        "                                    var num_string = num + \"%\";\r\n",
-       "                                     document.getElementById(\"round-c50f074d-8fea-4197-b864-c396051924b6\").innerHTML = num_string;\r\n",
+       "                                     document.getElementById(\"round-86aa2894-03fa-4715-91d9-681385eaf148\").innerHTML = num_string;\r\n",
        "                                    </script> </p>\r\n",
        "                                    </td>\r\n",
        "                                </td>\r\n",
@@ -2140,12 +2103,12 @@
        "                                        style=\"width: 100%;\"\r\n",
        "                                    > \r\n",
        "                                    <td>\r\n",
-       "                                    <p id=\"round-12dd8d8c-4a0d-4ae1-ae0f-72e8ac30a516\"> \r\n",
+       "                                    <p id=\"round-01b201b9-db43-4b3c-ba33-0f5de6c0b149\"> \r\n",
        "                                    <script>\r\n",
        "                                    var num = 0;\r\n",
        "                                    num = num.toFixed(4);\r\n",
        "                                    var num_string = num + \"%\";\r\n",
-       "                                     document.getElementById(\"round-12dd8d8c-4a0d-4ae1-ae0f-72e8ac30a516\").innerHTML = num_string;\r\n",
+       "                                     document.getElementById(\"round-01b201b9-db43-4b3c-ba33-0f5de6c0b149\").innerHTML = num_string;\r\n",
        "                                    </script> </p>\r\n",
        "                                    </td>\r\n",
        "                                </td>\r\n",
@@ -2170,12 +2133,12 @@
        "                                        style=\"width: 100%;\"\r\n",
        "                                    > \r\n",
        "                                    <td>\r\n",
-       "                                    <p id=\"round-d89234c5-a257-4fee-8a4d-dcc417909519\"> \r\n",
+       "                                    <p id=\"round-1e38e1be-152b-4b13-a762-c5e0a7ddd4da\"> \r\n",
        "                                    <script>\r\n",
        "                                    var num = 0;\r\n",
        "                                    num = num.toFixed(4);\r\n",
        "                                    var num_string = num + \"%\";\r\n",
-       "                                     document.getElementById(\"round-d89234c5-a257-4fee-8a4d-dcc417909519\").innerHTML = num_string;\r\n",
+       "                                     document.getElementById(\"round-1e38e1be-152b-4b13-a762-c5e0a7ddd4da\").innerHTML = num_string;\r\n",
        "                                    </script> </p>\r\n",
        "                                    </td>\r\n",
        "                                </td>\r\n",
@@ -2200,12 +2163,12 @@
        "                                        style=\"width: 100%;\"\r\n",
        "                                    > \r\n",
        "                                    <td>\r\n",
-       "                                    <p id=\"round-a334accb-a13c-4c7f-8ee2-5147bbde6306\"> \r\n",
+       "                                    <p id=\"round-ba9b35aa-4469-4f99-9f85-59cbe5b5e5e3\"> \r\n",
        "                                    <script>\r\n",
        "                                    var num = 50.000000000000014;\r\n",
        "                                    num = num.toFixed(4);\r\n",
        "                                    var num_string = num + \"%\";\r\n",
-       "                                     document.getElementById(\"round-a334accb-a13c-4c7f-8ee2-5147bbde6306\").innerHTML = num_string;\r\n",
+       "                                     document.getElementById(\"round-ba9b35aa-4469-4f99-9f85-59cbe5b5e5e3\").innerHTML = num_string;\r\n",
        "                                    </script> </p>\r\n",
        "                                    </td>\r\n",
        "                                </td>\r\n",
@@ -2370,7 +2333,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 41,
    "id": "5b80e500",
    "metadata": {},
    "outputs": [
@@ -2380,7 +2343,7 @@
        "SequenceProcess(n_qubits=1, processes=[ChpDecompositionProcess(n_qubits=1, operations=[Hadamard(idx_target=0)]), MixedPauliProcess(n_qubits=1, operators=[(0.9, 'I'), (0.1, 'Z')])])"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2402,7 +2365,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 42,
    "id": "94c8b146",
    "metadata": {},
    "outputs": [],
@@ -2412,13 +2375,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 43,
    "id": "c517bb74",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "application/json": "{\"Table\":{\"SchemaVersion\":1,\"Dimensions\":[8,9],\"Data\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,true,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false],\"AsArray\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,true,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false]},\"Data\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,true,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false],\"NQubits\":4}",
+      "application/json": "{\"Table\":{\"SchemaVersion\":1,\"Dimensions\":[8,9],\"Data\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false],\"AsArray\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false]},\"Data\":[false,false,false,false,true,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,false,false,true,true,false,false,false,false,false,false,false,false,false,true,false,false,false,false,false,false,false,false,false,true,false],\"NQubits\":4}",
       "text/html": [
        "\r\n",
        "                    <table>\r\n",
@@ -2430,7 +2393,7 @@
        "\r\n",
        "                        <tr>\r\n",
        "                            <th>State data</th>\r\n",
-       "                            <td>$$\\left\\langle -X_{0}X_{1}, Z_{0}Z_{1}, Z_{2}, Z_{3} \\right\\rangle$$</td>\r\n",
+       "                            <td>$$\\left\\langle X_{0}X_{1}, Z_{0}Z_{1}, Z_{2}, Z_{3} \\right\\rangle$$</td>\r\n",
        "                        </tr>\r\n",
        "                    </table>\r\n",
        "                "
@@ -2448,7 +2411,7 @@
        "()"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2467,25 +2430,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 44,
    "id": "56168b7e",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'iqsharp': LooseVersion ('1.0.0'),\n",
+       "{'iqsharp': LooseVersion ('0.17.210628040-alpha'),\n",
        " 'Jupyter Core': LooseVersion ('1.5.0.0'),\n",
        " '.NET Runtime': LooseVersion ('.NETCoreApp,Version=v3.1'),\n",
-       " 'qsharp': LooseVersion ('0.0.1.0a1'),\n",
+       " 'qsharp': LooseVersion ('0.17.2106.27950a1'),\n",
        " 'experimental': {'simulators': {'features': ['DEFAULT'],\n",
        "   'name': 'Microsoft.Quantum.Experimental.Simulators',\n",
        "   'opt_level': '3',\n",
        "   'target': 'x86_64-pc-windows-msvc',\n",
-       "   'version': '0.17.210627752-alpha'}}}"
+       "   'version': '0.17.210628040-alpha'}}}"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2519,7 +2482,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,
diff --git a/documentation/experimental-simulators.md b/documentation/preview-simulators.md
similarity index 66%
rename from documentation/experimental-simulators.md
rename to documentation/preview-simulators.md
index 944cbcb9a8b..d66a50b1ab2 100644
--- a/documentation/experimental-simulators.md
+++ b/documentation/preview-simulators.md
@@ -1,23 +1,23 @@
-# Using the Experimental Simulators for the Quantum Development Kit
+# Using the Preview Simulators for the Quantum Development Kit
 
-As an experimental feature, the Quantum Development Kit provides capabilities for noisy and stabilizer simulation. This feature allows for simulating the behavior of Q# programs under the influence of noise, and for using the stabilizer representation (a.k.a. CHP simulation) with programs that only call Clifford operations.
+As a preview feature, the Quantum Development Kit provides capabilities for noisy and stabilizer simulation. This feature allows for simulating the behavior of Q# programs under the influence of noise, and for using the stabilizer representation (a.k.a. CHP simulation) with programs that only call Clifford operations.
 
 > For more information about the development of this feature, please see the GitHub issue at <https://github.com/microsoft/qsharp-runtime/issues/714>.
 
-Currently, the experimental simulators are supported for use with:
+Currently, the preview simulators are supported for use with:
 
 - C# host programs
 - Python host programs
 - Q# standalone notebooks
 
-The experimental simulators are not yet supported by:
+The preview simulators are not yet supported by:
 
 - Q# standalone command-line programs
 - QIR-based executables
 
 ## Known issues and limitations
 
-As this feature is currently under development, there are still a number of limitations and missing capabilities.
+As this feature is currently under active development, there are still a number of limitations and missing capabilities.
 
 - Continuous-time rotations (e.g.: `Rx`, `Ry`, `Rz`, and `Exp`) are not yet supported.
 - Fractional rotations (e.g.: `R1Frac`, `ExpFrac`) are not yet supported.
@@ -30,11 +30,11 @@ Some limitations are inherent to open systems simulation, and may not ever be su
 
 - Assertions (e.g.: `AssertMeasurement` and `AssertMeasurementProbability`) are not supported, as these assertions may fail for correct code in the presence of noise. These assertions are no-ops on the experimental simulators.
 
-## Using Experimental Simulators from Python
+## Using Preview Simulators from Python
 
 > ### **ⓘ** TIP
 >
-> See the [example on using the experimental simulators from Python](./examples/experimental-simulators-from-python.ipynb) for more details.
+> See the [example on using the preview simulators from Python](./examples/preview-simulators-from-python.ipynb) for more details.
 
 Once you have the right version of the `qsharp-core` Python package installed, you can enable the use of the experimental simulators by using the `qsharp.experimental` module:
 
@@ -46,6 +46,10 @@ qsharp.experimental.enable_noisy_simulation()
 
 After calling `enable_noisy_simulation()`, Q# operations imported into Python will expose a `.simulate_noise()` method that can be used to run Q# programs against the experimental simulators.
 
-By default, `.simulate_noise()` will assume an ideal error model (that is, no noise). To configure a particular error model, use the `qsharp.experimental.get_noise_model` and `qsharp.experimental.set_noise_model` functions to get and set the current noise model for the experimental simulators. Each error model is represented as a dictionary from intrinsic operation names to objects representing the errors in those intrinsic operations.
+By default, `.simulate_noise()` will assume an ideal error model (that is, no noise). To configure a particular error model, use the `qsharp.experimental.get_noise_model` and `qsharp.experimental.set_noise_model` functions to get and set the current noise model for the preview simulators. Each error model is represented as a dictionary from intrinsic operation names to objects representing the errors in those intrinsic operations.
 
 For open systems simulation, error channels can be represented by [QuTiP](https://qutip.org/) `Qobj` objects encoding superoperators.
+
+```python
+
+```
diff --git a/src/Simulation/qdk_sim_rs/README.md b/src/Simulation/qdk_sim_rs/README.md
index f48c36c0bd5..3baef0bb8e1 100644
--- a/src/Simulation/qdk_sim_rs/README.md
+++ b/src/Simulation/qdk_sim_rs/README.md
@@ -7,19 +7,19 @@
          $ cargo +nightly doc --features python --open
 -->
 
-# Quantum Development Kit Experimental Simulators
+# Quantum Development Kit Preview Simulators
 
-> ## **⚠** WARNING **⚠**
+> ## **📝** NOTE
 >
-> This crate is **experimental**, and may undergo breaking API changes with no notice, and may not be maintained in future versions of the Quantum Development Kit.
+> This crate is in **preview**, and may undergo breaking API changes with no notice.
 >
-> As an experimental feature of the Quantum Development Kit, this crate may be buggy or incomplete. Please check the tracking issue at [microsoft/qsharp-runtime#714](https://github.com/microsoft/qsharp-runtime/issues/714) for more information.
+> As a preview feature, this crate may be buggy or incomplete. Please check the tracking issue at [microsoft/qsharp-runtime#714](https://github.com/microsoft/qsharp-runtime/issues/714) for more information.
 
 > ## **ⓘ** TIP
 >
 > This crate provides low-level APIs for interacting with experimental simulators. If you're interested in using the experimental simulators to run your Q# programs, please see the installation instructions at <https://github.com/microsoft/qsharp-runtime/tree/feature/experimental/opensim/docs/experimental-simulators.md>.
 
-This **experimental** crate implements simulation functionality for the Quantum Development Kit, including:
+This crate implements simulation functionality for the Quantum Development Kit, including:
 
 - Open systems simulation
 - Stabilizer simulation
diff --git a/src/Simulation/qdk_sim_rs/docs/python-api.md b/src/Simulation/qdk_sim_rs/docs/python-api.md
index 1950730920c..f6f0fbec74c 100644
--- a/src/Simulation/qdk_sim_rs/docs/python-api.md
+++ b/src/Simulation/qdk_sim_rs/docs/python-api.md
@@ -1,10 +1,10 @@
-# Using Experimental Simulators from Python
+# Using Preview Simulators from Python
 
 This module exposes the various data structures from this crate as Python objects, useful for embedding in Python programs.
 
 Note that this module contains Python-specific functionality, and cannot be used directly from Rust.
 
-> **ⓘ NOTE**: The Python API for this crate allows direct and low-level access to simulation data structures. This is distinct from using Python to run Q# programs on the experimental simulators implemented by this library. For details on how to use Python and Q# together with experimental simulators, please see documentation on the <https://github.com/microsoft/iqsharp> repository.
+> **ⓘ NOTE**: The Python API for this crate allows direct and low-level access to simulation data structures. This is distinct from using Python to run Q# programs on the preview simulators implemented by this library. For details on how to use Python and Q# together with preview simulators, please see documentation on the <https://github.com/microsoft/iqsharp> repository.
 
 ## Building the Python API