qsharp-lang 1.17.1-dev → 1.17.2-dev

package/dist/diagnostics.js

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { log } from "./log.js";
+/**
+ * Public error type for most `qsharp-lang` functions.
+ *
+ * This is typically thrown by functions that deal with compiling and
+ * running code. Contains one or more VS Code-like diagnostics.
+ */
+export class QdkDiagnostics extends Error {
+    constructor(diagnostics) {
+        const message = shortMessage(diagnostics);
+        super(message);
+        this.diagnostics = diagnostics;
+        this.name = "QdkDiagnostics";
+    }
+}
+/**
+ * Wrapper around QDK WASM functions to convert exceptions to a more ergonomic type.
+ *
+ * Many of the WASM functions throw exceptions that are of type `string`,
+ * which are really just JSON-serialized `IQSharpError[]`s.
+ *
+ * This function converts those exceptions into `QdkDiagnostics` instances
+ * that properly inherit from `Error`.
+ */
+export async function callAndTransformExceptions(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        const QdkDiagnostics = tryParseQdkDiagnostics(e);
+        if (QdkDiagnostics) {
+            throw QdkDiagnostics;
+        }
+        throw e;
+    }
+}
+/**
+ * If the error is a string containing JSON-serialized `IQSharpError[]`,
+ * creates a `QdkDiagnostics` instance from it.
+ */
+function tryParseQdkDiagnostics(e) {
+    if (typeof e === "string") {
+        try {
+            const errors = JSON.parse(e);
+            // Check for the shape of IQSharpError[]
+            if (Array.isArray(errors) &&
+                errors.length > 0 &&
+                errors[0].document &&
+                errors[0].diagnostic) {
+                return new QdkDiagnostics(errors);
+            }
+        }
+        catch {
+            // Couldn't parse the error as JSON.
+            log.warn(`could not parse error string ${e}`);
+        }
+    }
+    return undefined;
+}
+/**
+ * Constructs a human-readable message from the first error.
+ */
+function shortMessage(errors) {
+    const error = errors[0];
+    return `${error.diagnostic.message} at ${friendlyLocation(error.document, error.diagnostic.range)}`;
+}
+/**
+ * Constructs a human-readable location string for an error.
+ */
+function friendlyLocation(uriOrName, range) {
+    // Don't make any assumptions about the format of uriOrName,
+    // it could be a file path, a URI with an arbitrary scheme, or just a name.
+    // If it contains slashes, we assume it's a path and extract the basename.
+    // Best effort, for display only.
+    const lastSlash = Math.max(uriOrName.lastIndexOf("/"), uriOrName.lastIndexOf("\\"));
+    const basename = lastSlash >= 0 ? uriOrName.substring(lastSlash + 1) : uriOrName;
+    // avoid printing :1:1 since that's the default if the original error didn't specify a range
+    const lineColumn = range.start.line > 0 || range.start.character > 0
+        ? `:${range.start.line + 1}:${range.start.character + 1}`
+        : "";
+    return `${basename}${lineColumn}`;
+}

package/dist/katas-content.generated.js

@@ -1094,7 +1094,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>There is another way to represent quantum gates, this time using Dirac notation. However, kets aren't enough to represent arbitrary matrices. An additional notation is required: the <strong>bra</strong> (this is why Dirac notation is sometimes called <strong>bra-ket notation</strong>).</p>\n<p>Recall that kets represent column vectors; a bra is a ket's row vector counterpart. For any ket $\\ket{\\psi}$, the corresponding bra is its adjoint (conjugate transpose): $\\bra{\\psi} = \\ket{\\psi}^\\dagger$.</p>\n<p>Some examples:</p>\n<table>\n  <tr>\n    <th>Ket</th>\n    <th>Bra</th>\n  </tr>\n  <tr>\n    <td>$\\ket{0} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n    <td>$\\bra{0} = \\begin{bmatrix} 1 & 0 \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{1} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n    <td>$\\bra{1} = \\begin{bmatrix} 0 & 1 \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n    <td>$\\bra{ i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} & -\\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{\\psi} = \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$</td>\n    <td>$\\bra{\\psi} = \\begin{bmatrix} \\overline{\\alpha} & \\overline{\\beta} \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</td>\n    <td>$\\bra{\\psi} = \\overline{\\alpha}\\bra{0} + \\overline{\\beta}\\bra{1}$</td>\n  </tr>\n</table>\n<p>Kets and bras give us a neat way to express inner and outer products. The inner product of $\\ket{\\phi}$ and $\\ket{\\psi}$ is the matrix product of $\\bra{\\phi}$ and $\\ket{\\psi}$, denoted as $\\braket{\\phi|\\psi}$, and their outer product is the matrix product of $\\ket{\\phi}$ and $\\bra{\\psi}$, denoted as $\\ket{\\phi}\\bra{\\psi}$. Notice that the norm of $\\ket{\\psi}$ is $\\sqrt{\\braket{\\psi|\\psi}}$.</p>\n<p>This leads to the representation of matrices via outer products. Recall that the outer product of two vectors of the same size produces a square matrix. You can use a linear combination of several outer products of simple vectors (such as basis vectors) to express any square matrix. For example, the $X$ gate can be expressed as follows:</p>\n<p>$$X = \\ket{0}\\bra{1} + \\ket{1}\\bra{0}$$</p>\n<p>$$\n\\ket{0}\\bra{1} + \\ket{1}\\bra{0} =\n\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}\\begin{bmatrix} 0 &amp; 1 \\end{bmatrix} +\n\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\\begin{bmatrix} 1 &amp; 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 &amp; 1 \\\\ 0 &amp; 0 \\end{bmatrix} + \\begin{bmatrix} 0 &amp; 0 \\\\ 1 &amp; 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix}\n$$</p>\n<p>This representation can be used to carry out calculations in Dirac notation without ever switching back to matrix representation:</p>\n<p>$$X\\ket{0} = \\big(\\ket{0}\\bra{1} + \\ket{1}\\bra{0}\\big)\\ket{0} = \\ket{0}\\braket{1|0} + \\ket{1}\\braket{0|0} = \\ket{0}\\big(\\braket{1|0}\\big) + \\ket{1}\\big(\\braket{0|0}\\big) = \\ket{0}(0) + \\ket{1}(1) = \\ket{1}$$</p>\n<blockquote>\n<p>That last step may seem a bit confusing. Recall that $\\ket{0}$ and $\\ket{1}$ form an <strong>orthonormal basis</strong>. That is, they're both normalized, and they're orthogonal to each other.</p>\n<p>A vector is normalized if its norm is equal to $1$, which only happens if its inner product with itself is equal to $1$. This means that $\\braket{0|0} = \\braket{1|1} = 1$</p>\n<p>Two vectors are orthogonal to each other if their inner product equals $0$. This means that $\\braket{0|1} = \\braket{1|0} = 0$.</p>\n</blockquote>\n<p>In general case, a matrix\n$$A = \\begin{bmatrix} a_{00} &amp; a_{01} \\\\ a_{10} &amp; a_{11} \\end{bmatrix}$$\nwill have the following ket-bra representation:\n$$A = a_{00} \\ket{0}\\bra{0} + a_{01} \\ket{0}\\bra{1} + a_{10} \\ket{1}\\bra{0} + a_{11} \\ket{1}\\bra{1}$$</p>\n"
+                            "content": "<p>There is another way to represent quantum gates, this time using Dirac notation. However, kets aren't enough to represent arbitrary matrices. An additional notation is required: the <strong>bra</strong> (this is why Dirac notation is sometimes called <strong>bra-ket notation</strong>).</p>\n<p>Recall that kets represent column vectors; a bra is a ket's row vector counterpart. For any ket $\\ket{\\psi}$, the corresponding bra is its adjoint (conjugate transpose): $\\bra{\\psi} = \\ket{\\psi}^\\dagger$.</p>\n<p>Some examples:</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Ket</th>\n      <th>Bra</th>\n    </tr>\n    <tr>\n      <td>$\\ket{0} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n      <td>$\\bra{0} = \\begin{bmatrix} 1 & 0 \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{1} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n      <td>$\\bra{1} = \\begin{bmatrix} 0 & 1 \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n      <td>$\\bra{ i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} & -\\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{\\psi} = \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$</td>\n      <td>$\\bra{\\psi} = \\begin{bmatrix} \\overline{\\alpha} & \\overline{\\beta} \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</td>\n      <td>$\\bra{\\psi} = \\overline{\\alpha}\\bra{0} + \\overline{\\beta}\\bra{1}$</td>\n    </tr>\n  </table>\n</div>\n<p>Kets and bras give us a neat way to express inner and outer products. The inner product of $\\ket{\\phi}$ and $\\ket{\\psi}$ is the matrix product of $\\bra{\\phi}$ and $\\ket{\\psi}$, denoted as $\\braket{\\phi|\\psi}$, and their outer product is the matrix product of $\\ket{\\phi}$ and $\\bra{\\psi}$, denoted as $\\ket{\\phi}\\bra{\\psi}$. Notice that the norm of $\\ket{\\psi}$ is $\\sqrt{\\braket{\\psi|\\psi}}$.</p>\n<p>This leads to the representation of matrices via outer products. Recall that the outer product of two vectors of the same size produces a square matrix. You can use a linear combination of several outer products of simple vectors (such as basis vectors) to express any square matrix. For example, the $X$ gate can be expressed as follows:</p>\n<p>$$X = \\ket{0}\\bra{1} + \\ket{1}\\bra{0}$$</p>\n<p>$$\n\\ket{0}\\bra{1} + \\ket{1}\\bra{0} =\n\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}\\begin{bmatrix} 0 &amp; 1 \\end{bmatrix} +\n\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\\begin{bmatrix} 1 &amp; 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 &amp; 1 \\\\ 0 &amp; 0 \\end{bmatrix} + \\begin{bmatrix} 0 &amp; 0 \\\\ 1 &amp; 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix}\n$$</p>\n<p>This representation can be used to carry out calculations in Dirac notation without ever switching back to matrix representation:</p>\n<p>$$X\\ket{0} = \\big(\\ket{0}\\bra{1} + \\ket{1}\\bra{0}\\big)\\ket{0} = \\ket{0}\\braket{1|0} + \\ket{1}\\braket{0|0} = \\ket{0}\\big(\\braket{1|0}\\big) + \\ket{1}\\big(\\braket{0|0}\\big) = \\ket{0}(0) + \\ket{1}(1) = \\ket{1}$$</p>\n<blockquote>\n<p>That last step may seem a bit confusing. Recall that $\\ket{0}$ and $\\ket{1}$ form an <strong>orthonormal basis</strong>. That is, they're both normalized, and they're orthogonal to each other.</p>\n<p>A vector is normalized if its norm is equal to $1$, which only happens if its inner product with itself is equal to $1$. This means that $\\braket{0|0} = \\braket{1|1} = 1$</p>\n<p>Two vectors are orthogonal to each other if their inner product equals $0$. This means that $\\braket{0|1} = \\braket{1|0} = 0$.</p>\n</blockquote>\n<p>In general case, a matrix\n$$A = \\begin{bmatrix} a_{00} &amp; a_{01} \\\\ a_{10} &amp; a_{11} \\end{bmatrix}$$\nwill have the following ket-bra representation:\n$$A = a_{00} \\ket{0}\\bra{0} + a_{01} \\ket{0}\\bra{1} + a_{10} \\ket{1}\\bra{0} + a_{11} \\ket{1}\\bra{1}$$</p>\n"
                         }
                     ]
                 },
