qsharp-lang 1.0.32-dev → 1.0.34-dev

package/dist/katas-content.generated.js

@@ -665,8 +665,8 @@ export default {
                     "title": "Prepare a Superposition of Two Basis States",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{\\sqrt2}\\big(|00\\rangle - |01\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\\\ 0 \\\\ 0 \\end{bmatrix}$.</p>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $|0\\rangle \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$.\n</details>\n",
-                        "asMarkdown": "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{\\sqrt2}\\big(|00\\rangle - |01\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix}$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $|0\\rangle \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$.\n</details>\n"
+                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{\\sqrt2}\\big(|00\\rangle - |10\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ 0 \\\\ -1 \\\\ 0 \\end{bmatrix}$.</p>\n<blockquote>\n<p>Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the &quot;first&quot; qubit (<code>qs[0]</code> in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the &quot;second&quot; qubit (<code>qs[1]</code> in a Q# register) refers to the most-significant qubit $qs_1$.</p>\n</blockquote>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes |0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$.\n</details>\n",
+                        "asMarkdown": "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{\\sqrt2}\\big(|00\\rangle - |10\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ -1 \\\\\\ 0 \\end{bmatrix}$.\n\n> Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the \"first\" qubit (`qs[0]` in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the \"second\" qubit (`qs[1]` in a Q# register) refers to the most-significant qubit $qs_1$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes |0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$.\n</details>\n"
                     },
                     "sourceIds": [
                         "KatasLibrary.qs",
@@ -679,8 +679,8 @@ export default {
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>We begin in the same state as the previous excercise:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle$$</p>\n<p>The goal state can be separated as follows:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ -1 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix} = |0\\rangle \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big)$$</p>\n<p>This means that the first qubit is already in the state we want it to be, but the second qubit needs to be transformed from the $ \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} $ into $ \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\ -1\\end{bmatrix}$ state.</p>\n<p>First, we apply the <strong>X</strong> gate to the second qubit; this performs the following transformation:\n$$ X |0\\rangle = \\begin{bmatrix}0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = |1\\rangle  $$</p>\n<p>Second, we apply the <strong>H</strong> gate to the second qubit; this transforms its state into the desired one:\n$$ H|1\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 &amp; 1 \\\\ 1 &amp; -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}$$</p>\n",
-                                "asMarkdown": "\nWe begin in the same state as the previous excercise:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle$$\n\nThe goal state can be separated as follows:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ -1 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} = |0\\rangle \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big)$$\n\nThis means that the first qubit is already in the state we want it to be, but the second qubit needs to be transformed from the $ \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} $ into $ \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\\\ -1\\end{bmatrix}$ state.\n\nFirst, we apply the **X** gate to the second qubit; this performs the following transformation:\n$$ X |0\\rangle = \\begin{bmatrix}0 & 1 \\\\\\ 1 & 0 \\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} = |1\\rangle  $$\n\nSecond, we apply the **H** gate to the second qubit; this transforms its state into the desired one:\n$$ H|1\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 & 1 \\\\\\ 1 & -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$$"
+                                "asHtml": "<p>We begin in the same state as the previous excercise:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle$$</p>\n<p>The goal state can be separated as follows:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 0 \\\\ -1 \\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes |0\\rangle$$</p>\n<p>This means that the first qubit is already in the state we want it to be, but the second qubit needs to be transformed from the $ \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} $ into $ \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\ -1\\end{bmatrix}$ state.</p>\n<p>First, we apply the <strong>X</strong> gate to the second qubit; this performs the following transformation:\n$$ X |0\\rangle = \\begin{bmatrix}0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = |1\\rangle  $$</p>\n<p>Second, we apply the <strong>H</strong> gate to the second qubit; this transforms its state into the desired one:\n$$ H|1\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 &amp; 1 \\\\ 1 &amp; -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}$$</p>\n",
+                                "asMarkdown": "\nWe begin in the same state as the previous excercise:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle$$\n\nThe goal state can be separated as follows:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ -1 \\\\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes |0\\rangle$$\n\nThis means that the first qubit is already in the state we want it to be, but the second qubit needs to be transformed from the $ \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} $ into $ \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\\\ -1\\end{bmatrix}$ state.\n\nFirst, we apply the **X** gate to the second qubit; this performs the following transformation:\n$$ X |0\\rangle = \\begin{bmatrix}0 & 1 \\\\\\ 1 & 0 \\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} = |1\\rangle  $$\n\nSecond, we apply the **H** gate to the second qubit; this transforms its state into the desired one:\n$$ H|1\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 & 1 \\\\\\ 1 & -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$$"
                             },
                             {
                                 "type": "solution",
@@ -696,8 +696,8 @@ export default {
                     "title": " Prepare a Superposition with Real Amplitudes",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ -1 \\\\ 1 \\\\ -1 \\end{bmatrix}$.</p>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$.\n</details>\n",
-                        "asMarkdown": "\n**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ -1 \\\\\\ 1 \\\\\\ -1 \\end{bmatrix}$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix}$.\n</details>\n"
+                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + |01\\rangle - |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ 1 \\\\ -1 \\\\ -1 \\end{bmatrix}$.</p>\n<blockquote>\n<p>Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the &quot;first&quot; qubit (<code>qs[0]</code> in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the &quot;second&quot; qubit (<code>qs[1]</code> in a Q# register) refers to the most-significant qubit $qs_1$.</p>\n</blockquote>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$.\n</details>\n",
+                        "asMarkdown": "\n**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + |01\\rangle - |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ 1 \\\\\\ -1 \\\\\\ -1 \\end{bmatrix}$.\n\n> Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the \"first\" qubit (`qs[0]` in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the \"second\" qubit (`qs[1]` in a Q# register) refers to the most-significant qubit $qs_1$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$.\n</details>\n"
                     },
                     "sourceIds": [
                         "KatasLibrary.qs",
@@ -710,8 +710,8 @@ export default {
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>Again, to start we will represent the goal state as a tensor product of single-qubit states; this gives us the following representation:</p>\n<p>$$ \\frac{1}{2}\\big(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ -1 \\\\ 1 \\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big)  $$</p>\n<p>This time we need to transform both the first and the second qubits. Let&#39;s start with the first qubit. Applying the <strong>H</strong> gate transforms its state as follows:</p>\n<p>$$ H|0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 &amp; 1 \\\\ 1 &amp; -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$</p>\n<p>For the second qubit we can use the same transformation we&#39;ve seen in the &quot;Prepare a Superposition of Two Basis States&quot; exercise; this will give the desired end state.</p>\n",
-                                "asMarkdown": "\nAgain, to start we will represent the goal state as a tensor product of single-qubit states; this gives us the following representation:\n\n$$ \\frac{1}{2}\\big(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ -1 \\\\\\ 1 \\\\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big)  $$\n\nThis time we need to transform both the first and the second qubits. Let's start with the first qubit. Applying the **H** gate transforms its state as follows:\n\n$$ H|0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 & 1 \\\\\\ 1 & -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$\n\nFor the second qubit we can use the same transformation we've seen in the \"Prepare a Superposition of Two Basis States\" exercise; this will give the desired end state."
+                                "asHtml": "<p>Again, to start we will represent the goal state as a tensor product of single-qubit states; this gives us the following representation:</p>\n<p>$$ \\frac{1}{2}\\big(|00\\rangle + |01\\rangle - |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ 1 \\\\ -1 \\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$</p>\n<p>This time we need to transform both the first and the second qubits. Let&#39;s start with the first qubit. Applying the <strong>H</strong> gate transforms its state as follows:</p>\n<p>$$ H|0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 &amp; 1 \\\\ 1 &amp; -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$</p>\n<p>For the second qubit we can use the same transformation we&#39;ve seen in the &quot;Prepare a Superposition of Two Basis States&quot; exercise; this will give the desired end state.</p>\n",
+                                "asMarkdown": "\nAgain, to start we will represent the goal state as a tensor product of single-qubit states; this gives us the following representation:\n\n$$ \\frac{1}{2}\\big(|00\\rangle + |01\\rangle - |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ 1 \\\\\\ -1 \\\\\\ -1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ -1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$\n\nThis time we need to transform both the first and the second qubits. Let's start with the first qubit. Applying the **H** gate transforms its state as follows:\n\n$$ H|0\\rangle = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 & 1 \\\\\\ 1 & -1 \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big)$$\n\nFor the second qubit we can use the same transformation we've seen in the \"Prepare a Superposition of Two Basis States\" exercise; this will give the desired end state."
                             },
                             {
                                 "type": "solution",
@@ -727,8 +727,8 @@ export default {
                     "title": "Prepare a Superposition with Complex Amplitudes",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + e^{i\\pi/4}|01\\rangle + e^{i\\pi/2}|10\\rangle + e^{3i\\pi/4}|11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\ e^{i\\pi/4} \\ e^{i\\pi/2} \\ e^{3i\\pi/4} \\end{bmatrix}$.</p>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix}$.\n</details>\n",
-                        "asMarkdown": "\n**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + e^{i\\pi/4}|01\\rangle + e^{i\\pi/2}|10\\rangle + e^{3i\\pi/4}|11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\\\ e^{i\\pi/2} \\\\ e^{3i\\pi/4} \\end{bmatrix}$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix}$.\n</details>\n"
+                        "asHtml": "<p><strong>Input:</strong> A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \\end{bmatrix}$.</p>\n<p><strong>Goal:</strong> Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + e^{i\\pi/2}|01\\rangle + e^{i\\pi/4}|10\\rangle + e^{3i\\pi/4}|11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\ e^{i\\pi/2} \\ e^{i\\pi/4} \\ e^{3i\\pi/4} \\end{bmatrix}$.</p>\n<blockquote>\n<p>Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the &quot;first&quot; qubit (<code>qs[0]</code> in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the &quot;second&quot; qubit (<code>qs[1]</code> in a Q# register) refers to the most-significant qubit $qs_1$.</p>\n</blockquote>\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix}$.\n</details>\n",
+                        "asMarkdown": "\n**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n\n**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + e^{i\\pi/2}|01\\rangle + e^{i\\pi/4}|10\\rangle + e^{3i\\pi/4}|11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\\\ e^{i\\pi/4} \\\\ e^{3i\\pi/4} \\end{bmatrix}$.\n\n> Note that the quantum states are represented in little-endian format For a state $|qs_1 qs_0\\rangle$, the \"first\" qubit (`qs[0]` in a Q# qubit register) refers to the least-significant qubit $qs_0$, while the \"second\" qubit (`qs[1]` in a Q# register) refers to the most-significant qubit $qs_1$.\n\n<details>\n    <summary><b>Need a hint?</b></summary>\n    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix}$.\n</details>\n"
                     },
                     "sourceIds": [
                         "KatasLibrary.qs",
@@ -741,8 +741,8 @@ export default {
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>The start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$</p>\n<p>The goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):</p>\n<p>$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\\\ e^{i\\pi/2} \\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$</p>\n<p>We will again need to adjust the states of both qubits independently.</p>\n<p>For the first qubit, we&#39;ll start by applying the <strong>H</strong> gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}$, as we&#39;ve seen in the previous task. Afterwards we&#39;ll apply the <strong>S</strong> gate with the following result:</p>\n<p>$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ i \\end{bmatrix}$$</p>\n<p>If we recall that $i = e^{i\\pi/2}$, we can write the final state of the second qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} $$</p>\n<p>For the second qubit. we&#39;ll apply the <strong>H</strong> gate, followed by the <strong>T</strong> gate, with the following result:\n$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} $$</p>\n",
-                                "asMarkdown": "\nThe start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$\n\nThe goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):\n\n$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\\\\\ e^{i\\pi/2} \\\\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$\n\nWe will again need to adjust the states of both qubits independently.\n\nFor the first qubit, we'll start by applying the **H** gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$, as we've seen in the previous task. Afterwards we'll apply the **S** gate with the following result:\n\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ i \\end{bmatrix}$$\n\nIf we recall that $i = e^{i\\pi/2}$, we can write the final state of the second qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} $$\n\nFor the second qubit. we'll apply the **H** gate, followed by the **T** gate, with the following result:\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} $$"
+                                "asHtml": "<p>The start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$</p>\n<p>The goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):</p>\n<p>$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\\\ e^{i\\pi/4} \\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) $$</p>\n<p>We will again need to adjust the states of both qubits independently.</p>\n<p>For the first qubit, we&#39;ll start by applying the <strong>H</strong> gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}$, as we&#39;ve seen in the previous task. Afterwards we&#39;ll apply the <strong>S</strong> gate with the following result:</p>\n<p>$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ i \\end{bmatrix}$$</p>\n<p>If we recall that $i = e^{i\\pi/2}$, we can write the final state of the first qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} $$</p>\n<p>For the second qubit. we&#39;ll apply the <strong>H</strong> gate, followed by the <strong>T</strong> gate, with the following result:\n$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} $$</p>\n",
+                                "asMarkdown": "\nThe start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$\n\nThe goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):\n\n$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\\\\\ e^{i\\pi/4} \\\\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) $$\n\nWe will again need to adjust the states of both qubits independently.\n\nFor the first qubit, we'll start by applying the **H** gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$, as we've seen in the previous task. Afterwards we'll apply the **S** gate with the following result:\n\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ i \\end{bmatrix}$$\n\nIf we recall that $i = e^{i\\pi/2}$, we can write the final state of the first qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} $$\n\nFor the second qubit. we'll apply the **H** gate, followed by the **T** gate, with the following result:\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} $$"
                             },
                             {
                                 "type": "solution",
@@ -2341,23 +2341,23 @@ export default {
         },
         {
             "id": "multi_qubit_systems__common.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n\n    operation AssertEqualOnZeroState(\n        testImpl : (Qubit[] => Unit is Ctl),\n        refImpl : (Qubit[] => Unit is Adj+Ctl)) : Bool {\n\n        use qs = Qubit[3];\n        within {\n            H(qs[0]);\n        }\n        apply {\n            // apply operation that needs to be tested\n            Controlled testImpl([qs[0]], qs[1..2]);\n\n            // apply adjoint reference operation\n            Adjoint Controlled refImpl([qs[0]], qs[1..2]);\n        }\n\n        // Implementation is correct when all qubits end up in |0⟩ state\n        let isCorrect = CheckAllZero(qs);\n        if not isCorrect {\n            Message(\"The prepared state is not the same as reference state.\");\n        }\n        ResetAll(qs);\n        isCorrect\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation CheckEqualOnZeroState(\n        testImpl : (Qubit[] => Unit is Adj + Ctl),\n        refImpl : (Qubit[] => Unit is Adj + Ctl)) : Bool {\n\n        let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(testImpl, refImpl, 2);\n\n        // Output different feedback to the user depending on whether the exercise was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            use target = Qubit[2]; // |00〉\n            ShowQuantumStateComparison(target, testImpl, refImpl);\n            ResetAll(target);\n        }\n        isCorrect\n    }\n\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_basis_state__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareBasisState_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        X(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareBasisState, PrepareBasisState_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareBasisState_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        X(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareBasisState, PrepareBasisState_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_superposition__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareSuperposition_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareSuperposition, PrepareSuperposition_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareSuperposition_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareSuperposition, PrepareSuperposition_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_with_real__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareWithReal_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareWithReal, PrepareWithReal_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareWithReal_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareWithReal, PrepareWithReal_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_with_complex__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareWithComplex_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        H(qs[1]);\n        S(qs[0]);\n        T(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareWithComplex, PrepareWithComplex_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareWithComplex_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        H(qs[1]);\n        S(qs[0]);\n        T(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareWithComplex, PrepareWithComplex_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_gates__compound_gate__Verification.qs",

package/dist/log.js

@@ -55,9 +55,8 @@ export const log = {
      * @param args - The format string and args to log, e.g. ["Index of %s is %i", str, index]
      */
     logWithLevel(level, target, ...args) {
-        // Convert to a format string containing the target (if present)
-        const [, ...trailingArgs] = args; // All but first element of args
-        const outArgs = [`[%s] ${args[0]}`, target || "", ...trailingArgs];
+        const [firstArg, ...trailingArgs] = args;
+        const outArgs = [`[${target || ""}] ${firstArg}`, ...trailingArgs];
         switch (level) {
             case 1:
                 log.error(...outArgs);

package/dist/ux/ticks.d.ts

@@ -0,0 +1,6 @@
+export type Tick = {
+    value: number;
+    label: string;
+};
+export declare function CreateIntegerTicks(min: number, max: number): Tick[];
+export declare function CreateTimeTicks(min: number, max: number): Tick[];

package/dist/ux/ticks.js

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export function CreateIntegerTicks(min, max) {
+    if (max < min || min <= 0) {
+        return [];
+    }
+    const numberFormat = new Intl.NumberFormat();
+    const l = Math.round(10 ** Math.floor(Math.log10(min)));
+    const r = Math.round(10 ** Math.ceil(Math.log10(max)));
+    const result = [];
+    for (let i = l; i <= r; i *= 10) {
+        if (i >= min && i <= max) {
+            result.push({ value: i, label: numberFormat.format(i) });
+        }
+    }
+    if (result.length == 0) {
+        let step = l;
+        while (step >= 1) {
+            let i = Math.ceil(min / step) * step;
+            while (i <= max) {
+                result.push({ value: i, label: numberFormat.format(i) });
+                i += step;
+            }
+            if (result.length > 0) {
+                break;
+            }
+            step /= 10;
+        }
+    }
+    return result;
+}
+const predefinedTimeTicks = [
+    { tick: { value: 1, label: "1 nanosecond" }, plural: "nanoseconds" },
+    { tick: { value: 1e3, label: "1 microsecond" }, plural: "microseconds" },
+    { tick: { value: 1e6, label: "1 millisecond" }, plural: "milliseconds" },
+    { tick: { value: 1e9, label: "1 second" }, plural: "seconds" },
+    { tick: { value: 6e10, label: "1 minute" }, plural: "minutes" },
+    { tick: { value: 3.6e12, label: "1 hour" }, plural: "hours" },
+    { tick: { value: 8.64e13, label: "1 day" }, plural: "days" },
+    { tick: { value: 6.048e14, label: "1 week" }, plural: "weeks" },
+    { tick: { value: 2.592e15, label: "1 month" }, plural: "months" },
+    { tick: { value: 3.1536e16, label: "1 year" }, plural: "years" },
+    { tick: { value: 3.1536e17, label: "1 decade" }, plural: "decades" },
+    { tick: { value: 3.1536e18, label: "1 century" }, plural: "centuries" },
+];
+export function CreateTimeTicks(min, max) {
+    if (max < min || min <= 0) {
+        return [];
+    }
+    let l = 0;
+    while (l < predefinedTimeTicks.length &&
+        predefinedTimeTicks[l].tick.value <= min) {
+        l++;
+    }
+    let r = l;
+    if (l > 0) {
+        l--;
+    }
+    if (r >= predefinedTimeTicks.length) {
+        r = predefinedTimeTicks.length - 1;
+    }
+    while (r < predefinedTimeTicks.length - 1 &&
+        predefinedTimeTicks[r].tick.value <= max) {
+        r++;
+    }
+    const result = [];
+    for (let i = l; i <= r; i++) {
+        if (predefinedTimeTicks[i].tick.value >= min &&
+            predefinedTimeTicks[i].tick.value <= max) {
+            result.push(predefinedTimeTicks[i].tick);
+        }
+    }
+    if (result.length == 0) {
+        if (l < predefinedTimeTicks.length - 1) {
+            let coeff = 10 **
+                Math.floor(Math.log10(predefinedTimeTicks[l + 1].tick.value /
+                    predefinedTimeTicks[l].tick.value));
+            do {
+                let i = 1;
+                let val = 0;
+                do {
+                    val = predefinedTimeTicks[l].tick.value * i * coeff;
+                    if (val >= min && val <= max) {
+                        result.push({
+                            value: val,
+                            label: (i * coeff).toString() + " " + predefinedTimeTicks[l].plural,
+                        });
+                    }
+                    i++;
+                } while (
+                // just a single tick in case of 1, 10 or 100
+                (i > 2 || result.length < 1) &&
+                    val < predefinedTimeTicks[l + 1].tick.value);
+                coeff /= 10;
+            } while (result.length < 1 && coeff >= 1);
+        }
+        else {
+            // > century
+            let l = predefinedTimeTicks.length - 1;
+            do {
+                let coeff = 10 ** Math.floor(Math.log10(max / predefinedTimeTicks[l].tick.value));
+                do {
+                    let i = 1;
+                    let val = 0;
+                    do {
+                        val = predefinedTimeTicks[l].tick.value * i * coeff;
+                        if (val >= min && val <= max) {
+                            result.push({
+                                value: val,
+                                label: (i * coeff).toString() + " " + predefinedTimeTicks[l].plural,
+                            });
+                        }
+                        i++;
+                    } while (
+                    // just a single tick in case of 1, 10 or 100
+                    (i > 2 || result.length < 1) &&
+                        val < max);
+                    coeff /= 10;
+                } while (result.length < 1 && coeff >= 1);
+                l--;
+            } while (result.length < 1 && l >= 0);
+        }
+    }
+    return result;
+}