@@ -1116,7 +1116,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>This section introduces some of the common single-qubit gates, including their matrix form, their ket-bra decomposition, and a brief &quot;cheat sheet&quot; listing their effect on some common qubit states.</p>\n<p>You can use a tool called <a href=\"https://algassert.com/quirk\" target=\"_blank\">Quirk</a> to visualize how these gates interact with various qubit states.</p>\n<p>This section relies on the following notation:</p>\n<table>\n  <tr>\n    <td>$\\ket{+} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + \\ket{1}\\big)$</td>\n    <td>$\\ket{-} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - \\ket{1}\\big)$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + i\\ket{1}\\big)$</td>\n    <td>$\\ket{-i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - i\\ket{1}\\big)$</td>\n  </tr>\n</table>\n<p>The Pauli gates, named after <a href=\"https://en.wikipedia.org/wiki/Wolfgang_Pauli\" target=\"_blank\">Wolfgang Pauli</a>, are based on the so-called <strong>Pauli matrices</strong>, $X$, $Y$ and $Z$. All three Pauli gates are <strong>self-adjoint</strong>, meaning that each one is its own inverse, $XX = \\mathbb{I}$.</p>\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Ket-Bra</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n  </tr>\n  <tr>\n    <td>$X$</td>\n    <td>$\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{1} + \\ket{1}\\bra{0}$</td>\n    <td>$X\\ket{\\psi} = \\alpha\\ket{1} + \\beta\\ket{0}$</td>\n    <td>\n      $X\\ket{0} = \\ket{1}$<br>\n      $X\\ket{1} = \\ket{0}$<br>\n      $X\\ket{+} = \\ket{+}$<br>\n      $X\\ket{-} = -\\ket{-}$<br>\n      $X\\ket{i} = i\\ket{-i}$<br>\n      $X\\ket{-i} = -i\\ket{i}$\n    </td>\n  </tr>\n  <tr>\n    <td>$Y$</td>\n    <td>$\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$</td>\n    <td>$i(\\ket{1}\\bra{0} - \\ket{0}\\bra{1})$</td>\n    <td>$Y\\ket{\\psi} = i\\big(\\alpha\\ket{1} - \\beta\\ket{0}\\big)$</td>\n    <td>\n      $Y\\ket{0} = i\\ket{1}$<br>\n      $Y\\ket{1} = -i\\ket{0}$<br>\n      $Y\\ket{+} = -i\\ket{-}$<br>\n      $Y\\ket{-} = i\\ket{+}$<br>\n      $Y\\ket{i} = \\ket{i}$<br>\n      $Y\\ket{-i} = -\\ket{-i}$<br>\n    </td>\n  </tr>\n  <tr>\n    <td>$Z$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} - \\ket{1}\\bra{1}$</td>\n    <td>$Z\\ket{\\psi} = \\alpha\\ket{0} - \\beta\\ket{1}$</td>\n    <td>\n      $Z\\ket{0} = \\ket{0}$<br>\n      $Z\\ket{1} = -\\ket{1}$<br>\n      $Z\\ket{+} = \\ket{-}$<br>\n      $Z\\ket{-} = \\ket{+}$<br>\n      $Z\\ket{i} = \\ket{-i}$<br>\n      $Z\\ket{-i} = \\ket{i}$<br>\n    </td>\n  </tr>\n</table>\n<blockquote>\n<p>The $X$ gate is sometimes referred to as the <strong>bit flip</strong> gate, or the <strong>NOT</strong> gate, because it acts like the classical NOT gate on the computational basis.</p>\n<p>The $Z$ gate is sometimes referred to as the <strong>phase flip</strong> gate.</p>\n</blockquote>\n<p>Here are several properties of the Pauli gates that are easy to verify and convenient to remember:</p>\n<ul>\n<li>Different Pauli gates <em>anti-commute</em>:\n$$XZ = -ZX, XY = -YX, YZ = -ZY$$</li>\n<li>A product of any two Pauli gates equals the third gate, with an extra $i$ (or $-i$) phase:\n$$XY = iZ, YZ = iX, ZX = iY$$</li>\n<li>A product of all three Pauli gates equals identity (with an extra $i$ phase):\n$$XYZ = iI$$</li>\n</ul>\n"
+                            "content": "<p>This section introduces some of the common single-qubit gates, including their matrix form, their ket-bra decomposition, and a brief &quot;cheat sheet&quot; listing their effect on some common qubit states.</p>\n<p>You can use a tool called <a href=\"https://algassert.com/quirk\" target=\"_blank\">Quirk</a> to visualize how these gates interact with various qubit states.</p>\n<p>This section relies on the following notation:</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <td>$\\ket{+} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + \\ket{1}\\big)$</td>\n      <td>$\\ket{-} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - \\ket{1}\\big)$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + i\\ket{1}\\big)$</td>\n      <td>$\\ket{-i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - i\\ket{1}\\big)$</td>\n    </tr>\n  </table>\n</div>\n<p>The Pauli gates, named after <a href=\"https://en.wikipedia.org/wiki/Wolfgang_Pauli\" target=\"_blank\">Wolfgang Pauli</a>, are based on the so-called <strong>Pauli matrices</strong>, $X$, $Y$ and $Z$. All three Pauli gates are <strong>self-adjoint</strong>, meaning that each one is its own inverse, $XX = \\mathbb{I}$.</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n    </tr>\n    <tr>\n      <td>$X$</td>\n      <td>$\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{1} + \\ket{1}\\bra{0}$</td>\n      <td>$X\\ket{\\psi} = \\alpha\\ket{1} + \\beta\\ket{0}$</td>\n      <td>\n        $X\\ket{0} = \\ket{1}$<br>\n        $X\\ket{1} = \\ket{0}$<br>\n        $X\\ket{+} = \\ket{+}$<br>\n        $X\\ket{-} = -\\ket{-}$<br>\n        $X\\ket{i} = i\\ket{-i}$<br>\n        $X\\ket{-i} = -i\\ket{i}$\n      </td>\n    </tr>\n    <tr>\n      <td>$Y$</td>\n      <td>$\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$</td>\n      <td>$i(\\ket{1}\\bra{0} - \\ket{0}\\bra{1})$</td>\n      <td>$Y\\ket{\\psi} = i\\big(\\alpha\\ket{1} - \\beta\\ket{0}\\big)$</td>\n      <td>\n        $Y\\ket{0} = i\\ket{1}$<br>\n        $Y\\ket{1} = -i\\ket{0}$<br>\n        $Y\\ket{+} = -i\\ket{-}$<br>\n        $Y\\ket{-} = i\\ket{+}$<br>\n        $Y\\ket{i} = \\ket{i}$<br>\n        $Y\\ket{-i} = -\\ket{-i}$<br>\n      </td>\n    </tr>\n    <tr>\n      <td>$Z$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} - \\ket{1}\\bra{1}$</td>\n      <td>$Z\\ket{\\psi} = \\alpha\\ket{0} - \\beta\\ket{1}$</td>\n      <td>\n        $Z\\ket{0} = \\ket{0}$<br>\n        $Z\\ket{1} = -\\ket{1}$<br>\n        $Z\\ket{+} = \\ket{-}$<br>\n        $Z\\ket{-} = \\ket{+}$<br>\n        $Z\\ket{i} = \\ket{-i}$<br>\n        $Z\\ket{-i} = \\ket{i}$<br>\n      </td>\n    </tr>\n  </table>\n</div>\n<blockquote>\n<p>The $X$ gate is sometimes referred to as the <strong>bit flip</strong> gate, or the <strong>NOT</strong> gate, because it acts like the classical NOT gate on the computational basis.</p>\n<p>The $Z$ gate is sometimes referred to as the <strong>phase flip</strong> gate.</p>\n</blockquote>\n<p>Here are several properties of the Pauli gates that are easy to verify and convenient to remember:</p>\n<ul>\n<li>Different Pauli gates <em>anti-commute</em>:\n$$XZ = -ZX, XY = -YX, YZ = -ZY$$</li>\n<li>A product of any two Pauli gates equals the third gate, with an extra $i$ (or $-i$) phase:\n$$XY = iZ, YZ = iX, ZX = iY$$</li>\n<li>A product of all three Pauli gates equals identity (with an extra $i$ phase):\n$$XYZ = iI$$</li>\n</ul>\n"
                         }
                     ]
                 },
@@ -1311,7 +1311,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>The identity gate is mostly here for completeness, at least for now. It will come in handy when dealing with multi-qubit systems and multi-qubit gates. It's represented by the identity matrix, and doesn't affect the state of the qubit.</p>\n<table>\n<tr>\n<th>Gate</th>\n<th>Matrix</th>\n<th>Ket-Bra</th>\n<th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n</tr>\n<tr>\n<td>$I$</td>\n<td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n<td>$\\ket{0}\\bra{0} + \\ket{1}\\bra{1}$</td>\n<td>$I\\ket{\\psi} = \\ket{\\psi}$</td>\n</tr>\n</table>"
+                            "content": "<p>The identity gate is mostly here for completeness, at least for now. It will come in handy when dealing with multi-qubit systems and multi-qubit gates. It's represented by the identity matrix, and doesn't affect the state of the qubit.</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    </tr>\n    <tr>\n      <td>$I$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + \\ket{1}\\bra{1}$</td>\n      <td>$I\\ket{\\psi} = \\ket{\\psi}$</td>\n    </tr>\n  </table>\n</div>"
                         }
                     ]
                 },
@@ -1322,7 +1322,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>The <strong>Hadamard</strong> gate is an extremely important quantum gate. Unlike the previous gates, applying the Hadamard gate to a qubit in a computational basis state puts that qubit into a superposition.\nLike the Pauli gates, the Hadamard gate is self-adjoint.</p>\n<table>\n<tr>\n<th>Gate</th>\n<th>Matrix</th>\n<th>Ket-Bra</th>\n<th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n<th>Applying to basis states</th>\n</tr>\n<tr>\n<td>$H$</td>\n<td>$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}} \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}$</td>\n<td>$\\ket{0}\\bra{+} + \\ket{1}\\bra{-}$</td>\n<td>$H\\ket{\\psi} = \\alpha\\ket{+} + \\beta\\ket{-} = \\frac{\\alpha + \\beta}{\\sqrt{2}}\\ket{0} + \\frac{\\alpha - \\beta}{\\sqrt{2}}\\ket{1}$</td>\n<td>$H\\ket{0} = \\ket{+}$ <br>\n$H\\ket{1} = \\ket{-}$ <br>\n$H\\ket{+} = \\ket{0}$ <br>\n$H\\ket{-} = \\ket{1}$ <br>\n$H\\ket{i} = e^{i\\pi/4}\\ket{-i}$ <br>\n$H\\ket{-i} = e^{-i\\pi/4}\\ket{i} $ <br>\n</tr>\n</table>\n<blockquote>\n<p>As a reminder, $e^{i\\pi/4} = \\frac{1}{\\sqrt2} (1 + i)$ and $e^{-i\\pi/4} = \\frac{1}{\\sqrt2} (1 - i)$. This is an application of Euler's formula, $e^{i\\theta} = \\cos \\theta + i\\sin \\theta$, where $\\theta$ is measured in radians.\nSee this <a href=\"https://en.wikipedia.org/wiki/Euler%27s_formula\">Wikipedia article</a> for an explanation of Euler's formula and/or <a href=\"https://youtu.be/v0YEaeIClKY\">this video</a> for a more intuitive explanation.</p>\n</blockquote>\n"
+                            "content": "<p>The <strong>Hadamard</strong> gate is an extremely important quantum gate. Unlike the previous gates, applying the Hadamard gate to a qubit in a computational basis state puts that qubit into a superposition.\nLike the Pauli gates, the Hadamard gate is self-adjoint.</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n    </tr>\n    <tr>\n      <td>$H$</td>\n      <td>$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}} \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{+} + \\ket{1}\\bra{-}$</td>\n      <td>$H\\ket{\\psi} = \\alpha\\ket{+} + \\beta\\ket{-} = \\frac{\\alpha + \\beta}{\\sqrt{2}}\\ket{0} + \\frac{\\alpha - \\beta}{\\sqrt{2}}\\ket{1}$</td>\n      <td>$H\\ket{0} = \\ket{+}$ <br>\n      $H\\ket{1} = \\ket{-}$ <br>\n      $H\\ket{+} = \\ket{0}$ <br>\n      $H\\ket{-} = \\ket{1}$ <br>\n      $H\\ket{i} = e^{i\\pi/4}\\ket{-i}$ <br>\n      $H\\ket{-i} = e^{-i\\pi/4}\\ket{i} $ <br>\n    </tr>\n  </table>\n</div>\n<blockquote>\n<p>As a reminder, $e^{i\\pi/4} = \\frac{1}{\\sqrt2} (1 + i)$ and $e^{-i\\pi/4} = \\frac{1}{\\sqrt2} (1 - i)$. This is an application of Euler's formula, $e^{i\\theta} = \\cos \\theta + i\\sin \\theta$, where $\\theta$ is measured in radians.\nSee this <a href=\"https://en.wikipedia.org/wiki/Euler%27s_formula\">Wikipedia article</a> for an explanation of Euler's formula and/or <a href=\"https://youtu.be/v0YEaeIClKY\">this video</a> for a more intuitive explanation.</p>\n</blockquote>\n"
                         }
                     ]
                 },
@@ -1389,7 +1389,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>The next two gates are known as <strong>phase shift gates</strong>. They apply a phase to the $\\ket{1}$ state, and leave the $\\ket{0}$ state unchanged.</p>\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Ket-Bra</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n    </tr>\n  <tr>\n    <td>$S$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} + i\\ket{1}\\bra{1}$</td>\n    <td>$S\\ket{\\psi} = \\alpha\\ket{0} + i\\beta\\ket{1}$</td>\n    <td>\n      $S\\ket{0} = \\ket{0}$<br>\n      $S\\ket{1} = i\\ket{1}$<br>\n      $S\\ket{+} = \\ket{i}$<br>\n      $S\\ket{-} = \\ket{-i}$<br>\n      $S\\ket{i} = \\ket{-}$<br>\n      $S\\ket{-i} = \\ket{+}$<br>\n    </td>\n    </tr>\n  <tr>\n    <td>$T$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} + e^{i\\pi/4}\\ket{1}$$\\bra{1}$</td>\n    <td>$T\\ket{\\psi} = \\alpha\\ket{0} + e^{i\\pi/4} \\beta \\ket{1}$</td>\n    <td>\n      $T\\ket{0} = \\ket{0}$<br>\n      $T\\ket{1} = e^{i\\pi/4}\\ket{1}$\n    </td>\n  </tr>\n</table>\n<blockquote>\n<p>Notice that applying the $T$ gate twice is equivalent to applying the $S$ gate, and applying the $S$ gate twice is equivalent to applying the $Z$ gate:\n$$T^2 = S, S^2 = Z$$</p>\n</blockquote>\n"
+                            "content": "<p>The next two gates are known as <strong>phase shift gates</strong>. They apply a phase to the $\\ket{1}$ state, and leave the $\\ket{0}$ state unchanged.</p>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n      </tr>\n    <tr>\n      <td>$S$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + i\\ket{1}\\bra{1}$</td>\n      <td>$S\\ket{\\psi} = \\alpha\\ket{0} + i\\beta\\ket{1}$</td>\n      <td>\n        $S\\ket{0} = \\ket{0}$<br>\n        $S\\ket{1} = i\\ket{1}$<br>\n        $S\\ket{+} = \\ket{i}$<br>\n        $S\\ket{-} = \\ket{-i}$<br>\n        $S\\ket{i} = \\ket{-}$<br>\n        $S\\ket{-i} = \\ket{+}$<br>\n      </td>\n      </tr>\n    <tr>\n      <td>$T$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + e^{i\\pi/4}\\ket{1}$$\\bra{1}$</td>\n      <td>$T\\ket{\\psi} = \\alpha\\ket{0} + e^{i\\pi/4} \\beta \\ket{1}$</td>\n      <td>\n        $T\\ket{0} = \\ket{0}$<br>\n        $T\\ket{1} = e^{i\\pi/4}\\ket{1}$\n      </td>\n    </tr>\n  </table>\n</div>\n<blockquote>\n<p>Notice that applying the $T$ gate twice is equivalent to applying the $S$ gate, and applying the $S$ gate twice is equivalent to applying the $Z$ gate:\n$$T^2 = S, S^2 = Z$$</p>\n</blockquote>\n"
                         }
                     ]
                 },
@@ -1465,7 +1465,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>The next few gates are parametrized: their exact behavior depends on a numeric parameter - an angle $\\theta$, given in radians.\nThese gates are the $X$ rotation gate $R_x(\\theta)$, $Y$ rotation gate $R_y(\\theta)$, $Z$ rotation gate $R_z(\\theta)$, and the arbitrary phase gate $R_1(\\theta)$.\nNote that for the first three gates the parameter $\\theta$ is multiplied by $\\frac{1}{2}$ within the gate's matrix.</p>\n<blockquote>\n<p>These gates are known as rotation gates, because they represent rotations around various axes on the Bloch sphere. The Bloch sphere is a way of representing the qubit states visually, mapping them onto the surface of a sphere.\nUnfortunately, this visualization isn't very useful beyond single-qubit states, which is why this kata doesn't go into details.\nIf you're curious about it, you can learn more in <a href=\"https://en.wikipedia.org/wiki/Bloch_sphere\" target=\"_blank\">this Wikipedia article</a>.</p>\n</blockquote>\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n   </tr>\n  <tr>\n    <td>$R_x(\\theta)$</td>\n    <td>\n    $$\n    \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\ -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}\n    $$\n    </td>\n    <td>$R_x(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - i\\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} - i\\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n    <td>\n      $R_x(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} - i\\sin\\frac{\\theta}{2}\\ket{1}$<br>\n      $R_x(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - i\\sin\\frac{\\theta}{2}\\ket{0}$\n    </td>\n   </tr>\n  <tr>\n    <td>$R_y(\\theta)$</td>\n    <td>$\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}$</td>\n    <td>$R_y(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - \\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} + \\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n    <td>\n      $R_y(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} + \\sin\\frac{\\theta}{2}\\ket{1}$<br>\n      $R_y(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - \\sin\\frac{\\theta}{2}\\ket{0}$\n    </td>\n    </tr>\n  <tr>\n    <td>$R_z(\\theta)$</td>\n    <td>$\\begin{bmatrix} e^{-i\\theta/2} & 0 \\\\ 0 & e^{i\\theta/2} \\end{bmatrix}$</td>\n    <td>$R_z(\\theta)\\ket{\\psi} = \\alpha e^{-i\\theta/2}\\ket{0} + \\beta e^{i\\theta/2}\\ket{1}$</td>\n    <td>\n      $R_z(\\theta)\\ket{0} = e^{-i\\theta/2}\\ket{0}$<br>\n      $R_z(\\theta)\\ket{1} = e^{i\\theta/2}\\ket{1}$\n    </td>\n  </tr>\n  <tr>\n    <td>$R_1(\\theta)$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}$</td>\n    <td>$R_1(\\theta)\\ket{\\psi} = \\alpha\\ket{0} + \\beta e^{i\\theta}\\ket{1}$</td>\n    <td>\n      $R_1(\\theta)\\ket{0} = \\ket{0}$<br>\n      $R_1(\\theta)\\ket{1} = e^{i\\theta}\\ket{1}$\n    </td>  \n  </tr>\n</table>\n<p>You have already encountered some special cases of the $R_1$ gate:</p>\n<p>$$T = R_1(\\frac{\\pi}{4}), S = R_1(\\frac{\\pi}{2}), Z = R_1(\\pi)$$</p>\n<p>In addition, this gate is closely related to the $R_z$ gate: applying $R_1$ gate is equivalent to applying the $R_z$ gate, and then applying a global phase:</p>\n<p>$$R_1(\\theta) = e^{i\\theta/2}R_z(\\theta)$$</p>\n<p>In addition, the rotation gates are very closely related to their respective Pauli gates:</p>\n<p>$$X = iR_x(\\pi), Y = iR_y(\\pi), Z = iR_z(\\pi)$$</p>\n"
+                            "content": "<p>The next few gates are parametrized: their exact behavior depends on a numeric parameter - an angle $\\theta$, given in radians.\nThese gates are the $X$ rotation gate $R_x(\\theta)$, $Y$ rotation gate $R_y(\\theta)$, $Z$ rotation gate $R_z(\\theta)$, and the arbitrary phase gate $R_1(\\theta)$.\nNote that for the first three gates the parameter $\\theta$ is multiplied by $\\frac{1}{2}$ within the gate's matrix.</p>\n<blockquote>\n<p>These gates are known as rotation gates, because they represent rotations around various axes on the Bloch sphere. The Bloch sphere is a way of representing the qubit states visually, mapping them onto the surface of a sphere.\nUnfortunately, this visualization isn't very useful beyond single-qubit states, which is why this kata doesn't go into details.\nIf you're curious about it, you can learn more in <a href=\"https://en.wikipedia.org/wiki/Bloch_sphere\" target=\"_blank\">this Wikipedia article</a>.</p>\n</blockquote>\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n     </tr>\n    <tr>\n      <td>$R_x(\\theta)$</td>\n      <td>\n      $$\n      \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\ -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}\n      $$\n      </td>\n      <td>$R_x(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - i\\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} - i\\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n      <td>\n        $R_x(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} - i\\sin\\frac{\\theta}{2}\\ket{1}$<br>\n        $R_x(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - i\\sin\\frac{\\theta}{2}\\ket{0}$\n      </td>\n     </tr>\n    <tr>\n      <td>$R_y(\\theta)$</td>\n      <td>$\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}$</td>\n      <td>$R_y(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - \\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} + \\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n      <td>\n        $R_y(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} + \\sin\\frac{\\theta}{2}\\ket{1}$<br>\n        $R_y(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - \\sin\\frac{\\theta}{2}\\ket{0}$\n      </td>\n      </tr>\n    <tr>\n      <td>$R_z(\\theta)$</td>\n      <td>$\\begin{bmatrix} e^{-i\\theta/2} & 0 \\\\ 0 & e^{i\\theta/2} \\end{bmatrix}$</td>\n      <td>$R_z(\\theta)\\ket{\\psi} = \\alpha e^{-i\\theta/2}\\ket{0} + \\beta e^{i\\theta/2}\\ket{1}$</td>\n      <td>\n        $R_z(\\theta)\\ket{0} = e^{-i\\theta/2}\\ket{0}$<br>\n        $R_z(\\theta)\\ket{1} = e^{i\\theta/2}\\ket{1}$\n      </td>\n    </tr>\n    <tr>\n      <td>$R_1(\\theta)$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}$</td>\n      <td>$R_1(\\theta)\\ket{\\psi} = \\alpha\\ket{0} + \\beta e^{i\\theta}\\ket{1}$</td>\n      <td>\n        $R_1(\\theta)\\ket{0} = \\ket{0}$<br>\n        $R_1(\\theta)\\ket{1} = e^{i\\theta}\\ket{1}$\n      </td>  \n    </tr>\n  </table>\n</div>\n<p>You have already encountered some special cases of the $R_1$ gate:</p>\n<p>$$T = R_1(\\frac{\\pi}{4}), S = R_1(\\frac{\\pi}{2}), Z = R_1(\\pi)$$</p>\n<p>In addition, this gate is closely related to the $R_z$ gate: applying $R_1$ gate is equivalent to applying the $R_z$ gate, and then applying a global phase:</p>\n<p>$$R_1(\\theta) = e^{i\\theta/2}R_z(\\theta)$$</p>\n<p>In addition, the rotation gates are very closely related to their respective Pauli gates:</p>\n<p>$$X = iR_x(\\pi), Y = iR_y(\\pi), Z = iR_z(\\pi)$$</p>\n"
                         }
                     ]
                 },
@@ -6873,7 +6873,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>To wrap up the discussion in this kata, let's take a look at a problem solved using a similar approach - the Bernstein-Vazirani algorithm.\nIn this problem, you are also given an oracle implementing an $N$-bit function $f(x): \\{0, 1\\}^N \\to \\{0, 1\\}$.\nHowever, this time the function is guaranteed to be a <em>scalar product function</em>, that is, there exists an $N$-bit string $s$\nthat allows the following representation ($\\cdot$ is bitwise inner product of integers modulo $2$):</p>\n<p>$$f(x) = x \\cdot s = \\sum_{k=0}^{N-1} x_k s_k \\bmod 2$$</p>\n<p>The task is to recover the hidden bit string $s$.</p>\n<p><strong>Examples</strong></p>\n<ul>\n<li>$f(x) \\equiv 0$ is an example of such a function with $s = 0, \\dots, 0$.</li>\n<li>$f(x) = 1 \\text{ if x has odd number of 1s, and } 0 \\text{ otherwise }$ is another example of such a function, with $s = 1, \\dots, 1$.</li>\n</ul>\n<p>If you solve this problem classically, how many calls to the given function will you need?\nYou'd need to use one query to recover each bit of $s$ (the query for $k$-th bit can be a bit string with $1$ in the $k$-th bit and zeros in all other positions), for a total of $N$ queries.</p>\n<p>What about the quantum scenario?\nIt turns out that the algorithm that allows you to solve this problem looks just like Deutsch-Jozsa algorithm,\nexcept for the way you interpret the measurement results on the last step. To see this, you'll need to take another look\nat the math involved in applying Hadamard gates to multiple qubits.</p>\n<h3>Apply Hadamard transform to each qubit: a different view</h3>\n<p>When you apply an $H$ gate to a single qubit in the basis state $\\ket{x}$, you can write the result as the following sum:</p>\n<p>$$H\\ket{x} = \\frac1{\\sqrt2} (\\ket{0} + (-1)^{x} \\ket{1}) = \\frac1{\\sqrt2} \\sum_{z \\in {0, 1}} (-1)^{x \\cdot z} \\ket{z}$$</p>\n<p>If you use this representation to spell out the result of applying an $H$ gate to each qubit of an $N$-qubit basis state\n$\\ket{x} = \\ket{x_0}\\ket{x_1} \\dots \\ket{x_{N-1}}$, you get:</p>\n<p>$$H\\ket{x} = \\frac1{\\sqrt{2^N}} \\sum_{z_k \\in {0, 1}} (-1)^{x_0z_0 + \\dots + x_{N-1}z_{N-1}} \\ket{z_0}\\ket{z_1} \\dots \\ket{z_{N-1}} =$$</p>\n<p>$$= \\frac1{\\sqrt{2^N}} \\sum_{z = 0}^{2^N-1} (-1)^{x \\cdot z} \\ket{z}$$</p>\n<p>With this in mind, let's revisit the algorithm and see how you can write the exact quantum state after it.</p>\n<h3>Bernstein-Vazirani algorithm</h3>\n<p>Bernstein-Vazirani algorithm follows the same outline as Deutsch-Jozsa algorithm:</p>\n<ol>\n<li>Apply the $H$ gate to each qubit.</li>\n<li>Apply the oracle.</li>\n<li>Apply the $H$ gate to each qubit again.</li>\n<li>Measure all qubits.</li>\n</ol>\n<p>You know that after the second step the qubits end up in the following state:</p>\n<p>$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)} \\ket{x}$$</p>\n<p>Now, once you apply the Hadamard gates to each qubit, the system state becomes:</p>\n<p>$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} \\sum_{z=0}^{2^N-1} (-1)^{f(x) + x \\cdot z} \\ket{z}$$</p>\n<blockquote>\n<p>In Deutsch-Jozsa algorithm, you looked at the amplitude of the $\\ket{0}$ state in this expression, which was\n$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)}$.</p>\n</blockquote>\n<p>Now, let's take a look at the amplitude of the $\\ket{s}$ state - the state that encodes the hidden bit string you're looking for.\nThis amplitude is</p>\n<p>$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x) + x \\cdot s}$$</p>\n<p>Since $f(x) = x \\cdot s$, for all values of $x$ $f(x) + x \\cdot s = 2 x \\cdot s$, and $(-1)^{f(x) + x \\cdot s} = 1$.\nOverall the amplitude of $\\ket{s}$ is</p>\n<p>$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} 1 = \\frac{1}{\\sqrt{2^N}} 2^N = 1$$</p>\n<p>This means that the state after applying the Hadamard gates is just $\\ket{s}$, and measuring it gives you the bit string $s$!\nAnd, same as Deutsch-Jozsa algorithm, Bernstein-Vazirani algorithm takes only one oracle call.</p>\n"
+                            "content": "<p>To wrap up the discussion in this kata, let's take a look at a problem solved using a similar approach - the Bernstein-Vazirani algorithm.\nIn this problem, you are also given an oracle implementing an $N$-bit function $f(x): \\{0, 1\\}^N \\to \\{0, 1\\}$.\nHowever, this time the function is guaranteed to be a <em>scalar product function</em>, that is, there exists an $N$-bit string $s$\nthat allows the following representation ($\\cdot$ is bitwise inner product of integers modulo $2$):</p>\n<p>$$f(x) = x \\cdot s = \\sum_{k=0}^{N-1} x_k s_k \\bmod 2$$</p>\n<p>The task is to recover the hidden bit string $s$.</p>\n<p><strong>Examples</strong></p>\n<ul>\n<li>$f(x) \\equiv 0$ is an example of such a function with $s = 0, \\dots, 0$.</li>\n<li>$f(x) = 1 \\text{ if x has odd number of 1s, and } 0 \\text{ otherwise }$ is another example of such a function, with $s = 1, \\dots, 1$.</li>\n</ul>\n<p>If you solve this problem classically, how many calls to the given function will you need?\nYou'd need to use one query to recover each bit of $s$ (the query for $k$-th bit can be a bit string with $1$ in the $k$-th bit and zeros in all other positions), for a total of $N$ queries.</p>\n<p>What about the quantum scenario?\nIt turns out that the algorithm that allows you to solve this problem looks just like Deutsch-Jozsa algorithm,\nexcept for the way you interpret the measurement results on the last step. To see this, you'll need to take another look\nat the math involved in applying Hadamard gates to multiple qubits.</p>\n<h3>Apply Hadamard transform to each qubit: a different view</h3>\n<p>When you apply an $H$ gate to a single qubit in the basis state $\\ket{x}$, you can write the result as the following sum:</p>\n<p>$$H\\ket{x} = \\frac1{\\sqrt2} (\\ket{0} + (-1)^{x} \\ket{1}) = \\frac1{\\sqrt2} \\sum_{z \\in \\{0, 1\\}} (-1)^{x \\cdot z} \\ket{z}$$</p>\n<p>If you use this representation to spell out the result of applying an $H$ gate to each qubit of an $N$-qubit basis state\n$\\ket{x} = \\ket{x_0}\\ket{x_1} \\dots \\ket{x_{N-1}}$, you get:</p>\n<p>$$H\\ket{x} = \\frac1{\\sqrt{2^N}} \\sum_{z_k \\in {0, 1}} (-1)^{x_0z_0 + \\dots + x_{N-1}z_{N-1}} \\ket{z_0}\\ket{z_1} \\dots \\ket{z_{N-1}} =$$</p>\n<p>$$= \\frac1{\\sqrt{2^N}} \\sum_{z = 0}^{2^N-1} (-1)^{x \\cdot z} \\ket{z}$$</p>\n<p>With this in mind, let's revisit the algorithm and see how you can write the exact quantum state after it.</p>\n<h3>Bernstein-Vazirani algorithm</h3>\n<p>Bernstein-Vazirani algorithm follows the same outline as Deutsch-Jozsa algorithm:</p>\n<ol>\n<li>Apply the $H$ gate to each qubit.</li>\n<li>Apply the oracle.</li>\n<li>Apply the $H$ gate to each qubit again.</li>\n<li>Measure all qubits.</li>\n</ol>\n<p>You know that after the second step the qubits end up in the following state:</p>\n<p>$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)} \\ket{x}$$</p>\n<p>Now, once you apply the Hadamard gates to each qubit, the system state becomes:</p>\n<p>$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} \\sum_{z=0}^{2^N-1} (-1)^{f(x) + x \\cdot z} \\ket{z}$$</p>\n<blockquote>\n<p>In Deutsch-Jozsa algorithm, you looked at the amplitude of the $\\ket{0}$ state in this expression, which was\n$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} (-1)^{f(x)}$.</p>\n</blockquote>\n<p>Now, let's take a look at the amplitude of the $\\ket{s}$ state - the state that encodes the hidden bit string you're looking for.\nThis amplitude is</p>\n<p>$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} (-1)^{f(x) + x \\cdot s}$$</p>\n<p>Since $f(x) = x \\cdot s$, for all values of $x$ $f(x) + x \\cdot s = 2 x \\cdot s$, and $(-1)^{f(x) + x \\cdot s} = 1$.\nOverall the amplitude of $\\ket{s}$ is</p>\n<p>$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} 1 = \\frac{1}{2^N} 2^N = 1$$</p>\n<p>This means that the state after applying the Hadamard gates is just $\\ket{s}$, and measuring it gives you the bit string $s$!\nAnd, same as Deutsch-Jozsa algorithm, Bernstein-Vazirani algorithm takes only one oracle call.</p>\n"
                         }
                     ]
                 },

package/dist/katas-content.generated.md.js

@@ -1094,7 +1094,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThere is another way to represent quantum gates, this time using Dirac notation. However, kets aren't enough to represent arbitrary matrices. An additional notation is required: the **bra** (this is why Dirac notation is sometimes called **bra-ket notation**).\n\nRecall that kets represent column vectors; a bra is a ket's row vector counterpart. For any ket $\\ket{\\psi}$, the corresponding bra is its adjoint (conjugate transpose): $\\bra{\\psi} = \\ket{\\psi}^\\dagger$.\n\nSome examples:\n\n<table>\n  <tr>\n    <th>Ket</th>\n    <th>Bra</th>\n  </tr>\n  <tr>\n    <td>$\\ket{0} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n    <td>$\\bra{0} = \\begin{bmatrix} 1 & 0 \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{1} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n    <td>$\\bra{1} = \\begin{bmatrix} 0 & 1 \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n    <td>$\\bra{ i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} & -\\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{\\psi} = \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$</td>\n    <td>$\\bra{\\psi} = \\begin{bmatrix} \\overline{\\alpha} & \\overline{\\beta} \\end{bmatrix}$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</td>\n    <td>$\\bra{\\psi} = \\overline{\\alpha}\\bra{0} + \\overline{\\beta}\\bra{1}$</td>\n  </tr>\n</table>\n\nKets and bras give us a neat way to express inner and outer products. The inner product of $\\ket{\\phi}$ and $\\ket{\\psi}$ is the matrix product of $\\bra{\\phi}$ and $\\ket{\\psi}$, denoted as $\\braket{\\phi|\\psi}$, and their outer product is the matrix product of $\\ket{\\phi}$ and $\\bra{\\psi}$, denoted as $\\ket{\\phi}\\bra{\\psi}$. Notice that the norm of $\\ket{\\psi}$ is $\\sqrt{\\braket{\\psi|\\psi}}$.\n\nThis leads to the representation of matrices via outer products. Recall that the outer product of two vectors of the same size produces a square matrix. You can use a linear combination of several outer products of simple vectors (such as basis vectors) to express any square matrix. For example, the $X$ gate can be expressed as follows:\n\n$$X = \\ket{0}\\bra{1} + \\ket{1}\\bra{0}$$\n\n$$\n\\ket{0}\\bra{1} + \\ket{1}\\bra{0} =\n\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}\\begin{bmatrix} 0 & 1 \\end{bmatrix} +\n\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\\begin{bmatrix} 1 & 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 & 1 \\\\ 0 & 0 \\end{bmatrix} + \\begin{bmatrix} 0 & 0 \\\\ 1 & 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\n$$\n\nThis representation can be used to carry out calculations in Dirac notation without ever switching back to matrix representation:\n\n$$X\\ket{0} = \\big(\\ket{0}\\bra{1} + \\ket{1}\\bra{0}\\big)\\ket{0} = \\ket{0}\\braket{1|0} + \\ket{1}\\braket{0|0} = \\ket{0}\\big(\\braket{1|0}\\big) + \\ket{1}\\big(\\braket{0|0}\\big) = \\ket{0}(0) + \\ket{1}(1) = \\ket{1}$$\n\n> That last step may seem a bit confusing. Recall that $\\ket{0}$ and $\\ket{1}$ form an **orthonormal basis**. That is, they're both normalized, and they're orthogonal to each other.\n>\n> A vector is normalized if its norm is equal to $1$, which only happens if its inner product with itself is equal to $1$. This means that $\\braket{0|0} = \\braket{1|1} = 1$\n>\n> Two vectors are orthogonal to each other if their inner product equals $0$. This means that $\\braket{0|1} = \\braket{1|0} = 0$.\n\nIn general case, a matrix\n$$A = \\begin{bmatrix} a_{00} & a_{01} \\\\ a_{10} & a_{11} \\end{bmatrix}$$\nwill have the following ket-bra representation:\n$$A = a_{00} \\ket{0}\\bra{0} + a_{01} \\ket{0}\\bra{1} + a_{10} \\ket{1}\\bra{0} + a_{11} \\ket{1}\\bra{1}$$"
+                            "content": "\nThere is another way to represent quantum gates, this time using Dirac notation. However, kets aren't enough to represent arbitrary matrices. An additional notation is required: the **bra** (this is why Dirac notation is sometimes called **bra-ket notation**).\n\nRecall that kets represent column vectors; a bra is a ket's row vector counterpart. For any ket $\\ket{\\psi}$, the corresponding bra is its adjoint (conjugate transpose): $\\bra{\\psi} = \\ket{\\psi}^\\dagger$.\n\nSome examples:\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Ket</th>\n      <th>Bra</th>\n    </tr>\n    <tr>\n      <td>$\\ket{0} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n      <td>$\\bra{0} = \\begin{bmatrix} 1 & 0 \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{1} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n      <td>$\\bra{1} = \\begin{bmatrix} 0 & 1 \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n      <td>$\\bra{ i} = \\begin{bmatrix} \\frac{1}{\\sqrt{2}} & -\\frac{i}{\\sqrt{2}} \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{\\psi} = \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$</td>\n      <td>$\\bra{\\psi} = \\begin{bmatrix} \\overline{\\alpha} & \\overline{\\beta} \\end{bmatrix}$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</td>\n      <td>$\\bra{\\psi} = \\overline{\\alpha}\\bra{0} + \\overline{\\beta}\\bra{1}$</td>\n    </tr>\n  </table>\n</div>\n\nKets and bras give us a neat way to express inner and outer products. The inner product of $\\ket{\\phi}$ and $\\ket{\\psi}$ is the matrix product of $\\bra{\\phi}$ and $\\ket{\\psi}$, denoted as $\\braket{\\phi|\\psi}$, and their outer product is the matrix product of $\\ket{\\phi}$ and $\\bra{\\psi}$, denoted as $\\ket{\\phi}\\bra{\\psi}$. Notice that the norm of $\\ket{\\psi}$ is $\\sqrt{\\braket{\\psi|\\psi}}$.\n\nThis leads to the representation of matrices via outer products. Recall that the outer product of two vectors of the same size produces a square matrix. You can use a linear combination of several outer products of simple vectors (such as basis vectors) to express any square matrix. For example, the $X$ gate can be expressed as follows:\n\n$$X = \\ket{0}\\bra{1} + \\ket{1}\\bra{0}$$\n\n$$\n\\ket{0}\\bra{1} + \\ket{1}\\bra{0} =\n\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}\\begin{bmatrix} 0 & 1 \\end{bmatrix} +\n\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\\begin{bmatrix} 1 & 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 & 1 \\\\ 0 & 0 \\end{bmatrix} + \\begin{bmatrix} 0 & 0 \\\\ 1 & 0 \\end{bmatrix} =\n\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\n$$\n\nThis representation can be used to carry out calculations in Dirac notation without ever switching back to matrix representation:\n\n$$X\\ket{0} = \\big(\\ket{0}\\bra{1} + \\ket{1}\\bra{0}\\big)\\ket{0} = \\ket{0}\\braket{1|0} + \\ket{1}\\braket{0|0} = \\ket{0}\\big(\\braket{1|0}\\big) + \\ket{1}\\big(\\braket{0|0}\\big) = \\ket{0}(0) + \\ket{1}(1) = \\ket{1}$$\n\n> That last step may seem a bit confusing. Recall that $\\ket{0}$ and $\\ket{1}$ form an **orthonormal basis**. That is, they're both normalized, and they're orthogonal to each other.\n>\n> A vector is normalized if its norm is equal to $1$, which only happens if its inner product with itself is equal to $1$. This means that $\\braket{0|0} = \\braket{1|1} = 1$\n>\n> Two vectors are orthogonal to each other if their inner product equals $0$. This means that $\\braket{0|1} = \\braket{1|0} = 0$.\n\nIn general case, a matrix\n$$A = \\begin{bmatrix} a_{00} & a_{01} \\\\ a_{10} & a_{11} \\end{bmatrix}$$\nwill have the following ket-bra representation:\n$$A = a_{00} \\ket{0}\\bra{0} + a_{01} \\ket{0}\\bra{1} + a_{10} \\ket{1}\\bra{0} + a_{11} \\ket{1}\\bra{1}$$"
                         }
                     ]
                 },
@@ -1116,7 +1116,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThis section introduces some of the common single-qubit gates, including their matrix form, their ket-bra decomposition, and a brief \"cheat sheet\" listing their effect on some common qubit states.\n\nYou can use a tool called <a href=\"https://algassert.com/quirk\" target=\"_blank\">Quirk</a> to visualize how these gates interact with various qubit states.\n\nThis section relies on the following notation:\n\n<table>\n  <tr>\n    <td>$\\ket{+} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + \\ket{1}\\big)$</td>\n    <td>$\\ket{-} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - \\ket{1}\\big)$</td>\n  </tr>\n  <tr>\n    <td>$\\ket{i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + i\\ket{1}\\big)$</td>\n    <td>$\\ket{-i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - i\\ket{1}\\big)$</td>\n  </tr>\n</table>\n\nThe Pauli gates, named after <a href=\"https://en.wikipedia.org/wiki/Wolfgang_Pauli\" target=\"_blank\">Wolfgang Pauli</a>, are based on the so-called **Pauli matrices**, $X$, $Y$ and $Z$. All three Pauli gates are **self-adjoint**, meaning that each one is its own inverse, $XX = \\mathbb{I}$.\n\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Ket-Bra</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n  </tr>\n  <tr>\n    <td>$X$</td>\n    <td>$\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{1} + \\ket{1}\\bra{0}$</td>\n    <td>$X\\ket{\\psi} = \\alpha\\ket{1} + \\beta\\ket{0}$</td>\n    <td>\n      $X\\ket{0} = \\ket{1}$<br>\n      $X\\ket{1} = \\ket{0}$<br>\n      $X\\ket{+} = \\ket{+}$<br>\n      $X\\ket{-} = -\\ket{-}$<br>\n      $X\\ket{i} = i\\ket{-i}$<br>\n      $X\\ket{-i} = -i\\ket{i}$\n    </td>\n  </tr>\n  <tr>\n    <td>$Y$</td>\n    <td>$\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$</td>\n    <td>$i(\\ket{1}\\bra{0} - \\ket{0}\\bra{1})$</td>\n    <td>$Y\\ket{\\psi} = i\\big(\\alpha\\ket{1} - \\beta\\ket{0}\\big)$</td>\n    <td>\n      $Y\\ket{0} = i\\ket{1}$<br>\n      $Y\\ket{1} = -i\\ket{0}$<br>\n      $Y\\ket{+} = -i\\ket{-}$<br>\n      $Y\\ket{-} = i\\ket{+}$<br>\n      $Y\\ket{i} = \\ket{i}$<br>\n      $Y\\ket{-i} = -\\ket{-i}$<br>\n    </td>\n  </tr>\n  <tr>\n    <td>$Z$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} - \\ket{1}\\bra{1}$</td>\n    <td>$Z\\ket{\\psi} = \\alpha\\ket{0} - \\beta\\ket{1}$</td>\n    <td>\n      $Z\\ket{0} = \\ket{0}$<br>\n      $Z\\ket{1} = -\\ket{1}$<br>\n      $Z\\ket{+} = \\ket{-}$<br>\n      $Z\\ket{-} = \\ket{+}$<br>\n      $Z\\ket{i} = \\ket{-i}$<br>\n      $Z\\ket{-i} = \\ket{i}$<br>\n    </td>\n  </tr>\n</table>\n\n> The $X$ gate is sometimes referred to as the **bit flip** gate, or the **NOT** gate, because it acts like the classical NOT gate on the computational basis.\n>\n> The $Z$ gate is sometimes referred to as the **phase flip** gate.\n\nHere are several properties of the Pauli gates that are easy to verify and convenient to remember:\n\n- Different Pauli gates _anti-commute_:\n  $$XZ = -ZX, XY = -YX, YZ = -ZY$$\n- A product of any two Pauli gates equals the third gate, with an extra $i$ (or $-i$) phase:\n  $$XY = iZ, YZ = iX, ZX = iY$$\n- A product of all three Pauli gates equals identity (with an extra $i$ phase):\n  $$XYZ = iI$$"
+                            "content": "\nThis section introduces some of the common single-qubit gates, including their matrix form, their ket-bra decomposition, and a brief \"cheat sheet\" listing their effect on some common qubit states.\n\nYou can use a tool called <a href=\"https://algassert.com/quirk\" target=\"_blank\">Quirk</a> to visualize how these gates interact with various qubit states.\n\nThis section relies on the following notation:\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <td>$\\ket{+} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + \\ket{1}\\big)$</td>\n      <td>$\\ket{-} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - \\ket{1}\\big)$</td>\n    </tr>\n    <tr>\n      <td>$\\ket{i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} + i\\ket{1}\\big)$</td>\n      <td>$\\ket{-i} = \\frac{1}{\\sqrt{2}}\\big(\\ket{0} - i\\ket{1}\\big)$</td>\n    </tr>\n  </table>\n</div>\n\nThe Pauli gates, named after <a href=\"https://en.wikipedia.org/wiki/Wolfgang_Pauli\" target=\"_blank\">Wolfgang Pauli</a>, are based on the so-called **Pauli matrices**, $X$, $Y$ and $Z$. All three Pauli gates are **self-adjoint**, meaning that each one is its own inverse, $XX = \\mathbb{I}$.\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n    </tr>\n    <tr>\n      <td>$X$</td>\n      <td>$\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{1} + \\ket{1}\\bra{0}$</td>\n      <td>$X\\ket{\\psi} = \\alpha\\ket{1} + \\beta\\ket{0}$</td>\n      <td>\n        $X\\ket{0} = \\ket{1}$<br>\n        $X\\ket{1} = \\ket{0}$<br>\n        $X\\ket{+} = \\ket{+}$<br>\n        $X\\ket{-} = -\\ket{-}$<br>\n        $X\\ket{i} = i\\ket{-i}$<br>\n        $X\\ket{-i} = -i\\ket{i}$\n      </td>\n    </tr>\n    <tr>\n      <td>$Y$</td>\n      <td>$\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$</td>\n      <td>$i(\\ket{1}\\bra{0} - \\ket{0}\\bra{1})$</td>\n      <td>$Y\\ket{\\psi} = i\\big(\\alpha\\ket{1} - \\beta\\ket{0}\\big)$</td>\n      <td>\n        $Y\\ket{0} = i\\ket{1}$<br>\n        $Y\\ket{1} = -i\\ket{0}$<br>\n        $Y\\ket{+} = -i\\ket{-}$<br>\n        $Y\\ket{-} = i\\ket{+}$<br>\n        $Y\\ket{i} = \\ket{i}$<br>\n        $Y\\ket{-i} = -\\ket{-i}$<br>\n      </td>\n    </tr>\n    <tr>\n      <td>$Z$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} - \\ket{1}\\bra{1}$</td>\n      <td>$Z\\ket{\\psi} = \\alpha\\ket{0} - \\beta\\ket{1}$</td>\n      <td>\n        $Z\\ket{0} = \\ket{0}$<br>\n        $Z\\ket{1} = -\\ket{1}$<br>\n        $Z\\ket{+} = \\ket{-}$<br>\n        $Z\\ket{-} = \\ket{+}$<br>\n        $Z\\ket{i} = \\ket{-i}$<br>\n        $Z\\ket{-i} = \\ket{i}$<br>\n      </td>\n    </tr>\n  </table>\n</div>\n\n> The $X$ gate is sometimes referred to as the **bit flip** gate, or the **NOT** gate, because it acts like the classical NOT gate on the computational basis.\n>\n> The $Z$ gate is sometimes referred to as the **phase flip** gate.\n\nHere are several properties of the Pauli gates that are easy to verify and convenient to remember:\n\n- Different Pauli gates _anti-commute_:\n  $$XZ = -ZX, XY = -YX, YZ = -ZY$$\n- A product of any two Pauli gates equals the third gate, with an extra $i$ (or $-i$) phase:\n  $$XY = iZ, YZ = iX, ZX = iY$$\n- A product of all three Pauli gates equals identity (with an extra $i$ phase):\n  $$XYZ = iI$$"
                         }
                     ]
                 },
@@ -1311,7 +1311,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThe identity gate is mostly here for completeness, at least for now. It will come in handy when dealing with multi-qubit systems and multi-qubit gates. It's represented by the identity matrix, and doesn't affect the state of the qubit.\n\n<table>\n<tr>\n<th>Gate</th>\n<th>Matrix</th>\n<th>Ket-Bra</th>\n<th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n</tr>\n<tr>\n<td>$I$</td>\n<td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n<td>$\\ket{0}\\bra{0} + \\ket{1}\\bra{1}$</td>\n<td>$I\\ket{\\psi} = \\ket{\\psi}$</td>\n</tr>\n</table>"
+                            "content": "\nThe identity gate is mostly here for completeness, at least for now. It will come in handy when dealing with multi-qubit systems and multi-qubit gates. It's represented by the identity matrix, and doesn't affect the state of the qubit.\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    </tr>\n    <tr>\n      <td>$I$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + \\ket{1}\\bra{1}$</td>\n      <td>$I\\ket{\\psi} = \\ket{\\psi}$</td>\n    </tr>\n  </table>\n</div>"
                         }
                     ]
                 },
@@ -1322,7 +1322,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThe **Hadamard** gate is an extremely important quantum gate. Unlike the previous gates, applying the Hadamard gate to a qubit in a computational basis state puts that qubit into a superposition.\nLike the Pauli gates, the Hadamard gate is self-adjoint.\n\n<table>\n<tr>\n<th>Gate</th>\n<th>Matrix</th>\n<th>Ket-Bra</th>\n<th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n<th>Applying to basis states</th>\n</tr>\n<tr>\n<td>$H$</td>\n<td>$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}} \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}$</td>\n<td>$\\ket{0}\\bra{+} + \\ket{1}\\bra{-}$</td>\n<td>$H\\ket{\\psi} = \\alpha\\ket{+} + \\beta\\ket{-} = \\frac{\\alpha + \\beta}{\\sqrt{2}}\\ket{0} + \\frac{\\alpha - \\beta}{\\sqrt{2}}\\ket{1}$</td>\n<td>$H\\ket{0} = \\ket{+}$ <br>\n$H\\ket{1} = \\ket{-}$ <br>\n$H\\ket{+} = \\ket{0}$ <br>\n$H\\ket{-} = \\ket{1}$ <br>\n$H\\ket{i} = e^{i\\pi/4}\\ket{-i}$ <br>\n$H\\ket{-i} = e^{-i\\pi/4}\\ket{i} $ <br>\n</tr>\n</table>\n\n> As a reminder, $e^{i\\pi/4} = \\frac{1}{\\sqrt2} (1 + i)$ and $e^{-i\\pi/4} = \\frac{1}{\\sqrt2} (1 - i)$. This is an application of Euler's formula, $e^{i\\theta} = \\cos \\theta + i\\sin \\theta$, where $\\theta$ is measured in radians.\n> See this [Wikipedia article](https://en.wikipedia.org/wiki/Euler%27s_formula) for an explanation of Euler's formula and/or [this video](https://youtu.be/v0YEaeIClKY) for a more intuitive explanation."
+                            "content": "\nThe **Hadamard** gate is an extremely important quantum gate. Unlike the previous gates, applying the Hadamard gate to a qubit in a computational basis state puts that qubit into a superposition.\nLike the Pauli gates, the Hadamard gate is self-adjoint.\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n    </tr>\n    <tr>\n      <td>$H$</td>\n      <td>$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}} \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{+} + \\ket{1}\\bra{-}$</td>\n      <td>$H\\ket{\\psi} = \\alpha\\ket{+} + \\beta\\ket{-} = \\frac{\\alpha + \\beta}{\\sqrt{2}}\\ket{0} + \\frac{\\alpha - \\beta}{\\sqrt{2}}\\ket{1}$</td>\n      <td>$H\\ket{0} = \\ket{+}$ <br>\n      $H\\ket{1} = \\ket{-}$ <br>\n      $H\\ket{+} = \\ket{0}$ <br>\n      $H\\ket{-} = \\ket{1}$ <br>\n      $H\\ket{i} = e^{i\\pi/4}\\ket{-i}$ <br>\n      $H\\ket{-i} = e^{-i\\pi/4}\\ket{i} $ <br>\n    </tr>\n  </table>\n</div>\n\n> As a reminder, $e^{i\\pi/4} = \\frac{1}{\\sqrt2} (1 + i)$ and $e^{-i\\pi/4} = \\frac{1}{\\sqrt2} (1 - i)$. This is an application of Euler's formula, $e^{i\\theta} = \\cos \\theta + i\\sin \\theta$, where $\\theta$ is measured in radians.\n> See this [Wikipedia article](https://en.wikipedia.org/wiki/Euler%27s_formula) for an explanation of Euler's formula and/or [this video](https://youtu.be/v0YEaeIClKY) for a more intuitive explanation."
                         }
                     ]
                 },
@@ -1389,7 +1389,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThe next two gates are known as **phase shift gates**. They apply a phase to the $\\ket{1}$ state, and leave the $\\ket{0}$ state unchanged.\n\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Ket-Bra</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n    </tr>\n  <tr>\n    <td>$S$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} + i\\ket{1}\\bra{1}$</td>\n    <td>$S\\ket{\\psi} = \\alpha\\ket{0} + i\\beta\\ket{1}$</td>\n    <td>\n      $S\\ket{0} = \\ket{0}$<br>\n      $S\\ket{1} = i\\ket{1}$<br>\n      $S\\ket{+} = \\ket{i}$<br>\n      $S\\ket{-} = \\ket{-i}$<br>\n      $S\\ket{i} = \\ket{-}$<br>\n      $S\\ket{-i} = \\ket{+}$<br>\n    </td>\n    </tr>\n  <tr>\n    <td>$T$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{bmatrix}$</td>\n    <td>$\\ket{0}\\bra{0} + e^{i\\pi/4}\\ket{1}$$\\bra{1}$</td>\n    <td>$T\\ket{\\psi} = \\alpha\\ket{0} + e^{i\\pi/4} \\beta \\ket{1}$</td>\n    <td>\n      $T\\ket{0} = \\ket{0}$<br>\n      $T\\ket{1} = e^{i\\pi/4}\\ket{1}$\n    </td>\n  </tr>\n</table>\n\n> Notice that applying the $T$ gate twice is equivalent to applying the $S$ gate, and applying the $S$ gate twice is equivalent to applying the $Z$ gate:\n$$T^2 = S, S^2 = Z$$"
+                            "content": "\nThe next two gates are known as **phase shift gates**. They apply a phase to the $\\ket{1}$ state, and leave the $\\ket{0}$ state unchanged.\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Ket-Bra</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n      </tr>\n    <tr>\n      <td>$S$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + i\\ket{1}\\bra{1}$</td>\n      <td>$S\\ket{\\psi} = \\alpha\\ket{0} + i\\beta\\ket{1}$</td>\n      <td>\n        $S\\ket{0} = \\ket{0}$<br>\n        $S\\ket{1} = i\\ket{1}$<br>\n        $S\\ket{+} = \\ket{i}$<br>\n        $S\\ket{-} = \\ket{-i}$<br>\n        $S\\ket{i} = \\ket{-}$<br>\n        $S\\ket{-i} = \\ket{+}$<br>\n      </td>\n      </tr>\n    <tr>\n      <td>$T$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{bmatrix}$</td>\n      <td>$\\ket{0}\\bra{0} + e^{i\\pi/4}\\ket{1}$$\\bra{1}$</td>\n      <td>$T\\ket{\\psi} = \\alpha\\ket{0} + e^{i\\pi/4} \\beta \\ket{1}$</td>\n      <td>\n        $T\\ket{0} = \\ket{0}$<br>\n        $T\\ket{1} = e^{i\\pi/4}\\ket{1}$\n      </td>\n    </tr>\n  </table>\n</div>\n\n> Notice that applying the $T$ gate twice is equivalent to applying the $S$ gate, and applying the $S$ gate twice is equivalent to applying the $Z$ gate:\n$$T^2 = S, S^2 = Z$$"
                         }
                     ]
                 },
@@ -1465,7 +1465,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nThe next few gates are parametrized: their exact behavior depends on a numeric parameter - an angle $\\theta$, given in radians.\nThese gates are the $X$ rotation gate $R_x(\\theta)$, $Y$ rotation gate $R_y(\\theta)$, $Z$ rotation gate $R_z(\\theta)$, and the arbitrary phase gate $R_1(\\theta)$.\nNote that for the first three gates the parameter $\\theta$ is multiplied by $\\frac{1}{2}$ within the gate's matrix.\n\n> These gates are known as rotation gates, because they represent rotations around various axes on the Bloch sphere. The Bloch sphere is a way of representing the qubit states visually, mapping them onto the surface of a sphere.\n> Unfortunately, this visualization isn't very useful beyond single-qubit states, which is why this kata doesn't go into details.\n> If you're curious about it, you can learn more in <a href=\"https://en.wikipedia.org/wiki/Bloch_sphere\" target=\"_blank\">this Wikipedia article</a>.\n\n<table>\n  <tr>\n    <th>Gate</th>\n    <th>Matrix</th>\n    <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n    <th>Applying to basis states</th>\n   </tr>\n  <tr>\n    <td>$R_x(\\theta)$</td>\n    <td>\n    $$\n    \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\ -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}\n    $$\n    </td>\n    <td>$R_x(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - i\\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} - i\\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n    <td>\n      $R_x(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} - i\\sin\\frac{\\theta}{2}\\ket{1}$<br>\n      $R_x(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - i\\sin\\frac{\\theta}{2}\\ket{0}$\n    </td>\n   </tr>\n  <tr>\n    <td>$R_y(\\theta)$</td>\n    <td>$\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}$</td>\n    <td>$R_y(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - \\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} + \\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n    <td>\n      $R_y(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} + \\sin\\frac{\\theta}{2}\\ket{1}$<br>\n      $R_y(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - \\sin\\frac{\\theta}{2}\\ket{0}$\n    </td>\n    </tr>\n  <tr>\n    <td>$R_z(\\theta)$</td>\n    <td>$\\begin{bmatrix} e^{-i\\theta/2} & 0 \\\\ 0 & e^{i\\theta/2} \\end{bmatrix}$</td>\n    <td>$R_z(\\theta)\\ket{\\psi} = \\alpha e^{-i\\theta/2}\\ket{0} + \\beta e^{i\\theta/2}\\ket{1}$</td>\n    <td>\n      $R_z(\\theta)\\ket{0} = e^{-i\\theta/2}\\ket{0}$<br>\n      $R_z(\\theta)\\ket{1} = e^{i\\theta/2}\\ket{1}$\n    </td>\n  </tr>\n  <tr>\n    <td>$R_1(\\theta)$</td>\n    <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}$</td>\n    <td>$R_1(\\theta)\\ket{\\psi} = \\alpha\\ket{0} + \\beta e^{i\\theta}\\ket{1}$</td>\n    <td>\n      $R_1(\\theta)\\ket{0} = \\ket{0}$<br>\n      $R_1(\\theta)\\ket{1} = e^{i\\theta}\\ket{1}$\n    </td>  \n  </tr>\n</table>\n\nYou have already encountered some special cases of the $R_1$ gate:\n\n$$T = R_1(\\frac{\\pi}{4}), S = R_1(\\frac{\\pi}{2}), Z = R_1(\\pi)$$\n\nIn addition, this gate is closely related to the $R_z$ gate: applying $R_1$ gate is equivalent to applying the $R_z$ gate, and then applying a global phase:\n\n$$R_1(\\theta) = e^{i\\theta/2}R_z(\\theta)$$\n\nIn addition, the rotation gates are very closely related to their respective Pauli gates:\n\n$$X = iR_x(\\pi), Y = iR_y(\\pi), Z = iR_z(\\pi)$$"
+                            "content": "\nThe next few gates are parametrized: their exact behavior depends on a numeric parameter - an angle $\\theta$, given in radians.\nThese gates are the $X$ rotation gate $R_x(\\theta)$, $Y$ rotation gate $R_y(\\theta)$, $Z$ rotation gate $R_z(\\theta)$, and the arbitrary phase gate $R_1(\\theta)$.\nNote that for the first three gates the parameter $\\theta$ is multiplied by $\\frac{1}{2}$ within the gate's matrix.\n\n> These gates are known as rotation gates, because they represent rotations around various axes on the Bloch sphere. The Bloch sphere is a way of representing the qubit states visually, mapping them onto the surface of a sphere.\n> Unfortunately, this visualization isn't very useful beyond single-qubit states, which is why this kata doesn't go into details.\n> If you're curious about it, you can learn more in <a href=\"https://en.wikipedia.org/wiki/Bloch_sphere\" target=\"_blank\">this Wikipedia article</a>.\n\n<div class=\"table-with-latex\">\n  <table>\n    <tr>\n      <th>Gate</th>\n      <th>Matrix</th>\n      <th>Applying to $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$</th>\n      <th>Applying to basis states</th>\n     </tr>\n    <tr>\n      <td>$R_x(\\theta)$</td>\n      <td>\n      $$\n      \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\ -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}\n      $$\n      </td>\n      <td>$R_x(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - i\\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} - i\\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n      <td>\n        $R_x(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} - i\\sin\\frac{\\theta}{2}\\ket{1}$<br>\n        $R_x(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - i\\sin\\frac{\\theta}{2}\\ket{0}$\n      </td>\n     </tr>\n    <tr>\n      <td>$R_y(\\theta)$</td>\n      <td>$\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}$</td>\n      <td>$R_y(\\theta)\\ket{\\psi} = (\\alpha\\cos\\frac{\\theta}{2} - \\beta\\sin\\frac{\\theta}{2})\\ket{0} + (\\beta\\cos\\frac{\\theta}{2} + \\alpha\\sin\\frac{\\theta}{2})\\ket{1}$</td>\n      <td>\n        $R_y(\\theta)\\ket{0} = \\cos\\frac{\\theta}{2}\\ket{0} + \\sin\\frac{\\theta}{2}\\ket{1}$<br>\n        $R_y(\\theta)\\ket{1} = \\cos\\frac{\\theta}{2}\\ket{1} - \\sin\\frac{\\theta}{2}\\ket{0}$\n      </td>\n      </tr>\n    <tr>\n      <td>$R_z(\\theta)$</td>\n      <td>$\\begin{bmatrix} e^{-i\\theta/2} & 0 \\\\ 0 & e^{i\\theta/2} \\end{bmatrix}$</td>\n      <td>$R_z(\\theta)\\ket{\\psi} = \\alpha e^{-i\\theta/2}\\ket{0} + \\beta e^{i\\theta/2}\\ket{1}$</td>\n      <td>\n        $R_z(\\theta)\\ket{0} = e^{-i\\theta/2}\\ket{0}$<br>\n        $R_z(\\theta)\\ket{1} = e^{i\\theta/2}\\ket{1}$\n      </td>\n    </tr>\n    <tr>\n      <td>$R_1(\\theta)$</td>\n      <td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}$</td>\n      <td>$R_1(\\theta)\\ket{\\psi} = \\alpha\\ket{0} + \\beta e^{i\\theta}\\ket{1}$</td>\n      <td>\n        $R_1(\\theta)\\ket{0} = \\ket{0}$<br>\n        $R_1(\\theta)\\ket{1} = e^{i\\theta}\\ket{1}$\n      </td>  \n    </tr>\n  </table>\n</div>\n\nYou have already encountered some special cases of the $R_1$ gate:\n\n$$T = R_1(\\frac{\\pi}{4}), S = R_1(\\frac{\\pi}{2}), Z = R_1(\\pi)$$\n\nIn addition, this gate is closely related to the $R_z$ gate: applying $R_1$ gate is equivalent to applying the $R_z$ gate, and then applying a global phase:\n\n$$R_1(\\theta) = e^{i\\theta/2}R_z(\\theta)$$\n\nIn addition, the rotation gates are very closely related to their respective Pauli gates:\n\n$$X = iR_x(\\pi), Y = iR_y(\\pi), Z = iR_z(\\pi)$$"
                         }
                     ]
                 },
@@ -6873,7 +6873,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nTo wrap up the discussion in this kata, let's take a look at a problem solved using a similar approach - the Bernstein-Vazirani algorithm.\nIn this problem, you are also given an oracle implementing an $N$-bit function $f(x): \\{0, 1\\}^N \\to \\{0, 1\\}$.\nHowever, this time the function is guaranteed to be a *scalar product function*, that is, there exists an $N$-bit string $s$\nthat allows the following representation ($\\cdot$ is bitwise inner product of integers modulo $2$):\n\n$$f(x) = x \\cdot s = \\sum_{k=0}^{N-1} x_k s_k \\bmod 2$$\n\nThe task is to recover the hidden bit string $s$.\n\n**Examples**\n\n- $f(x) \\equiv 0$ is an example of such a function with $s = 0, \\dots, 0$.\n- $f(x) = 1 \\text{ if x has odd number of 1s, and } 0 \\text{ otherwise }$ is another example of such a function, with $s = 1, \\dots, 1$.\n\nIf you solve this problem classically, how many calls to the given function will you need? \nYou'd need to use one query to recover each bit of $s$ (the query for $k$-th bit can be a bit string with $1$ in the $k$-th bit and zeros in all other positions), for a total of $N$ queries.\n\nWhat about the quantum scenario?\nIt turns out that the algorithm that allows you to solve this problem looks just like Deutsch-Jozsa algorithm, \nexcept for the way you interpret the measurement results on the last step. To see this, you'll need to take another look \nat the math involved in applying Hadamard gates to multiple qubits.\n\n### Apply Hadamard transform to each qubit: a different view\n\nWhen you apply an $H$ gate to a single qubit in the basis state $\\ket{x}$, you can write the result as the following sum:\n\n$$H\\ket{x} = \\frac1{\\sqrt2} (\\ket{0} + (-1)^{x} \\ket{1}) = \\frac1{\\sqrt2} \\sum_{z \\in {0, 1}} (-1)^{x \\cdot z} \\ket{z}$$\n\nIf you use this representation to spell out the result of applying an $H$ gate to each qubit of an $N$-qubit basis state \n$\\ket{x} = \\ket{x_0}\\ket{x_1} \\dots \\ket{x_{N-1}}$, you get:\n\n$$H\\ket{x} = \\frac1{\\sqrt{2^N}} \\sum_{z_k \\in {0, 1}} (-1)^{x_0z_0 + \\dots + x_{N-1}z_{N-1}} \\ket{z_0}\\ket{z_1} \\dots \\ket{z_{N-1}} =$$\n\n$$= \\frac1{\\sqrt{2^N}} \\sum_{z = 0}^{2^N-1} (-1)^{x \\cdot z} \\ket{z}$$\n\nWith this in mind, let's revisit the algorithm and see how you can write the exact quantum state after it.\n\n### Bernstein-Vazirani algorithm\n\nBernstein-Vazirani algorithm follows the same outline as Deutsch-Jozsa algorithm:\n\n1. Apply the $H$ gate to each qubit.\n2. Apply the oracle.\n3. Apply the $H$ gate to each qubit again.\n4. Measure all qubits.\n\nYou know that after the second step the qubits end up in the following state:\n\n$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)} \\ket{x}$$\n\nNow, once you apply the Hadamard gates to each qubit, the system state becomes:\n\n$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} \\sum_{z=0}^{2^N-1} (-1)^{f(x) + x \\cdot z} \\ket{z}$$\n\n> In Deutsch-Jozsa algorithm, you looked at the amplitude of the $\\ket{0}$ state in this expression, which was \n> $\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)}$.\n\nNow, let's take a look at the amplitude of the $\\ket{s}$ state - the state that encodes the hidden bit string you're looking for.\nThis amplitude is \n\n$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x) + x \\cdot s}$$\n\nSince $f(x) = x \\cdot s$, for all values of $x$ $f(x) + x \\cdot s = 2 x \\cdot s$, and $(-1)^{f(x) + x \\cdot s} = 1$.\nOverall the amplitude of $\\ket{s}$ is \n\n$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} 1 = \\frac{1}{\\sqrt{2^N}} 2^N = 1$$\n\nThis means that the state after applying the Hadamard gates is just $\\ket{s}$, and measuring it gives you the bit string $s$!\nAnd, same as Deutsch-Jozsa algorithm, Bernstein-Vazirani algorithm takes only one oracle call."
+                            "content": "\nTo wrap up the discussion in this kata, let's take a look at a problem solved using a similar approach - the Bernstein-Vazirani algorithm.\nIn this problem, you are also given an oracle implementing an $N$-bit function $f(x): \\{0, 1\\}^N \\to \\{0, 1\\}$.\nHowever, this time the function is guaranteed to be a *scalar product function*, that is, there exists an $N$-bit string $s$\nthat allows the following representation ($\\cdot$ is bitwise inner product of integers modulo $2$):\n\n$$f(x) = x \\cdot s = \\sum_{k=0}^{N-1} x_k s_k \\bmod 2$$\n\nThe task is to recover the hidden bit string $s$.\n\n**Examples**\n\n- $f(x) \\equiv 0$ is an example of such a function with $s = 0, \\dots, 0$.\n- $f(x) = 1 \\text{ if x has odd number of 1s, and } 0 \\text{ otherwise }$ is another example of such a function, with $s = 1, \\dots, 1$.\n\nIf you solve this problem classically, how many calls to the given function will you need? \nYou'd need to use one query to recover each bit of $s$ (the query for $k$-th bit can be a bit string with $1$ in the $k$-th bit and zeros in all other positions), for a total of $N$ queries.\n\nWhat about the quantum scenario?\nIt turns out that the algorithm that allows you to solve this problem looks just like Deutsch-Jozsa algorithm, \nexcept for the way you interpret the measurement results on the last step. To see this, you'll need to take another look \nat the math involved in applying Hadamard gates to multiple qubits.\n\n### Apply Hadamard transform to each qubit: a different view\n\nWhen you apply an $H$ gate to a single qubit in the basis state $\\ket{x}$, you can write the result as the following sum:\n\n$$H\\ket{x} = \\frac1{\\sqrt2} (\\ket{0} + (-1)^{x} \\ket{1}) = \\frac1{\\sqrt2} \\sum_{z \\in \\{0, 1\\}} (-1)^{x \\cdot z} \\ket{z}$$\n\nIf you use this representation to spell out the result of applying an $H$ gate to each qubit of an $N$-qubit basis state \n$\\ket{x} = \\ket{x_0}\\ket{x_1} \\dots \\ket{x_{N-1}}$, you get:\n\n$$H\\ket{x} = \\frac1{\\sqrt{2^N}} \\sum_{z_k \\in {0, 1}} (-1)^{x_0z_0 + \\dots + x_{N-1}z_{N-1}} \\ket{z_0}\\ket{z_1} \\dots \\ket{z_{N-1}} =$$\n\n$$= \\frac1{\\sqrt{2^N}} \\sum_{z = 0}^{2^N-1} (-1)^{x \\cdot z} \\ket{z}$$\n\nWith this in mind, let's revisit the algorithm and see how you can write the exact quantum state after it.\n\n### Bernstein-Vazirani algorithm\n\nBernstein-Vazirani algorithm follows the same outline as Deutsch-Jozsa algorithm:\n\n1. Apply the $H$ gate to each qubit.\n2. Apply the oracle.\n3. Apply the $H$ gate to each qubit again.\n4. Measure all qubits.\n\nYou know that after the second step the qubits end up in the following state:\n\n$$\\frac{1}{\\sqrt{2^N}} \\sum_{x=0}^{2^N-1} (-1)^{f(x)} \\ket{x}$$\n\nNow, once you apply the Hadamard gates to each qubit, the system state becomes:\n\n$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} \\sum_{z=0}^{2^N-1} (-1)^{f(x) + x \\cdot z} \\ket{z}$$\n\n> In Deutsch-Jozsa algorithm, you looked at the amplitude of the $\\ket{0}$ state in this expression, which was \n> $\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} (-1)^{f(x)}$.\n\nNow, let's take a look at the amplitude of the $\\ket{s}$ state - the state that encodes the hidden bit string you're looking for.\nThis amplitude is \n\n$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} (-1)^{f(x) + x \\cdot s}$$\n\nSince $f(x) = x \\cdot s$, for all values of $x$ $f(x) + x \\cdot s = 2 x \\cdot s$, and $(-1)^{f(x) + x \\cdot s} = 1$.\nOverall the amplitude of $\\ket{s}$ is \n\n$$\\frac{1}{2^N} \\sum_{x=0}^{2^N-1} 1 = \\frac{1}{2^N} 2^N = 1$$\n\nThis means that the state after applying the Hadamard gates is just $\\ket{s}$, and measuring it gives you the bit string $s$!\nAnd, same as Deutsch-Jozsa algorithm, Bernstein-Vazirani algorithm takes only one oracle call."
                         }
                     ]
                 },

package/dist/main.d.ts

@@ -1,8 +1,8 @@
 import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
 import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
 import { ILanguageService, ILanguageServiceWorker, qsharpLibraryUriScheme } from "./language-service/language-service.js";
-import type { ProjectLoader } from "../lib/web/qsc_wasm.js";
-import { IProjectHost } from "./browser.js";
+import { ProjectLoader } from "./project.js";
+import type { IProjectHost } from "./browser.js";
 export { qsharpLibraryUriScheme };
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
 export declare function getCompiler(): ICompiler;

package/dist/main.js

@@ -8,6 +8,7 @@ import { QSharpDebugService, debugServiceProtocol, } from "./debug-service/debug
 import { QSharpLanguageService, languageServiceProtocol, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
 import { log } from "./log.js";
 import { createProxy } from "./workers/node.js";
+import { ProjectLoader } from "./project.js";
 export { qsharpLibraryUriScheme };
 let wasm = null;
 function ensureWasm() {
@@ -29,7 +30,7 @@ export function getCompiler() {
 }
 export function getProjectLoader(host) {
     ensureWasm();
-    return new wasm.ProjectLoader(host);
+    return new ProjectLoader(wasm, host);
 }
 export function getCompilerWorker() {
     return createProxy("../compiler/worker-node.js", compilerProtocol);

package/dist/project.d.ts

@@ -0,0 +1,10 @@
+import * as wasm from "../lib/web/qsc_wasm.js";
+type QscWasm = typeof import("../lib/web/qsc_wasm.js");
+export declare class ProjectLoader {
+    private nativeLoader;
+    constructor(wasm: QscWasm, host: wasm.IProjectHost);
+    dispose(): void;
+    loadQSharpProject(directory: string): Promise<wasm.IProjectConfig>;
+    loadOpenQasmProject(document: string): Promise<wasm.IProjectConfig>;
+}
+export {};

package/dist/project.js

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { callAndTransformExceptions } from "./diagnostics.js";
+export class ProjectLoader {
+    constructor(wasm, host) {
+        this.nativeLoader = new wasm.ProjectLoader(host);
+    }
+    dispose() {
+        this.nativeLoader.free();
+    }
+    loadQSharpProject(directory) {
+        return callAndTransformExceptions(() => this.nativeLoader.load_project_with_deps(directory));
+    }
+    loadOpenQasmProject(document) {
+        return callAndTransformExceptions(() => this.nativeLoader.load_openqasm_project(document));
+    }
+}

package/dist/samples.generated.js

@@ -62,11 +62,6 @@ export default [
     {
         "title": "Random Number Generator",
         "shots": 1000,
-        "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nimport Std.Measurement.*;\nimport Std.Intrinsic.*;\n\noperation Main() : Result[] {\n    // Generate 5-bit random number.\n    let nBits = 5;\n    return GenerateNRandomBits(nBits);\n}\n\n/// # Summary\n/// Generates N random bits.\noperation GenerateNRandomBits(nBits : Int) : Result[] {\n    // Allocate N qubits.\n    use register = Qubit[nBits];\n\n    // Set the qubits into superposition of 0 and 1 using the Hadamard\n    // operation `H`.\n    for qubit in register {\n        H(qubit);\n    }\n\n    // At this point each has 50% chance of being measured in the |0〉 state\n    // and 50% chance of being measured in the |1〉 state.\n    // Measure each qubit and reset them all so they can be safely\n    // deallocated.\n    let results = MResetEachZ(register);\n    return results;\n}\n"
-    },
-    {
-        "title": "Random Number Generator (Advanced)",
-        "shots": 1000,
         "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nimport Std.Convert.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\n\noperation Main() : Int {\n    let max = 100;\n    Message($\"Sampling a random number between 0 and {max}:\");\n\n    // Generate random number in the 0..max range.\n    return GenerateRandomNumberInRange(max);\n}\n\n/// # Summary\n/// Generates a random number between 0 and `max`.\noperation GenerateRandomNumberInRange(max : Int) : Int {\n    // Determine the number of bits needed to represent `max` and store it\n    // in the `nBits` variable. Then generate `nBits` random bits which will\n    // represent the generated random number.\n    mutable bits = [];\n    let nBits = BitSizeI(max);\n    for idxBit in 1..nBits {\n        bits += [GenerateRandomBit()];\n    }\n    let sample = ResultArrayAsInt(bits);\n\n    // Return random number if it is within the requested range.\n    // Generate it again if it is outside the range.\n    return sample > max ? GenerateRandomNumberInRange(max) | sample;\n}\n\n/// # Summary\n/// Generates a random bit.\noperation GenerateRandomBit() : Result {\n    // Allocate a qubit.\n    use q = Qubit();\n\n    // Set the qubit into superposition of 0 and 1 using the Hadamard\n    // operation `H`.\n    H(q);\n\n    // At this point the qubit `q` has 50% chance of being measured in the\n    // |0〉 state and 50% chance of being measured in the |1〉 state.\n    // Measure the qubit value using the `M` operation, and store the\n    // measurement value in the `result` variable.\n    let result = M(q);\n\n    // Reset qubit to the |0〉 state.\n    // Qubits must be in the |0〉 state by the time they are released.\n    Reset(q);\n\n    // Return the result of the measurement.\n    return result;\n\n    // Note that Qubit `q` is automatically released at the end of the block.\n}\n"
     },
     {
@@ -92,7 +87,7 @@ export default [
     {
         "title": "Grover's Search",
         "shots": 100,
-        "code": "/// # Sample\n/// Grover's Search Algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm.\nimport Std.Convert.*;\nimport Std.Math.*;\nimport Std.Arrays.*;\nimport Std.Measurement.*;\nimport Std.Diagnostics.*;\n\noperation Main() : Result[] {\n    let nQubits = 5;\n\n    // Grover's algorithm relies on performing a \"Grover iteration\" an\n    // optimal number of times to maximize the probability of finding the\n    // value we are searching for.\n    // You can set the number iterations to a value lower than optimal to\n    // intentionally reduce precision.\n    let iterations = CalculateOptimalIterations(nQubits);\n    Message($\"Number of iterations: {iterations}\");\n\n    // Use Grover's algorithm to find a particular marked state.\n    let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);\n    return results;\n}\n\n/// # Summary\n/// Implements Grover's algorithm, which searches all possible inputs to an\n/// operation to find a particular marked state.\noperation GroverSearch(\n    nQubits : Int,\n    iterations : Int,\n    phaseOracle : Qubit[] => Unit\n) : Result[] {\n\n    use qubits = Qubit[nQubits];\n\n    // Initialize a uniform superposition over all possible inputs.\n    PrepareUniform(qubits);\n\n    // The search itself consists of repeatedly reflecting about the marked\n    // state and our start state, which we can write out in Q# as a for loop.\n    for _ in 1..iterations {\n        phaseOracle(qubits);\n        ReflectAboutUniform(qubits);\n    }\n\n    // Measure and return the answer.\n    return MResetEachZ(qubits);\n}\n\n/// # Summary\n/// Returns the optimal number of Grover iterations needed to find a marked\n/// item, given the number of qubits in a register.\nfunction CalculateOptimalIterations(nQubits : Int) : Int {\n    if nQubits > 126 {\n        fail \"This sample supports at most 126 qubits.\";\n    }\n\n    let nItems = 2.0^IntAsDouble(nQubits);\n    let angle = ArcSin(1. / Sqrt(nItems));\n    let iterations = Round(0.25 * PI() / angle - 0.5);\n    iterations\n}\n\n/// # Summary\n/// Reflects about the basis state marked by alternating zeros and ones.\n/// This operation defines what input we are trying to find in the search.\noperation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n    Message(\"Reflecting about marked state...\");\n    use outputQubit = Qubit();\n    within {\n        // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n        // toggling it results in a (-1) phase.\n        X(outputQubit);\n        H(outputQubit);\n        // Flip the outputQubit for marked states.\n        // Here, we get the state with alternating 0s and 1s by using the X\n        // operation on every other qubit.\n        for q in inputQubits[...2...] {\n            X(q);\n        }\n    } apply {\n        Controlled X(inputQubits, outputQubit);\n    }\n}\n\n/// # Summary\n/// Given a register in the all-zeros state, prepares a uniform\n/// superposition over all basis states.\noperation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n    for q in inputQubits {\n        H(q);\n    }\n}\n\n/// # Summary\n/// Reflects about the all-ones state.\noperation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n    Controlled Z(Most(inputQubits), Tail(inputQubits));\n}\n\n/// # Summary\n/// Reflects about the uniform superposition state.\noperation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n    within {\n        // Transform the uniform superposition to all-zero.\n        Adjoint PrepareUniform(inputQubits);\n        // Transform the all-zero state to all-ones\n        for q in inputQubits {\n            X(q);\n        }\n    } apply {\n        // Now that we've transformed the uniform superposition to the\n        // all-ones state, reflect about the all-ones state, then let the\n        // within/apply block transform us back.\n        ReflectAboutAllOnes(inputQubits);\n    }\n}\n"
+        "code": "/// # Sample\n/// Grover's Search Algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm and applies it\n/// to a specific problem: finding a marked state in a register of qubits.\n/// The marked state selected for this sample is |01010⟩.\n\nimport Std.Convert.*;\nimport Std.Math.*;\nimport Std.Arrays.*;\nimport Std.Measurement.*;\nimport Std.Diagnostics.*;\n\noperation Main() : Result[] {\n    let nQubits = 5;\n\n    // Grover's algorithm relies on performing a \"Grover iteration\" an\n    // optimal number of times to maximize the probability of finding the\n    // value we are searching for.\n    // You can intentionally set the number iterations to a value lower\n    // than optimal. In this case, the algorithm will find the marked state\n    // with lower probability.\n    let nIterations = IterationsToMarked(nQubits);\n    Message($\"Number of iterations: {nIterations}\");\n\n    // Use Grover's algorithm to find a particular marked state. The marked state\n    // we are looking for in this sample is |01010⟩, which is represented\n    // by the operation ReflectAboutMarked.\n    let results = GroverSearch(nQubits, nIterations, ReflectAboutMarked);\n\n    // Expected result is [Zero, One, Zero, One, Zero] with very high probability.\n    return results;\n}\n\n/// # Summary\n/// Implements Grover's algorithm, which searches all possible inputs to an\n/// operation to find a particular marked state.\noperation GroverSearch(\n    nQubits : Int,\n    iterations : Int,\n    phaseOracle : Qubit[] => Unit\n) : Result[] {\n\n    use qubits = Qubit[nQubits];\n\n    // Initialize a uniform superposition over all possible inputs.\n    PrepareUniform(qubits);\n\n    // The search itself consists of repeatedly reflecting about the marked\n    // state and our start state, which we can write out in Q# as a for loop.\n    for _ in 1..iterations {\n        phaseOracle(qubits);\n        ReflectAboutUniform(qubits);\n    }\n\n    // Measure and return the answer.\n    return MResetEachZ(qubits);\n}\n\n/// # Summary\n/// Returns the optimal number of Grover iterations needed to find a marked\n/// item, given the number of qubits in a register. Setting the number of\n/// iterations to a different number may undershoot or overshoot the marked state.\nfunction IterationsToMarked(nQubits : Int) : Int {\n    if nQubits > 126 {\n        fail \"This sample supports at most 126 qubits.\";\n    }\n\n    let nItems = 2.0^IntAsDouble(nQubits);\n    let angle = ArcSin(1. / Sqrt(nItems));\n    let iterations = Round(0.25 * PI() / angle - 0.5);\n    iterations\n}\n\n/// # Summary\n/// Reflects about the basis state marked by alternating zeros and ones.\n/// This operation defines what input we are trying to find in the search.\noperation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n    Message(\"Reflecting about marked state...\");\n    use outputQubit = Qubit();\n    within {\n        // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n        // toggling it results in a (-1) phase.\n        X(outputQubit);\n        H(outputQubit);\n        // Flip the outputQubit for marked states.\n        // Here, we get the state with alternating 0s and 1s by using the X\n        // operation on every other qubit.\n        for q in inputQubits[...2...] {\n            X(q);\n        }\n    } apply {\n        Controlled X(inputQubits, outputQubit);\n    }\n}\n\n/// # Summary\n/// Given a register in the all-zeros state, prepares a uniform\n/// superposition over all basis states.\noperation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n    for q in inputQubits {\n        H(q);\n    }\n}\n\n/// # Summary\n/// Reflects about the all-ones state.\noperation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n    Controlled Z(Most(inputQubits), Tail(inputQubits));\n}\n\n/// # Summary\n/// Reflects about the uniform superposition state.\noperation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n    within {\n        // Transform the uniform superposition to all-zero.\n        Adjoint PrepareUniform(inputQubits);\n        // Transform the all-zero state to all-ones\n        for q in inputQubits {\n            X(q);\n        }\n    } apply {\n        // Now that we've transformed the uniform superposition to the\n        // all-ones state, reflect about the all-ones state, then let the\n        // within/apply block transform us back.\n        ReflectAboutAllOnes(inputQubits);\n    }\n}\n"
     },
     {
         "title": "Hidden Shift",

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { Operation } from "./shared/circuit.js";
-import { Register } from "./shared/register.js";
+import { Operation } from "./data-structures/circuit.js";
+import { Register } from "./data-structures/register.js";
 export type Tick = {
     value: number;
     label: string;
@@ -30,12 +30,4 @@ export declare function getRanges(data: SeriesOfPoints, rangeCoefficient: number
  * @returns An array of Register objects involved in the operation.
  */
 export declare function getOperationRegisters(operation: Operation): Register[];
-/**
- * Get the minimum and maximum register indices for a given operation.
- *
- * @param operation The operation for which to get the register indices.
- * @param numQubits The number of qubits in the circuit.
- * @returns A tuple containing the minimum and maximum register indices.
- */
-export declare function getMinMaxRegIdx(operation: Operation, numQubits: number): [number, number];
 export {};

package/dist/utils.js

@@ -162,42 +162,3 @@ export function getOperationRegisters(operation) {
             return [...operation.qubits, ...(operation.results || [])];
     }
 }
-/**
- * Get the minimum and maximum register indices for a given operation.
- *
- * @param operation The operation for which to get the register indices.
- * @param numQubits The number of qubits in the circuit.
- * @returns A tuple containing the minimum and maximum register indices.
- */
-export function getMinMaxRegIdx(operation, numQubits) {
-    let targets;
-    let controls;
-    switch (operation.kind) {
-        case "measurement":
-            targets = operation.results;
-            controls = operation.qubits;
-            break;
-        case "unitary":
-            targets = operation.targets;
-            controls = operation.controls || [];
-            break;
-        case "ket":
-            targets = operation.targets;
-            controls = [];
-            break;
-    }
-    const qRegs = [...controls, ...targets]
-        .filter(({ result }) => result === undefined)
-        .map(({ qubit }) => qubit);
-    const clsControls = controls.filter(({ result }) => result !== undefined);
-    const isClassicallyControlled = clsControls.length > 0;
-    if (!isClassicallyControlled && qRegs.length === 0)
-        return [-1, -1];
-    // If operation is classically-controlled, pad all qubit registers. Otherwise, only pad
-    // the contiguous range of registers that it covers.
-    const minRegIdx = isClassicallyControlled ? 0 : Math.min(...qRegs);
-    const maxRegIdx = isClassicallyControlled
-        ? numQubits - 1
-        : Math.max(...qRegs);
-    return [minRegIdx, maxRegIdx];
-}