qsharp-lang 1.3.5-dev → 1.3.6-dev

package/dist/katas-content.generated.js

@@ -1226,60 +1226,60 @@ export default {
                 },
                 {
                     "type": "exercise",
-                    "id": "single_qubit_gates__y_gate",
-                    "title": "The Y Gate",
+                    "id": "single_qubit_gates__sign_flip",
+                    "title": "Sign Flip",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p><strong>Input:</strong> A qubit in an arbitrary state $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$.</p>\n<p><strong>Goal:</strong> Apply the Y gate to the qubit, i.e., transform the given state into $i\\alpha|1\\rangle - i\\beta|0\\rangle$.</p>\n",
-                        "asMarkdown": "**Input:** A qubit in an arbitrary state $|\\\\psi\\\\rangle = \\\\alpha|0\\\\rangle + \\\\beta|1\\\\rangle$.\n\n**Goal:** Apply the Y gate to the qubit, i.e., transform the given state into $i\\\\alpha|1\\\\rangle - i\\\\beta|0\\\\rangle$."
+                        "asHtml": "<p><strong>Input</strong>: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.</p>\n<p><strong>Goal</strong> : Change the qubit state to $\\alpha |0\\rangle - \\beta |1\\rangle$ (i.e., flip the sign of the $|1\\rangle$ component of the superposition).</p>\n",
+                        "asMarkdown": "**Input**: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n\n**Goal** : Change the qubit state to $\\alpha |0\\rangle - \\beta |1\\rangle$ (i.e., flip the sign of the $|1\\rangle$ component of the superposition).\n"
                     },
                     "sourceIds": [
-                        "single_qubit_gates__y_gate__Verification.qs",
+                        "single_qubit_gates__sign_flip__Verification.qs",
                         "KatasLibrary.qs"
                     ],
-                    "placeholderCode": "namespace Kata {\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "placeholderCode": "namespace Kata {\n    operation SignFlip (q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}\n\n",
                     "explainedSolution": {
                         "type": "explained-solution",
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>We have to do exactly what the task asks us to do: apply the Pauli gate $Y=\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix}$.</p>\n<p>This has the effect of turning $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$ into $Y|\\psi\\rangle = i\\alpha|1\\rangle - i\\beta|0\\rangle$, which in matrix form looks as follows:\n$$\n\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix} \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} = \n\\begin{bmatrix} -i\\beta \\\\ i\\alpha \\end{bmatrix}\n$$</p>\n",
-                                "asMarkdown": "\nWe have to do exactly what the task asks us to do: apply the Pauli gate $Y=\\\\begin{bmatrix} 0 & -i \\\\\\\\ i & 0 \\\\end{bmatrix}$.\n\nThis has the effect of turning $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$ into $Y|\\psi\\rangle = i\\alpha|1\\rangle - i\\beta|0\\rangle$, which in matrix form looks as follows:\n$$\n\\begin{bmatrix} 0 & -i \\\\\\ i & 0 \\end{bmatrix} \\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix} = \n\\begin{bmatrix} -i\\beta \\\\\\ i\\alpha \\end{bmatrix}\n$$"
+                                "asHtml": "<p>The action of the Pauli Z gate is exactly what is required by this question.\nThis gate leaves the sign of the $|0\\rangle$ component of the superposition unchanged but flips the sign of the $|1\\rangle$ component of the superposition.</p>\n<p>As a reminder, the Pauli Z gate is defined by the following matrix:</p>\n<p>$$\nZ =\n \\begin{bmatrix}1 &amp; 0\\\\0 &amp; -1 \\end{bmatrix}\n$$</p>\n<p>Let&#39;s see its effect on the only computational basis state that it changes, $|1\\rangle$:</p>\n<p>$$\nZ|1\\rangle =\n \\begin{bmatrix} 1 &amp; 0\\\\0 &amp; -1 \\end{bmatrix}\n \\begin{bmatrix}0\\\\ 1\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1 \\cdot 0 + 0 \\cdot1\\\\0 \\cdot 1 +  (-1) \\cdot 1\\\\ \\end{bmatrix}=\n\\begin{bmatrix}0\\\\ -1\\\\ \\end{bmatrix}=\n -\\begin{bmatrix}0\\\\ 1\\\\ \\end{bmatrix}=\n-|1\\rangle\n$$</p>\n<p>In general applying the Z gate to a single qubit superposition state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$ gives</p>\n<p>$$\nZ|\\psi\\rangle =\n \\begin{bmatrix}1 &amp; 0 \\\\0 &amp; -1\\end{bmatrix}\n \\begin{bmatrix}\\alpha\\\\ \\beta\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1\\cdot\\alpha + 0\\cdot\\beta\\\\0\\cdot\\alpha + (-1)\\cdot\\beta\\\\ \\end{bmatrix}=\n \\begin{bmatrix}\\alpha\\\\ -\\beta\\\\ \\end{bmatrix}=\n \\alpha |0\\rangle -\\beta |1\\rangle\n$$</p>\n",
+                                "asMarkdown": "\nThe action of the Pauli Z gate is exactly what is required by this question.\nThis gate leaves the sign of the $|0\\rangle$ component of the superposition unchanged but flips the sign of the $|1\\rangle$ component of the superposition.\n\nAs a reminder, the Pauli Z gate is defined by the following matrix:\n\n$$\nZ =\n \\begin{bmatrix}1 & 0\\\\\\0 & -1 \\end{bmatrix}\n$$\n\nLet's see its effect on the only computational basis state that it changes, $|1\\rangle$:\n\n$$\nZ|1\\rangle =\n \\begin{bmatrix} 1 & 0\\\\\\0 & -1 \\end{bmatrix}\n \\begin{bmatrix}0\\\\\\ 1\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1 \\cdot 0 + 0 \\cdot1\\\\\\0 \\cdot 1 +  (-1) \\cdot 1\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}0\\\\\\ -1\\\\\\ \\end{bmatrix}=\n -\\begin{bmatrix}0\\\\\\ 1\\\\\\ \\end{bmatrix}=\n-|1\\rangle\n$$\n\nIn general applying the Z gate to a single qubit superposition state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$ gives\n\n$$\nZ|\\psi\\rangle =\n \\begin{bmatrix}1 & 0 \\\\\\0 & -1\\end{bmatrix}\n \\begin{bmatrix}\\alpha\\\\\\ \\beta\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1\\cdot\\alpha + 0\\cdot\\beta\\\\\\0\\cdot\\alpha + (-1)\\cdot\\beta\\\\\\ \\end{bmatrix}=\n \\begin{bmatrix}\\alpha\\\\\\ -\\beta\\\\\\ \\end{bmatrix}=\n \\alpha |0\\rangle -\\beta |1\\rangle\n$$"
                             },
                             {
                                 "type": "solution",
-                                "id": "single_qubit_gates__y_gate_solution",
-                                "code": "namespace Kata {\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        Y(q); // As simple as this.\n    }\n}"
+                                "id": "single_qubit_gates__sign_flip_solution",
+                                "code": "namespace Kata {\n    operation SignFlip (q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n    }\n}"
                             }
                         ]
                     }
                 },
                 {
                     "type": "exercise",
-                    "id": "single_qubit_gates__global_phase_i",
-                    "title": "Applying a Global Phase",
+                    "id": "single_qubit_gates__y_gate",
+                    "title": "The Y Gate",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p><strong>Input:</strong> A qubit in an arbitrary state $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$.</p>\n<p><strong>Goal:</strong> Use several Pauli gates to change the qubit state to $i|\\psi\\rangle = i\\alpha|0\\rangle + i\\beta|1\\rangle$.</p>\n",
-                        "asMarkdown": "**Input:** A qubit in an arbitrary state $|\\\\psi\\\\rangle = \\\\alpha|0\\\\rangle + \\\\beta|1\\\\rangle$.\n\n**Goal:** Use several Pauli gates to change the qubit state to $i|\\\\psi\\\\rangle = i\\\\alpha|0\\\\rangle + i\\\\beta|1\\\\rangle$."
+                        "asHtml": "<p><strong>Input:</strong> A qubit in an arbitrary state $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$.</p>\n<p><strong>Goal:</strong> Apply the Y gate to the qubit, i.e., transform the given state into $i\\alpha|1\\rangle - i\\beta|0\\rangle$.</p>\n",
+                        "asMarkdown": "**Input:** A qubit in an arbitrary state $|\\\\psi\\\\rangle = \\\\alpha|0\\\\rangle + \\\\beta|1\\\\rangle$.\n\n**Goal:** Apply the Y gate to the qubit, i.e., transform the given state into $i\\\\alpha|1\\\\rangle - i\\\\beta|0\\\\rangle$."
                     },
                     "sourceIds": [
-                        "single_qubit_gates__global_phase_i__Verification.qs",
+                        "single_qubit_gates__y_gate__Verification.qs",
                         "KatasLibrary.qs"
                     ],
-                    "placeholderCode": "namespace Kata {\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "placeholderCode": "namespace Kata {\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
                     "explainedSolution": {
                         "type": "explained-solution",
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>We need to apply a gate which applies a global phase of $i$, i.e. $|\\psi\\rangle \\rightarrow i|\\psi\\rangle$.\nThe matrix representation of such a gate is $\\begin{bmatrix} i &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} = i\\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; 1 \\end{bmatrix} = iI$.\nSince we are restricted to the Pauli gates, we use the property that a product of any two distinct Pauli gates equals the third gate with a $+i$ or a $-i$ global phase, therefore the product of all three Pauli gates is $XYZ = iI$.\n$$\n\\begin{bmatrix} 0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix}\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix}\\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; -1 \\end{bmatrix} = \n\\begin{bmatrix} i &amp; 0 \\\\ 0 &amp; i \\end{bmatrix}\n$$</p>\n<blockquote>\n<p>Remember the rightmost gates in mathematical notation are applied first in Q# code. Hence we first apply the $Z$ gate, followed by the $Y$ gate, and finally the $X$ gate.</p>\n</blockquote>\n",
-                                "asMarkdown": "\nWe need to apply a gate which applies a global phase of $i$, i.e. $|\\psi\\rangle \\rightarrow i|\\psi\\rangle$.\nThe matrix representation of such a gate is $\\begin{bmatrix} i & 0 \\\\\\ 0 & i \\end{bmatrix} = i\\begin{bmatrix} 1 & 0 \\\\\\ 0 & 1 \\end{bmatrix} = iI$.\nSince we are restricted to the Pauli gates, we use the property that a product of any two distinct Pauli gates equals the third gate with a $+i$ or a $-i$ global phase, therefore the product of all three Pauli gates is $XYZ = iI$.\n$$\n\\begin{bmatrix} 0 & 1 \\\\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 0 & -i \\\\\\ i & 0 \\end{bmatrix}\\begin{bmatrix} 1 & 0 \\\\\\ 0 & -1 \\end{bmatrix} = \n\\begin{bmatrix} i & 0 \\\\\\ 0 & i \\end{bmatrix}\n$$\n\n> Remember the rightmost gates in mathematical notation are applied first in Q# code. Hence we first apply the $Z$ gate, followed by the $Y$ gate, and finally the $X$ gate."
+                                "asHtml": "<p>We have to do exactly what the task asks us to do: apply the Pauli gate $Y=\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix}$.</p>\n<p>This has the effect of turning $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$ into $Y|\\psi\\rangle = i\\alpha|1\\rangle - i\\beta|0\\rangle$, which in matrix form looks as follows:\n$$\n\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix} \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} = \n\\begin{bmatrix} -i\\beta \\\\ i\\alpha \\end{bmatrix}\n$$</p>\n",
+                                "asMarkdown": "\nWe have to do exactly what the task asks us to do: apply the Pauli gate $Y=\\\\begin{bmatrix} 0 & -i \\\\\\\\ i & 0 \\\\end{bmatrix}$.\n\nThis has the effect of turning $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$ into $Y|\\psi\\rangle = i\\alpha|1\\rangle - i\\beta|0\\rangle$, which in matrix form looks as follows:\n$$\n\\begin{bmatrix} 0 & -i \\\\\\ i & 0 \\end{bmatrix} \\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix} = \n\\begin{bmatrix} -i\\beta \\\\\\ i\\alpha \\end{bmatrix}\n$$"
                             },
                             {
                                 "type": "solution",
-                                "id": "single_qubit_gates__global_phase_i_solution",
-                                "code": "namespace Kata {\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n        Y(q);\n        X(q);\n    }\n}"
+                                "id": "single_qubit_gates__y_gate_solution",
+                                "code": "namespace Kata {\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        Y(q); // As simple as this.\n    }\n}"
                             }
                         ]
                     }
@@ -1314,6 +1314,66 @@ export default {
                         ]
                     }
                 },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__global_phase_minusone",
+                    "title": "Global Phase -1",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.</p>\n<p><strong>Goal</strong>: Change the state of the qubit to $- \\beta |0\\rangle - \\gamma |1\\rangle$.</p>\n<blockquote>\n<p>This change on its own is not observable - there is no experiment you can do on a standalone qubit to figure out whether it acquired the global phase or not.\nHowever, you can use a controlled version of this operation to observe the global phase it introduces.\nThis is used in later katas as part of more complicated tasks.</p>\n</blockquote>\n",
+                        "asMarkdown": "**Input:** A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.\n\n**Goal**: Change the state of the qubit to $- \\beta |0\\rangle - \\gamma |1\\rangle$.\n\n> This change on its own is not observable - there is no experiment you can do on a standalone qubit to figure out whether it acquired the global phase or not.\n> However, you can use a controlled version of this operation to observe the global phase it introduces.\n> This is used in later katas as part of more complicated tasks.\n"
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__global_phase_minusone__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation GlobalPhaseChange (q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}\n\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>A global phase is a phase factor that multiplies the entire quantum state. It is not observable when measuring the qubit&#39;s state, as the probabilities remain unchanged. However, it is significant when considering quantum state transformations.</p>\n<p>Our task is to implement an operation that transforms the given qubit state from $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$ to $- \\beta |0\\rangle - \\gamma |1\\rangle$.</p>\n<p>To do that, we utilize a sequence of gates. The Pauli Z gate followed by the Pauli X gate can be used to achieve this effect when applied in succession twice.</p>\n<ol>\n<li><p><strong>Apply the Pauli Z gate</strong>: The Z gate multiplies the $|1\\rangle$ state by $-1$ but does not change the $|0\\rangle$ state, converting our state $\\beta |0\\rangle + \\gamma |1\\rangle$ to $\\beta |0\\rangle - \\gamma |1\\rangle$.</p>\n<p>The matrix representation of the Z gate is:</p>\n<p>$$\nZ =\n\\begin{bmatrix}1 &amp; 0 \\\\ 0 &amp; -1 \\end{bmatrix}\n$$</p>\n</li>\n<li><p><strong>Apply the Pauli X gate</strong>: The X gate flips the $|0\\rangle$ and $|1\\rangle$ basis states, converting our $\\beta |0\\rangle - \\gamma |1\\rangle$ state to $\\beta |1\\rangle - \\gamma |0\\rangle$.</p>\n<p>The matrix representation of the X gate is:</p>\n<p>$$\nX =\n\\begin{bmatrix}0 &amp; 1 \\\\1 &amp; 0\\end{bmatrix}\n$$</p>\n</li>\n<li><p><strong>Repeat the Z and X gates</strong>: Applying the Z gate again will multiply the $|1\\rangle$ state (that used to be $|0\\rangle$), converting our state $\\beta |1\\rangle - \\gamma |0\\rangle$ to $- \\beta |1\\rangle - \\gamma |0\\rangle$. Finally, the second X gate will restore the original basis states, but now with both amplitudes having acquired an additional phase of $-1$. This means our state has been multiplied by $-1$, achieving the required global phase change.</p>\n</li>\n</ol>\n",
+                                "asMarkdown": "\nA global phase is a phase factor that multiplies the entire quantum state. It is not observable when measuring the qubit's state, as the probabilities remain unchanged. However, it is significant when considering quantum state transformations.\n\nOur task is to implement an operation that transforms the given qubit state from $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$ to $- \\beta |0\\rangle - \\gamma |1\\rangle$.\n\nTo do that, we utilize a sequence of gates. The Pauli Z gate followed by the Pauli X gate can be used to achieve this effect when applied in succession twice.\n\n1. **Apply the Pauli Z gate**: The Z gate multiplies the $|1\\rangle$ state by $-1$ but does not change the $|0\\rangle$ state, converting our state $\\beta |0\\rangle + \\gamma |1\\rangle$ to $\\beta |0\\rangle - \\gamma |1\\rangle$.\n\n   The matrix representation of the Z gate is:\n\n   $$\n   Z =\n   \\begin{bmatrix}1 & 0 \\\\\\ 0 & -1 \\end{bmatrix}\n   $$\n\n2. **Apply the Pauli X gate**: The X gate flips the $|0\\rangle$ and $|1\\rangle$ basis states, converting our $\\beta |0\\rangle - \\gamma |1\\rangle$ state to $\\beta |1\\rangle - \\gamma |0\\rangle$.\n\n   The matrix representation of the X gate is:\n\n   $$\n   X =\n   \\begin{bmatrix}0 & 1 \\\\\\1 & 0\\end{bmatrix}\n   $$\n\n3. **Repeat the Z and X gates**: Applying the Z gate again will multiply the $|1\\rangle$ state (that used to be $|0\\rangle$), converting our state $\\beta |1\\rangle - \\gamma |0\\rangle$ to $- \\beta |1\\rangle - \\gamma |0\\rangle$. Finally, the second X gate will restore the original basis states, but now with both amplitudes having acquired an additional phase of $-1$. This means our state has been multiplied by $-1$, achieving the required global phase change."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__global_phase_minusone_solution",
+                                "code": "namespace Kata {\n    operation GlobalPhaseChange (q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n        X(q);\n        Z(q);\n        X(q);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__global_phase_i",
+                    "title": "Global Phase i",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> A qubit in an arbitrary state $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$.</p>\n<p><strong>Goal:</strong> Use several Pauli gates to change the qubit state to $i|\\psi\\rangle = i\\alpha|0\\rangle + i\\beta|1\\rangle$.</p>\n",
+                        "asMarkdown": "**Input:** A qubit in an arbitrary state $|\\\\psi\\\\rangle = \\\\alpha|0\\\\rangle + \\\\beta|1\\\\rangle$.\n\n**Goal:** Use several Pauli gates to change the qubit state to $i|\\\\psi\\\\rangle = i\\\\alpha|0\\\\rangle + i\\\\beta|1\\\\rangle$."
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__global_phase_i__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We need to apply a gate which applies a global phase of $i$, i.e. $|\\psi\\rangle \\rightarrow i|\\psi\\rangle$.\nThe matrix representation of such a gate is $\\begin{bmatrix} i &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} = i\\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; 1 \\end{bmatrix} = iI$.\nSince we are restricted to the Pauli gates, we use the property that a product of any two distinct Pauli gates equals the third gate with a $+i$ or a $-i$ global phase, therefore the product of all three Pauli gates is $XYZ = iI$.\n$$\n\\begin{bmatrix} 0 &amp; 1 \\\\ 1 &amp; 0 \\end{bmatrix}\\begin{bmatrix} 0 &amp; -i \\\\ i &amp; 0 \\end{bmatrix}\\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; -1 \\end{bmatrix} = \n\\begin{bmatrix} i &amp; 0 \\\\ 0 &amp; i \\end{bmatrix}\n$$</p>\n<blockquote>\n<p>Remember the rightmost gates in mathematical notation are applied first in Q# code. Hence we first apply the $Z$ gate, followed by the $Y$ gate, and finally the $X$ gate.</p>\n</blockquote>\n",
+                                "asMarkdown": "\nWe need to apply a gate which applies a global phase of $i$, i.e. $|\\psi\\rangle \\rightarrow i|\\psi\\rangle$.\nThe matrix representation of such a gate is $\\begin{bmatrix} i & 0 \\\\\\ 0 & i \\end{bmatrix} = i\\begin{bmatrix} 1 & 0 \\\\\\ 0 & 1 \\end{bmatrix} = iI$.\nSince we are restricted to the Pauli gates, we use the property that a product of any two distinct Pauli gates equals the third gate with a $+i$ or a $-i$ global phase, therefore the product of all three Pauli gates is $XYZ = iI$.\n$$\n\\begin{bmatrix} 0 & 1 \\\\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 0 & -i \\\\\\ i & 0 \\end{bmatrix}\\begin{bmatrix} 1 & 0 \\\\\\ 0 & -1 \\end{bmatrix} = \n\\begin{bmatrix} i & 0 \\\\\\ 0 & i \\end{bmatrix}\n$$\n\n> Remember the rightmost gates in mathematical notation are applied first in Q# code. Hence we first apply the $Z$ gate, followed by the $Y$ gate, and finally the $X$ gate."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__global_phase_i_solution",
+                                "code": "namespace Kata {\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n        Y(q);\n        X(q);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "lesson",
                     "id": "identity_gate",
@@ -1322,7 +1382,7 @@ export default {
                         {
                             "type": "text-content",
                             "asHtml": "<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 is represented by the identity matrix, and does not 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 $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$</th>\n</tr>\n<tr>\n<td>$I$</td>\n<td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n<td>$|0\\rangle\\langle0| + |1\\rangle\\langle1|$</td>\n<td>$I|\\psi\\rangle = |\\psi\\rangle$</td>\n</tr>\n</table>",
-                            "asMarkdown": "\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 is represented by the identity matrix, and does not 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 $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$</th>\n</tr>\n<tr>\n<td>$I$</td>\n<td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n<td>$|0\\rangle\\langle0| + |1\\rangle\\langle1|$</td>\n<td>$I|\\psi\\rangle = |\\psi\\rangle$</td>\n</tr>\n</table>"
+                            "asMarkdown": "\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 is represented by the identity matrix, and does not 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 $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$</th>\n</tr>\n<tr>\n<td>$I$</td>\n<td>$\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$</td>\n<td>$|0\\rangle\\langle0| + |1\\rangle\\langle1|$</td>\n<td>$I|\\psi\\rangle = |\\psi\\rangle$</td>\n</tr>\n</table>"
                         }
                     ]
                 },
@@ -1338,6 +1398,36 @@ export default {
                         }
                     ]
                 },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__basis_change",
+                    "title": "Basis Change",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input</strong>: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.</p>\n<p><strong>Goal</strong>: Change the state of the qubit as follows:</p>\n<ul>\n<li>If the qubit is in state $|0\\rangle$, change its state to $|+\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle + |1\\rangle\\big)$.</li>\n<li>If the qubit is in state $|1\\rangle$, change its state to $|-\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle - |1\\rangle\\big)$.</li>\n<li>If the qubit is in superposition, change its state according to the effect on basis vectors.</li>\n</ul>\n",
+                        "asMarkdown": "**Input**: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n\n**Goal**: Change the state of the qubit as follows:\n\n- If the qubit is in state $|0\\rangle$, change its state to $|+\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle + |1\\rangle\\big)$.\n- If the qubit is in state $|1\\rangle$, change its state to $|-\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle - |1\\rangle\\big)$.\n- If the qubit is in superposition, change its state according to the effect on basis vectors.\n"
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__basis_change__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation BasisChange (q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n     \n    }\n}\n\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We can recognize that the Hadamard gate changes states $|0\\rangle$ and $|1\\rangle$ to $|+\\rangle$ and $|-\\rangle$, respectively, and vice versa.</p>\n<p>As a reminder, the Hadamard gate is defined by the following matrix:</p>\n<p>$$\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1 &amp; 1 \\\\1 &amp; -1\\end{bmatrix}\n$$</p>\n<p>For example, we can work out $H|1\\rangle$ as follows:</p>\n<p>$$\nH|1\\rangle=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 &amp; 1 \\\\1 &amp; -1\\end{bmatrix}\n\\begin{bmatrix} 0\\\\ 1\\end{bmatrix}=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1 \\cdot 0 + 1 \\cdot 1 \\\\1 \\cdot 0 + (-1) \\cdot 1\\end{bmatrix}=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1\\\\ -1\\\\ \\end{bmatrix}=\n\\frac{1}{\\sqrt{2}} \\big(|0\\rangle - |1\\rangle\\big) = |-\\rangle\n$$</p>\n<p>Similarly, we can consider the effect of the Hadamard gate on the superposition state $|\\psi\\rangle = 0.6|0\\rangle + 0.8|1\\rangle$ (rounding the numbers to 4 decimal places):</p>\n<p>$$\nH|\\psi⟩ =\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 &amp; 1 \\\\ 1 &amp; -1 \\end{bmatrix}\n \\begin{bmatrix} \\alpha\\\\ \\beta\\\\ \\end{bmatrix} =\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} \\alpha + \\beta\\\\ \\alpha - \\beta\\\\ \\end{bmatrix}=\n0.7071\\begin{bmatrix} 1.4\\\\ -0.2\\\\ \\end{bmatrix} =\n\\begin{bmatrix}\n   0.98994\\\\ -0.14142\\\\ \\end{bmatrix} =\n   0.9899|0\\rangle - 0.1414|1\\rangle\n$$</p>\n",
+                                "asMarkdown": "\nWe can recognize that the Hadamard gate changes states $|0\\rangle$ and $|1\\rangle$ to $|+\\rangle$ and $|-\\rangle$, respectively, and vice versa.\n\nAs a reminder, the Hadamard gate is defined by the following matrix:\n\n$$\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1 & 1 \\\\\\1 & -1\\end{bmatrix}\n$$\n\nFor example, we can work out $H|1\\rangle$ as follows:\n\n$$\nH|1\\rangle=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\\\1 & -1\\end{bmatrix}\n\\begin{bmatrix} 0\\\\\\ 1\\end{bmatrix}=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1 \\cdot 0 + 1 \\cdot 1 \\\\\\1 \\cdot 0 + (-1) \\cdot 1\\end{bmatrix}=\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix}1\\\\\\ -1\\\\\\ \\end{bmatrix}=\n\\frac{1}{\\sqrt{2}} \\big(|0\\rangle - |1\\rangle\\big) = |-\\rangle\n$$\n\nSimilarly, we can consider the effect of the Hadamard gate on the superposition state $|\\psi\\rangle = 0.6|0\\rangle + 0.8|1\\rangle$ (rounding the numbers to 4 decimal places):\n\n$$\nH|\\psi⟩ =\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\\\ 1 & -1 \\end{bmatrix}\n \\begin{bmatrix} \\alpha\\\\\\ \\beta\\\\\\ \\end{bmatrix} =\n\\frac{1}{\\sqrt{2}}\\begin{bmatrix} \\alpha + \\beta\\\\\\ \\alpha - \\beta\\\\\\ \\end{bmatrix}=\n0.7071\\begin{bmatrix} 1.4\\\\\\ -0.2\\\\\\ \\end{bmatrix} =\n\\begin{bmatrix}\n   0.98994\\\\\\ -0.14142\\\\\\ \\end{bmatrix} =\n   0.9899|0\\rangle - 0.1414|1\\rangle\n$$"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__basis_change_solution",
+                                "code": "namespace Kata {\n    operation BasisChange (q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "exercise",
                     "id": "single_qubit_gates__prepare_minus",
@@ -1380,6 +1470,46 @@ export default {
                         }
                     ]
                 },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__phase_i",
+                    "title": "Relative Phase i",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.</p>\n<p><strong>Goal:</strong> Change the qubit state to $\\alpha |0\\rangle + {\\color{red}i}\\beta |1\\rangle$ (add a relative phase $i$ to $|1\\rangle$ component of the superposition).</p>\n",
+                        "asMarkdown": "**Input:** A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n\n**Goal:** Change the qubit state to $\\alpha |0\\rangle + {\\color{red}i}\\beta |1\\rangle$ (add a relative phase $i$ to $|1\\rangle$ component of the superposition).\n"
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__phase_i__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation PhaseFlip (q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}\n\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<h4>Solution 1</h4>\n<p>We can recognize that the $S$ gate performs this particular relative phase addition to the $|1\\rangle$ basis state. As a reminder,</p>\n<p>$$\nS =\n\\begin{bmatrix}1 &amp; 0\\\\ 0 &amp; i\\end{bmatrix}\n$$</p>\n<p>Let&#39;s see the effect of this gate on the general superposition $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.</p>\n<p>$$\n \\begin{bmatrix}1 &amp; 0 \\\\ 0 &amp; i \\end{bmatrix}\n \\begin{bmatrix}\\alpha\\\\ \\beta\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1\\cdot\\alpha + 0\\cdot\\beta\\\\ 0\\cdot\\alpha + i\\cdot\\beta \\end{bmatrix}=\n \\begin{bmatrix}\\alpha\\\\ i\\beta\\\\ \\end{bmatrix}\n$$</p>\n<p>It is therefore easy to see that when $|\\psi\\rangle = 0.6|0\\rangle +  0.8|1\\rangle, S|\\psi\\rangle =  0.6|0\\rangle + 0.8i|1\\rangle$.</p>\n",
+                                "asMarkdown": "\n#### Solution 1\n\nWe can recognize that the $S$ gate performs this particular relative phase addition to the $|1\\rangle$ basis state. As a reminder,\n\n$$\nS =\n\\begin{bmatrix}1 & 0\\\\\\ 0 & i\\end{bmatrix}\n$$\n\nLet's see the effect of this gate on the general superposition $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n\n$$\n \\begin{bmatrix}1 & 0 \\\\\\ 0 & i \\end{bmatrix}\n \\begin{bmatrix}\\alpha\\\\\\ \\beta\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1\\cdot\\alpha + 0\\cdot\\beta\\\\\\ 0\\cdot\\alpha + i\\cdot\\beta \\end{bmatrix}=\n \\begin{bmatrix}\\alpha\\\\\\ i\\beta\\\\\\ \\end{bmatrix}\n$$\n\nIt is therefore easy to see that when $|\\psi\\rangle = 0.6|0\\rangle +  0.8|1\\rangle, S|\\psi\\rangle =  0.6|0\\rangle + 0.8i|1\\rangle$."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__phase_i_solution_a",
+                                "code": "namespace Kata {\n    operation PhaseFlip (q : Qubit) : Unit is Adj + Ctl {\n        S(q);\n    }\n}"
+                            },
+                            {
+                                "type": "text-content",
+                                "asHtml": "<h4>Solution 2</h4>\n<p>Alternatively, see the Complex Relative Phase task later in the kata for an explanation of using $R1$ gate to implement the same transformation.</p>\n",
+                                "asMarkdown": "\n#### Solution 2\n\nAlternatively, see the Complex Relative Phase task later in the kata for an explanation of using $R1$ gate to implement the same transformation."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates_phase_i_solution_b",
+                                "code": "namespace Kata {\n    operation PhaseFlip (q : Qubit) : Unit is Adj + Ctl {\n        open Microsoft.Quantum.Math;\n        R1(0.5 * PI(), q);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "exercise",
                     "id": "single_qubit_gates__three_quarters_pi_phase",
@@ -1422,6 +1552,66 @@ export default {
                         }
                     ]
                 },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__complex_phase",
+                    "title": "Complex Relative Phase",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>Angle $\\alpha$, in radians, represented as Double.</li>\n<li>A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.</li>\n</ol>\n<p><strong>Goal:</strong> Change the state of the qubit as follows:</p>\n<ul>\n<li>If the qubit is in state $|0\\rangle$, don&#39;t change its state.</li>\n<li>If the qubit is in state $|1\\rangle$, change its state to $e^{i\\alpha} |1\\rangle$.</li>\n<li>If the qubit is in superposition, change its state according to the effect on basis vectors: $\\beta |0\\rangle + {\\color{red}{e^{i\\alpha}}} \\gamma |1\\rangle$.</li>\n</ul>\n",
+                        "asMarkdown": "**Inputs:**\n\n1. Angle $\\alpha$, in radians, represented as Double.\n2. A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.\n\n**Goal:** Change the state of the qubit as follows:\n\n- If the qubit is in state $|0\\rangle$, don't change its state.\n- If the qubit is in state $|1\\rangle$, change its state to $e^{i\\alpha} |1\\rangle$.\n- If the qubit is in superposition, change its state according to the effect on basis vectors: $\\beta |0\\rangle + {\\color{red}{e^{i\\alpha}}} \\gamma |1\\rangle$.\n"
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__complex_phase__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation PhaseChange (alpha : Double, q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}\n\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We know that:</p>\n<p>$$\nR1(\\alpha)=\n \\begin{bmatrix}1 &amp; 0\\\\0 &amp; \\color{red}{e^{i\\alpha}}\\end{bmatrix}\n$$</p>\n<p>So we have:</p>\n<p>$$\nR1(\\beta |0\\rangle + \\gamma |1\\rangle) =\n \\begin{bmatrix}1 &amp; 0 \\\\0 &amp; \\color{red}{e^{i\\alpha}} \\end{bmatrix}\n \\begin{bmatrix}\\beta\\\\ \\gamma\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1 \\cdot \\beta + 0 \\cdot \\gamma\\\\ 0 \\cdot \\beta + {\\color{red}{e^{i\\alpha}}} \\cdot \\gamma\\end{bmatrix}=\n \\begin{bmatrix}\\beta\\\\ {\\color{red}{e^{i\\alpha}}}\\gamma\\end{bmatrix}=\n \\beta |0\\rangle + {\\color{red}{e^{i\\alpha}}} \\gamma |1\\rangle\n$$</p>\n<blockquote>\n<p>Suppose now that $\\alpha = \\frac{\\pi}{2}$.\nThen $e^{i\\alpha}= \\cos\\frac{\\pi}{2} + i\\sin\\frac{\\pi}{2}$.\nAnd, since $\\cos\\frac{\\pi}{2}= 0$ and $\\sin\\frac{\\pi}{2} = 1$, then we have that $\\cos\\frac{\\pi}{2} + i \\sin\\frac{\\pi}{2} = i$, and<br>$R1(\\frac{\\pi}{2}) = S$, which we used in the second solution to the task &quot;Relative Phase i&quot;.</p>\n</blockquote>\n",
+                                "asMarkdown": "\nWe know that:\n\n$$\nR1(\\alpha)=\n \\begin{bmatrix}1 & 0\\\\\\0 & \\color{red}{e^{i\\alpha}}\\end{bmatrix}\n$$\n\nSo we have:\n\n$$\nR1(\\beta |0\\rangle + \\gamma |1\\rangle) =\n \\begin{bmatrix}1 & 0 \\\\\\0 & \\color{red}{e^{i\\alpha}} \\end{bmatrix}\n \\begin{bmatrix}\\beta\\\\\\ \\gamma\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}1 \\cdot \\beta + 0 \\cdot \\gamma\\\\\\ 0 \\cdot \\beta + {\\color{red}{e^{i\\alpha}}} \\cdot \\gamma\\end{bmatrix}=\n \\begin{bmatrix}\\beta\\\\\\ {\\color{red}{e^{i\\alpha}}}\\gamma\\end{bmatrix}=\n \\beta |0\\rangle + {\\color{red}{e^{i\\alpha}}} \\gamma |1\\rangle\n$$\n\n> Suppose now that $\\alpha = \\frac{\\pi}{2}$.\n> Then $e^{i\\alpha}= \\cos\\frac{\\pi}{2} + i\\sin\\frac{\\pi}{2}$.\n> And, since $\\cos\\frac{\\pi}{2}= 0$ and $\\sin\\frac{\\pi}{2} = 1$, then we have that $\\cos\\frac{\\pi}{2} + i \\sin\\frac{\\pi}{2} = i$, and  \n> $R1(\\frac{\\pi}{2}) = S$, which we used in the second solution to the task \"Relative Phase i\"."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__complex_phase_solution",
+                                "code": "namespace Kata {\n    operation PhaseChange (alpha : Double, q : Qubit) : Unit is Adj + Ctl {\n        R1(alpha, q); \n    }\n}\n\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "single_qubit_gates__amplitude_change",
+                    "title": "Amplitude Change",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>Angle $\\alpha$, in radians, represented as Double.</li>\n<li>A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.</li>\n</ol>\n<p><strong>Goal:</strong> Change the state of the qubit as follows:</p>\n<ul>\n<li>If the qubit is in state $|0\\rangle$, change its state to $\\cos \\alpha |0\\rangle + \\sin \\alpha |1\\rangle$.</li>\n<li>If the qubit is in state $|1\\rangle$, change its state to $-\\sin \\alpha |0\\rangle + \\cos \\alpha |1\\rangle$.</li>\n<li>If the qubit is in superposition, change its state according to the effect on basis vectors.</li>\n</ul>\n",
+                        "asMarkdown": "**Inputs:**\n\n1. Angle $\\alpha$, in radians, represented as Double.\n2. A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.\n\n**Goal:** Change the state of the qubit as follows:\n\n- If the qubit is in state $|0\\rangle$, change its state to $\\cos \\alpha |0\\rangle + \\sin \\alpha |1\\rangle$.\n- If the qubit is in state $|1\\rangle$, change its state to $-\\sin \\alpha |0\\rangle + \\cos \\alpha |1\\rangle$.\n- If the qubit is in superposition, change its state according to the effect on basis vectors.\n"
+                    },
+                    "sourceIds": [
+                        "single_qubit_gates__amplitude_change__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation AmplitudeChange (alpha : Double, q : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}\n\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We can recognize that we need to use one of the rotation gates Rx, Ry, and Rz (named because they &quot;rotate&quot; the qubit state in the three dimensional space visualized as the Bloch sphere about the x, y, and z axes, respectively), since they involve angle parameters. Of these three gates, only Ry rotates the basis states $|0\\rangle$ and $|1\\rangle$ to have real amplitudes (the other two gates introduce complex coefficients).</p>\n<p>As a reminder,</p>\n<p>$$\nR_{y}(\\theta) =\n\\begin{bmatrix}\\cos \\frac{\\theta}{2} &amp; -\\sin \\frac{\\theta}{2}\\\\ \\sin \\frac{\\theta}{2} &amp; \\cos \\frac{\\theta}{2}\\end{bmatrix}\n$$</p>\n<p>Let&#39;s see its effect on the $|0\\rangle$ state:</p>\n<p>$$\nR_y(\\theta)|0\\rangle =\n\\begin{bmatrix}\\cos \\frac{\\theta}{2} &amp; -\\sin \\frac{\\theta}{2}\\\\ \\sin \\frac{\\theta}{2} &amp; \\cos \\frac{\\theta}{2} \\end{bmatrix}\n\\begin{bmatrix}1\\\\ 0\\\\ \\end{bmatrix}=\n\\begin{bmatrix}\\cos \\frac{\\theta}{2}\\cdot1 - \\sin \\frac{\\theta}{2}\\cdot0\\\\ \\sin \\frac{\\theta}{2}\\cdot1 + \\cos \\frac{\\theta}{2}\\cdot0\n\\end{bmatrix}=\n\\begin{bmatrix}\\cos \\frac{\\theta}{2}\\\\ \\sin \\frac{\\theta}{2}\\end{bmatrix}=\n\\cos\\frac{\\theta}{2} |0\\rangle + \\sin\\frac{\\theta}{2} |1\\rangle\n$$</p>\n<p>Recall that when applying a gate, you can tell what its matrix does to the basis states by looking at its columns: the first column of the matrix is the state into which it will transform the $|0\\rangle$ state, and the second column is the state into which it will transform the $|1\\rangle$ state.\nOne of the examples used by the testing harness has $\\beta = 0.6, \\gamma = 0.8$ and $\\alpha = 1.0471975511965976 = \\frac{\\pi}{3}$.\nSince $\\cos \\frac{\\pi}{3} = 0.5$ and $\\sin \\frac{\\pi}{3} = 0.8660$, working to 4 decimal places, we can use $\\frac{\\theta}{2} = \\alpha$ to compute:</p>\n<p>$$\nR_{y}(\\theta) |\\psi\\rangle=\n \\begin{bmatrix}\\cos \\frac{\\theta}{2} &amp; -\\sin \\frac{\\theta}{2}\\\\ \\sin \\frac{\\theta}{2} &amp; \\cos \\frac{\\theta}{2} \\end{bmatrix}\n  \\begin{bmatrix}\\beta\\\\ \\gamma\\\\ \\end{bmatrix}=\n  \\begin{bmatrix}\\cos \\frac{\\theta}{2}\\cdot\\beta - \\sin \\frac{\\theta}{2}\\cdot\\gamma\\\\ \\sin \\frac{\\theta}{2}\\cdot\\beta +\\cos \\frac{\\theta}{2}\\cdot\\gamma \\end{bmatrix}=\n \\begin{bmatrix} 0.6\\cdot\\cos \\frac{\\pi}{3} -0.8\\cdot\\sin \\frac{\\pi}{3}\\\\0.6\\cdot\\sin \\frac{\\pi}{3} +0.8\\cdot\\cos \\frac{\\pi}{3}\\end{bmatrix}=\n \\begin{bmatrix}0.3 - 0.6928\\\\ 0.5196 + 0.4\\end{bmatrix}=\n\\begin{bmatrix}-0.3928\\\\ 0.9196\\\\ \\end{bmatrix}\n$$</p>\n<p>Notice that we used $\\frac{\\theta}{2} = \\alpha$; this means that in the Q# code we need to pass the angle $\\theta = 2\\alpha$.</p>\n",
+                                "asMarkdown": "\nWe can recognize that we need to use one of the rotation gates Rx, Ry, and Rz (named because they \"rotate\" the qubit state in the three dimensional space visualized as the Bloch sphere about the x, y, and z axes, respectively), since they involve angle parameters. Of these three gates, only Ry rotates the basis states $|0\\rangle$ and $|1\\rangle$ to have real amplitudes (the other two gates introduce complex coefficients).\n\nAs a reminder,\n\n$$\nR_{y}(\\theta) =\n\\begin{bmatrix}\\cos \\frac{\\theta}{2} & -\\sin \\frac{\\theta}{2}\\\\\\ \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2}\\end{bmatrix}\n$$\n\nLet's see its effect on the $|0\\rangle$ state:\n\n$$\nR_y(\\theta)|0\\rangle =\n\\begin{bmatrix}\\cos \\frac{\\theta}{2} & -\\sin \\frac{\\theta}{2}\\\\\\ \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2} \\end{bmatrix}\n\\begin{bmatrix}1\\\\\\ 0\\\\\\ \\end{bmatrix}=\n\\begin{bmatrix}\\cos \\frac{\\theta}{2}\\cdot1 - \\sin \\frac{\\theta}{2}\\cdot0\\\\\\ \\sin \\frac{\\theta}{2}\\cdot1 + \\cos \\frac{\\theta}{2}\\cdot0\n\\end{bmatrix}=\n\\begin{bmatrix}\\cos \\frac{\\theta}{2}\\\\\\ \\sin \\frac{\\theta}{2}\\end{bmatrix}=\n\\cos\\frac{\\theta}{2} |0\\rangle + \\sin\\frac{\\theta}{2} |1\\rangle\n$$\n\nRecall that when applying a gate, you can tell what its matrix does to the basis states by looking at its columns: the first column of the matrix is the state into which it will transform the $|0\\rangle$ state, and the second column is the state into which it will transform the $|1\\rangle$ state.\nOne of the examples used by the testing harness has $\\beta = 0.6, \\gamma = 0.8$ and $\\alpha = 1.0471975511965976 = \\frac{\\pi}{3}$.\nSince $\\cos \\frac{\\pi}{3} = 0.5$ and $\\sin \\frac{\\pi}{3} = 0.8660$, working to 4 decimal places, we can use $\\frac{\\theta}{2} = \\alpha$ to compute:\n\n$$\nR_{y}(\\theta) |\\psi\\rangle=\n \\begin{bmatrix}\\cos \\frac{\\theta}{2} & -\\sin \\frac{\\theta}{2}\\\\\\ \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2} \\end{bmatrix}\n  \\begin{bmatrix}\\beta\\\\\\ \\gamma\\\\\\ \\end{bmatrix}=\n  \\begin{bmatrix}\\cos \\frac{\\theta}{2}\\cdot\\beta - \\sin \\frac{\\theta}{2}\\cdot\\gamma\\\\\\ \\sin \\frac{\\theta}{2}\\cdot\\beta +\\cos \\frac{\\theta}{2}\\cdot\\gamma \\end{bmatrix}=\n \\begin{bmatrix} 0.6\\cdot\\cos \\frac{\\pi}{3} -0.8\\cdot\\sin \\frac{\\pi}{3}\\\\\\0.6\\cdot\\sin \\frac{\\pi}{3} +0.8\\cdot\\cos \\frac{\\pi}{3}\\end{bmatrix}=\n \\begin{bmatrix}0.3 - 0.6928\\\\\\ 0.5196 + 0.4\\end{bmatrix}=\n\\begin{bmatrix}-0.3928\\\\\\ 0.9196\\\\\\ \\end{bmatrix}\n$$\n\nNotice that we used $\\frac{\\theta}{2} = \\alpha$; this means that in the Q# code we need to pass the angle $\\theta = 2\\alpha$."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "single_qubit_gates__amplitude_change_solution",
+                                "code": "namespace Kata {\n    operation AmplitudeChange (alpha : Double, q : Qubit) : Unit is Adj + Ctl {\n        Ry(2.0 * alpha, q);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "exercise",
                     "id": "single_qubit_gates__prepare_rotated_state",
@@ -2144,8 +2334,7 @@ export default {
                     },
                     "sourceIds": [
                         "single_qubit_measurements__distinguish_0_and_1__Verification.qs",
-                        "KatasLibrary.qs",
-                        "single_qubit_measurements__Common.qs"
+                        "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation IsQubitZero(q : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
                     "explainedSolution": {
@@ -2187,8 +2376,7 @@ export default {
                     },
                     "sourceIds": [
                         "single_qubit_measurements__distinguish_plus_and_minus__Verification.qs",
-                        "KatasLibrary.qs",
-                        "single_qubit_measurements__Common.qs"
+                        "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation IsQubitMinus(q : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
                     "explainedSolution": {
@@ -2230,8 +2418,7 @@ export default {
                     },
                     "sourceIds": [
                         "single_qubit_measurements__distinguish_orthogonal_states_1__Verification.qs",
-                        "KatasLibrary.qs",
-                        "single_qubit_measurements__Common.qs"
+                        "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    open Microsoft.Quantum.Math;\n\n    operation IsQubitPsiPlus(q : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
                     "explainedSolution": {
@@ -2261,8 +2448,7 @@ export default {
                     },
                     "sourceIds": [
                         "single_qubit_measurements__distinguish_orthogonal_states_2__Verification.qs",
-                        "KatasLibrary.qs",
-                        "single_qubit_measurements__Common.qs"
+                        "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation IsQubitA(alpha : Double, q : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
                     "explainedSolution": {
@@ -2292,8 +2478,7 @@ export default {
                     },
                     "sourceIds": [
                         "single_qubit_measurements__a_b_basis_measurements__Verification.qs",
-                        "KatasLibrary.qs",
-                        "single_qubit_measurements__Common.qs"
+                        "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation MeasureInABBasis(alpha : Double, q : Qubit) : Result {\n        // Implement your solution here...\n\n        return Zero;\n    }\n}\n",
                     "explainedSolution": {
@@ -2397,7 +2582,6 @@ export default {
                     },
                     "sourceIds": [
                         "multi_qubit_measurements__full_measurements__Verification.qs",
-                        "multi_qubit_measurements__Common.qs",
                         "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation BasisStateMeasurement(qs : Qubit[]) : Int {\n        // Implement your solution here...\n\n        return -1;\n    }\n}\n",
@@ -2472,7 +2656,6 @@ export default {
                     },
                     "sourceIds": [
                         "multi_qubit_measurements__partial_measurements_for_system__Verification.qs",
-                        "multi_qubit_measurements__Common.qs",
                         "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation IsPlusPlusMinus(qs : Qubit[]) : Int {\n        // Implement your solution here...\n\n        return -1;\n    }\n}\n",
@@ -2515,7 +2698,6 @@ export default {
                     },
                     "sourceIds": [
                         "multi_qubit_measurements__state_modification__Verification.qs",
-                        "multi_qubit_measurements__Common.qs",
                         "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation StateSelection(qs : Qubit[], ind : Int) : Unit {\n        // Implement your solution here...\n\n    }\n}\n",
@@ -2558,7 +2740,6 @@ export default {
                     },
                     "sourceIds": [
                         "multi_qubit_measurements__state_preparation__Verification.qs",
-                        "multi_qubit_measurements__Common.qs",
                         "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation PostSelection(qs : Qubit[]) : Unit {\n        // Implement your solution here...\n\n    }\n}\n",
@@ -2601,7 +2782,6 @@ export default {
                     },
                     "sourceIds": [
                         "multi_qubit_measurements__joint_measurements__Verification.qs",
-                        "multi_qubit_measurements__Common.qs",
                         "KatasLibrary.qs"
                     ],
                     "placeholderCode": "namespace Kata {\n    operation ParityMeasurement(qs : Qubit[]) : Int {\n        // Implement your solution here...\n\n        return -1;\n    }\n}\n",
@@ -3721,11 +3901,11 @@ export default {
     "globalCodeSources": [
         {
             "id": "getting_started__flip_qubit__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n\n    operation FlipQubit(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.FlipQubit(register[0]);\n        let reference = register => FlipQubit(register[0]);\n        let isCorrect = CheckOperationsEquivalence(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n            Message(\"Congratulations! You have solved your first exercise.\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Look out for hints when your solution is incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the |0〉 state and compare it with the effect it \" +\n                \"is expected to have.\");\n            use target = Qubit[1]; // |0〉\n            ShowQuantumStateComparison(target, solution, reference);\n            ResetAll(target);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n\n    operation FlipQubit(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.FlipQubit(register[0]);\n        let reference = register => FlipQubit(register[0]);\n        let isCorrect = CheckOperationsEquivalence(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n            Message(\"Congratulations! You have solved your first exercise.\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Look out for hints when your solution is incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the |0〉 state and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, (qs => ()), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "KatasLibrary.qs",
-            "code": "// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nnamespace Microsoft.Quantum.Katas {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Random;\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically for all input states.\n    /// This operation is implemented by using the Choi–Jamiołkowski isomorphism.\n    operation CheckOperationsEquivalence(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use (control, target) = (Qubit[inputSize], Qubit[inputSize]);\n        within {\n            EntangleRegisters(control, target);\n        }\n        apply {\n            op(target);\n            Adjoint reference(target);\n        }\n\n        let areEquivalent = CheckAllZero(control + target);\n        ResetAll(control + target);\n        areEquivalent\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically (including global phase) for all input states.\n    /// This is done through controlled versions of the operations instead of plain ones which convert the global phase\n    /// into a relative phase that can be detected.\n    operation CheckOperationsEquivalenceStrict(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        let controlledOp = register => Controlled op(register[...0], register[1...]);\n        let controlledReference = register => Controlled reference(register[...0], register[1...]);\n        let areEquivalent = CheckOperationsEquivalence(controlledOp, controlledReference, inputSize + 1);\n        areEquivalent\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits.\n    operation CheckOperationsEquivalenceOnZeroState(\n        op : (Qubit[] => Unit),\n        reference : (Qubit[] => Unit is Adj),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use target = Qubit[inputSize];\n        op(target);\n        Adjoint reference(target);\n        let isCorrect = CheckAllZero(target);\n        ResetAll(target);\n        isCorrect\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits.\n    /// This operation introduces a control qubit to convert a global phase into a relative phase to be able to detect\n    /// it.\n    operation CheckOperationsEquivalenceOnZeroStateStrict(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use control = Qubit();\n        use target = Qubit[inputSize];\n        within {\n            H(control);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n    /// # Summary\n    /// Shows the effect a quantum operation has on the quantum state.\n    operation ShowEffectOnQuantumState(targetRegister : Qubit[], op : (Qubit[] => Unit is Adj + Ctl)) : Unit {\n        Message(\"Quantum state before applying the operation:\");\n        DumpMachine();\n\n        // Apply the operation, dump the simulator state and \"undo\" the operation by applying the adjoint.\n        Message(\"Quantum state after applying the operation:\");\n        op(targetRegister);\n        DumpMachine();\n        Adjoint op(targetRegister);\n    }\n\n    /// # Summary\n    /// Shows the comparison of the quantum state between a specific operation and a reference operation.\n    operation ShowQuantumStateComparison(\n        targetRegister : Qubit[],\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl))\n    : Unit {\n        Message(\"Initial quantum state:\");\n        DumpMachine();\n\n        // Apply the reference operation, dump the simulator state and \"undo\" the operation by applying the adjoint.\n        reference(targetRegister);\n        Message(\"Expected quantum state after applying the operation:\");\n        DumpMachine();\n        Adjoint reference(targetRegister);\n\n        // Apply the specific operation, dump the simulator state and \"undo\" the operation by applying the adjoint.\n        op(targetRegister);\n        Message(\"Actual quantum state after applying the operation:\");\n        DumpMachine();\n        Adjoint op(targetRegister);\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits. If they don't, prints user feedback.\n    operation CheckOperationsEquivalenceOnZeroStateWithFeedback(\n        testImpl : (Qubit[] => Unit is Adj + Ctl),\n        refImpl : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n\n        let isCorrect = CheckOperationsEquivalenceOnZeroState(testImpl, refImpl, inputSize);\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[inputSize];\n            ShowQuantumStateComparison(target, testImpl, refImpl);\n            ResetAll(target);\n        }\n        isCorrect\n    }\n\n\n    internal operation EntangleRegisters(\n        control : Qubit[],\n        target : Qubit[]) : Unit is Adj + Ctl {\n        Fact(\n            Length(control) == Length(target),\n            $\"The length of qubit registers must be the same.\");\n\n        for index in IndexRange(control) {\n            H(control[index]);\n            CNOT(control[index], target[index]);\n        }\n    }\n\n\n    /// # Summary\n    /// Prepare a random uneven superposition state on the given qubit array.\n    operation PrepRandomState(qs : Qubit[]) : Unit {\n        for q in qs {\n            Ry(DrawRandomDouble(0.01, 0.99) * 2.0, q);\n        }\n    }\n}\n"
+            "code": "// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nnamespace Microsoft.Quantum.Katas {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Random;\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically for all input states.\n    /// This operation is implemented by using the Choi–Jamiołkowski isomorphism.\n    operation CheckOperationsEquivalence(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use (control, target) = (Qubit[inputSize], Qubit[inputSize]);\n        within {\n            EntangleRegisters(control, target);\n        }\n        apply {\n            op(target);\n            Adjoint reference(target);\n        }\n\n        let areEquivalent = CheckAllZero(control + target);\n        ResetAll(control + target);\n        areEquivalent\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically (including global phase) for all input states.\n    /// This is done through controlled versions of the operations instead of plain ones which convert the global phase\n    /// into a relative phase that can be detected.\n    operation CheckOperationsEquivalenceStrict(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        let controlledOp = register => Controlled op(register[...0], register[1...]);\n        let controlledReference = register => Controlled reference(register[...0], register[1...]);\n        let areEquivalent = CheckOperationsEquivalence(controlledOp, controlledReference, inputSize + 1);\n        areEquivalent\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits.\n    operation CheckOperationsEquivalenceOnZeroState(\n        op : (Qubit[] => Unit),\n        reference : (Qubit[] => Unit is Adj),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use target = Qubit[inputSize];\n        op(target);\n        Adjoint reference(target);\n        let isCorrect = CheckAllZero(target);\n        ResetAll(target);\n        isCorrect\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits.\n    /// This operation introduces a control qubit to convert a global phase into a relative phase to be able to detect\n    /// it.\n    operation CheckOperationsEquivalenceOnZeroStateStrict(\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int)\n    : Bool {\n        Fact(inputSize > 0, \"`inputSize` must be positive\");\n        use control = Qubit();\n        use target = Qubit[inputSize];\n        within {\n            H(control);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n\n    /// # Summary\n    /// Shows the comparison of the quantum state between a specific operation and a reference operation.\n    operation ShowQuantumStateComparison(\n        registerSize : Int,\n        initialState : Qubit[] => Unit,\n        op : Qubit[] => Unit,\n        reference : Qubit[] => Unit)\n    : Unit {\n        {\n            use register = Qubit[registerSize];\n            initialState(register);\n\n            Message(\"Initial quantum state:\");\n            DumpMachine();\n\n            // Apply the reference operation and dump the simulator state\n            reference(register);\n            Message(\"Expected quantum state after applying the operation:\");\n            DumpMachine();\n            ResetAll(register);\n        }\n\n        {\n            use register = Qubit[registerSize];\n            initialState(register);\n            // Apply the comparison operation and dump the simulator state\n            op(register);\n            Message(\"Actual quantum state after applying the operation:\");\n            DumpMachine();\n            ResetAll(register);\n        }\n    }\n\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the zero state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉 composed of\n    /// `inputSize` qubits. If they don't, prints user feedback.\n    operation CheckOperationsEquivalenceOnZeroStateWithFeedback(\n        testImpl : (Qubit[] => Unit),\n        refImpl : (Qubit[] => Unit is Adj),\n        inputSize : Int\n    ) : Bool {\n\n        let isCorrect = CheckOperationsEquivalenceOnZeroState(testImpl, refImpl, inputSize);\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            ShowQuantumStateComparison(inputSize, (qs => ()), testImpl, refImpl);\n        }\n        isCorrect\n    }\n\n\n    internal operation EntangleRegisters(\n        control : Qubit[],\n        target : Qubit[]) : Unit is Adj + Ctl {\n        Fact(\n            Length(control) == Length(target),\n            $\"The length of qubit registers must be the same.\");\n\n        for index in IndexRange(control) {\n            H(control[index]);\n            CNOT(control[index], target[index]);\n        }\n    }\n\n\n    /// # Summary\n    /// Prepare a random uneven superposition state on the given qubit array.\n    operation PrepRandomState(qs : Qubit[]) : Unit {\n        for q in qs {\n            Ry(DrawRandomDouble(0.01, 0.99) * 2.0, q);\n        }\n    }\n\n\n    // \"Framework\" operation for testing single-qubit tasks for distinguishing states of one qubit\n    // with Bool return\n    operation DistinguishTwoStates_SingleQubit(\n        statePrep : ((Qubit, Int) => Unit is Adj),\n        testImpl : (Qubit => Bool),\n        stateNames : String[],\n        preserveState : Bool) : Bool {\n\n        let nTotal = 100;\n        let nStates = 2;\n        mutable misclassifications = [0, size=nStates];\n\n        use q = Qubit();\n        for _ in 1 .. nTotal {\n            // get a random bit to define whether qubit will be in a state corresponding to true return (1) or to false one (0)\n            // state = 0 false return\n            // state = 1 true return\n            let state = DrawRandomInt(0, 1);\n\n            // do state prep: convert |0⟩ to outcome with false return or to outcome with true return depending on state\n            statePrep(q, state);\n\n            // get the solution's answer and verify if NOT a match, then differentiate what kind of mismatch\n            let ans = testImpl(q);\n            if ans != (state == 1) {\n                set misclassifications w/= state <- misclassifications[state] + 1;\n            }\n\n            // If the final state is to be preserved, check if it was not modified\n            if preserveState {\n                Adjoint statePrep(q, state);\n                if not CheckZero(q) {\n                    Message($\"Input quantum state {stateNames[state]} was not preserved during the measurement.\");\n                    Reset(q);\n                    return false;\n                }\n            } else {\n                Reset(q);\n            }\n        }\n\n        mutable totalMisclassifications = 0;\n        for i in 0 .. nStates - 1 {\n            if misclassifications[i] != 0 {\n                set totalMisclassifications += misclassifications[i];\n                Message($\"Misclassified {stateNames[i]} as {stateNames[1 - i]} in {misclassifications[i]} test runs.\");\n            }\n        }\n\n        totalMisclassifications == 0\n    }\n\n\n    // \"Framework\" operation for testing multi-qubit tasks for distinguishing states of an array of qubits\n    // with Int return\n    operation DistinguishStates_MultiQubit(\n        nQubits : Int,\n        nStates : Int,\n        statePrep : ((Qubit[], Int, Double) => Unit is Adj),\n        testImpl : (Qubit[] => Int),\n        preserveState : Bool,\n        stateNames : String[]) : Bool {\n\n        let nTotal = 100;\n        // misclassifications will store the number of times state i has been classified as state j (dimension nStates^2)\n        mutable misclassifications = [0, size = nStates * nStates];\n        // unknownClassifications will store the number of times state i has been classified as some invalid state (index < 0 or >= nStates)\n        mutable unknownClassifications = [0, size = nStates];\n\n        use qs = Qubit[nQubits];\n        for _ in 1 .. nTotal {\n            // get a random integer to define the state of the qubits\n            let state = DrawRandomInt(0, nStates - 1);\n            // get a random rotation angle to define the exact state of the qubits\n            // for some exercises, this value might be a dummy variable which does not matter\n            let alpha = DrawRandomDouble(0.0, 1.0) * PI();\n\n            // do state prep: convert |0...0⟩ to outcome with return equal to state\n            statePrep(qs, state, alpha);\n\n            // get the solution's answer and verify that it's a match, if not, increase the exact mismatch count\n            let ans = testImpl(qs);\n            if ans >= 0 and ans < nStates {\n                // classification result is a valid state index - check if is it correct\n                if ans != state {\n                    set misclassifications w/= ((state * nStates) + ans) <- (misclassifications[(state * nStates) + ans] + 1);\n                }\n            }\n            else {\n                // classification result is an invalid state index - file it separately\n                set unknownClassifications w/= state <- (unknownClassifications[state] + 1);\n            }\n\n            if preserveState {\n                // check that the state of the qubit after the operation is unchanged\n                Adjoint statePrep(qs, state, alpha);\n                if not CheckAllZero(qs) {\n                    Message($\"Input quantum state {stateNames[state]} was not preserved during the measurement.\");\n                    ResetAll(qs);\n                    return false;\n                }\n            } else {\n                // we're not checking the state of the qubit after the operation\n                ResetAll(qs);\n            }\n        }\n\n        mutable totalMisclassifications = 0;\n        for i in 0 .. nStates - 1 {\n            for j in 0 .. nStates - 1 {\n                if misclassifications[(i * nStates) + j] != 0 {\n                    set totalMisclassifications += misclassifications[i * nStates + j];\n                    Message($\"Misclassified {stateNames[i]} as {stateNames[j]} in {misclassifications[(i * nStates) + j]} test runs.\");\n                }\n            }\n            if unknownClassifications[i] != 0 {\n                set totalMisclassifications += unknownClassifications[i];\n                Message($\"Misclassified {stateNames[i]} as Unknown State in {unknownClassifications[i]} test runs.\");\n            }\n        }\n        totalMisclassifications == 0\n    }\n\n}\n"
         },
         {
             "id": "complex_arithmetic__powers_of_i__Verification.qs",
@@ -3829,35 +4009,59 @@ export default {
         },
         {
             "id": "single_qubit_gates__state_flip__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation StateFlip(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.StateFlip(register[0]);\n        let reference = register => StateFlip(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial);\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation StateFlip(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.StateFlip(register[0]);\n        let reference = register => StateFlip(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}"
+        },
+        {
+            "id": "single_qubit_gates__sign_flip__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation SignFlip(q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.SignFlip(register[0]);\n        let reference = register => SignFlip(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__y_gate__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        Y(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.ApplyY(register[0]);\n        let reference = register => ApplyY(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial); // 0.6|0〉 + 0.8|1〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation ApplyY(q : Qubit) : Unit is Adj + Ctl {\n        Y(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.ApplyY(register[0]);\n        let reference = register => ApplyY(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
+        },
+        {
+            "id": "single_qubit_gates__sign_flip_on_zero__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation SignFlipOnZero(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        Z(q);\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.SignFlipOnZero(register[0]);\n        let reference = register => SignFlipOnZero(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\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            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
+        },
+        {
+            "id": "single_qubit_gates__global_phase_minusone__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Intrinsic;\n\n\n    operation GlobalPhaseChange (q : Qubit) : Unit is Adj + Ctl {\n        Z(q);\n        X(q);\n        Z(q);\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.GlobalPhaseChange(register[0]);\n        let reference = register => GlobalPhaseChange(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__global_phase_i__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        Z(q);\n        Y(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.GlobalPhaseI(register[0]);\n        let reference = register => GlobalPhaseI(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial); // 0.6|0〉 + 0.8|1〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation GlobalPhaseI(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        Z(q);\n        Y(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.GlobalPhaseI(register[0]);\n        let reference = register => GlobalPhaseI(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
-            "id": "single_qubit_gates__sign_flip_on_zero__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation SignFlipOnZero(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        Z(q);\n        X(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.SignFlipOnZero(register[0]);\n        let reference = register => SignFlipOnZero(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\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            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial); // 0.6|0〉 + 0.8|1〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "id": "single_qubit_gates__basis_change__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation BasisChange(q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.BasisChange(register[0]);\n        let reference = register => BasisChange(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__prepare_minus__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.PrepareMinus(register[0]);\n        let reference = register => PrepareMinus(register[0]);\n        let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\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            Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                \"is expected to prepare.\");\n            use initial = Qubit(); // |0〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.PrepareMinus(register[0]);\n        let reference = register => PrepareMinus(register[0]);\n        let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\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            Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                \"is expected to prepare.\");\n            ShowQuantumStateComparison(1, qs => (), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
+        },
+        {
+            "id": "single_qubit_gates__phase_i__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Convert;\n\n    operation PhaseFlip (q : Qubit) : Unit is Adj + Ctl {\n        S(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.PhaseFlip(register[0]);\n        let reference = register => PhaseFlip(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__three_quarters_pi_phase__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation ThreeQuartersPiPhase(q : Qubit) : Unit is Adj + Ctl {\n        S(q);\n        T(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.ThreeQuartersPiPhase(register[0]);\n        let reference = register => ThreeQuartersPiPhase(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\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            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial); // 0.6|0〉 + 0.8|1〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation ThreeQuartersPiPhase(q : Qubit) : Unit is Adj + Ctl {\n        S(q);\n        T(q);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.ThreeQuartersPiPhase(register[0]);\n        let reference = register => ThreeQuartersPiPhase(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\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            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n            ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
+        },
+        {
+            "id": "single_qubit_gates__complex_phase__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Convert;\n\n    operation PhaseChange (alpha : Double, q : Qubit) : Unit is Adj+Ctl {\n        R1(alpha, q); \n    }\n\n    operation CheckSolution() : Bool {\n        for i in 0 .. 36 {\n            let alpha = ((2.0 * PI()) * IntAsDouble(i)) / 36.0;\n            let solution = register => Kata.PhaseChange(alpha, register[0]);\n            let reference = register => PhaseChange(alpha, register[0]);\n            let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}.\");\n                Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n                ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}"
+        },
+        {
+            "id": "single_qubit_gates__amplitude_change__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Convert;\n\n    operation AmplitudeChange (alpha : Double, q : Qubit) : Unit is Adj+Ctl {\n        Ry(2.0 * alpha, q);\n    }\n\n    operation CheckSolution() : Bool {\n        for i in 0 .. 36 {\n            let alpha = ((2.0 * PI()) * IntAsDouble(i)) / 36.0;\n            let solution = register => Kata.AmplitudeChange(alpha, register[0]);\n            let reference = register => AmplitudeChange(alpha, register[0]);\n            let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}.\");\n                Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have.\");\n                ShowQuantumStateComparison(1, qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0]), solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__prepare_rotated_state__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PrepareRotatedState (alpha : Double, beta : Double, q : Qubit) : Unit is Adj+Ctl {\n        let phi = ArcTan2(beta, alpha);\n        Rx(2.0 * phi, q);\n    }\n\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let i = IntAsDouble(i);\n            let alpha = Cos(i);\n            let beta = Sin(i);\n            let solution = register => Kata.PrepareRotatedState(alpha, beta, register[0]);\n            let reference = register => PrepareRotatedState(alpha, beta, register[0]);\n            let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}, beta = {beta}.\");\n                Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                    \"is expected to prepare.\");\n                use initial = Qubit(); // |0〉\n                ShowQuantumStateComparison([initial], solution, reference);\n                Reset(initial);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        Message(\"The solution was correct for all test cases.\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PrepareRotatedState (alpha : Double, beta : Double, q : Qubit) : Unit is Adj+Ctl {\n        let phi = ArcTan2(beta, alpha);\n        Rx(2.0 * phi, q);\n    }\n\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let i = IntAsDouble(i);\n            let alpha = Cos(i);\n            let beta = Sin(i);\n            let solution = register => Kata.PrepareRotatedState(alpha, beta, register[0]);\n            let reference = register => PrepareRotatedState(alpha, beta, register[0]);\n            let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}, beta = {beta}.\");\n                Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                    \"is expected to prepare.\");\n                ShowQuantumStateComparison(1, qs => (), solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        Message(\"The solution was correct for all test cases.\");\n        true\n    }\n}\n"
         },
         {
             "id": "single_qubit_gates__prepare_arbitrary_state__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PrepareArbitraryState (alpha : Double, beta : Double, theta : Double, q : Qubit) : Unit is Adj+Ctl {\n        let phi = ArcTan2(beta, alpha);\n        Ry(2.0 * phi, q);\n        R1(theta, q);\n    }\n\n    operation CheckSolution() : Bool {\n         for i in 0 .. 10 {\n            let i = IntAsDouble(i);\n            let alpha = Cos(i);\n            let beta = Sin(i);\n            let theta = Sin(i);\n            let solution = register => Kata.PrepareArbitraryState(alpha, beta, theta, register[0]);\n            let reference = register => PrepareArbitraryState(alpha, beta, theta, register[0]);\n            let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}, beta = {beta}, theta = {theta}.\");\n                Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                    \"is expected to prepare.\");\n                use initial = Qubit(); // |0〉\n                ShowQuantumStateComparison([initial], solution, reference);\n                Reset(initial);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        Message(\"The solution was correct for all test cases.\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PrepareArbitraryState (alpha : Double, beta : Double, theta : Double, q : Qubit) : Unit is Adj+Ctl {\n        let phi = ArcTan2(beta, alpha);\n        Ry(2.0 * phi, q);\n        R1(theta, q);\n    }\n\n    operation CheckSolution() : Bool {\n         for i in 0 .. 10 {\n            let i = IntAsDouble(i);\n            let alpha = Cos(i);\n            let beta = Sin(i);\n            let theta = Sin(i);\n            let solution = register => Kata.PrepareArbitraryState(alpha, beta, theta, register[0]);\n            let reference = register => PrepareArbitraryState(alpha, beta, theta, register[0]);\n            let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(solution, reference, 1);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message($\"The solution was incorrect for the test case alpha = {alpha}, beta = {beta}, theta = {theta}.\");\n                Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                    \"is expected to prepare.\");\n                ShowQuantumStateComparison(1, qs => (), solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        Message(\"The solution was correct for all test cases.\");\n        true\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__learn_basis_state_amplitudes__Verification.qs",
@@ -3881,11 +4085,11 @@ export default {
         },
         {
             "id": "multi_qubit_gates__compound_gate__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation CompoundGate (qs : Qubit[]) : Unit is Adj + Ctl {\n        S(qs[0]);\n        I(qs[1]); // this line can be omitted, since it doesn't change the qubit state\n        Y(qs[2]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.CompoundGate;\n        let reference = CompoundGate;\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 3);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            use initial = Qubit[3]; // |000〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial[0]);\n            Ry(ArcTan2(0.7, 0.4) * 2.0, initial[1]);\n            Ry(ArcTan2(0.6, 0.5) * 2.0, initial[2]);\n            ShowQuantumStateComparison(initial, solution, reference);\n            ResetAll(initial);\n        }\n\n        isCorrect\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation CompoundGate (qs : Qubit[]) : Unit is Adj + Ctl {\n        S(qs[0]);\n        I(qs[1]); // this line can be omitted, since it doesn't change the qubit state\n        Y(qs[2]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.CompoundGate;\n        let reference = CompoundGate;\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 3);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            ShowQuantumStateComparison(3, PrepRandomState, solution, reference);\n        }\n\n        isCorrect\n    }\n}"
         },
         {
             "id": "multi_qubit_gates__preparing_bell_state__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation BellState (qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        CNOT(qs[0], qs[1]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.BellState;\n        let reference = BellState;\n        let isCorrect = CheckOperationsEquivalenceOnZeroState(solution, reference, 2);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect :(\");\n            Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                \"is expected to prepare.\");\n            use initial = Qubit[2]; // |00〉\n            ShowQuantumStateComparison(initial, solution, reference);\n            ResetAll(initial);\n        }\n\n        isCorrect\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation BellState (qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        CNOT(qs[0], qs[1]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.BellState;\n        let reference = BellState;\n        let isCorrect = CheckOperationsEquivalenceOnZeroState(solution, reference, 2);\n\n        // Output different feedback to the user depending on whether the solution was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the state prepared by your solution and compare it with the state it \" +\n                \"is expected to prepare.\");\n            ShowQuantumStateComparison(2, (qs => ()), solution, reference);\n        }\n\n        isCorrect\n    }\n}"
         },
         {
             "id": "multi_qubit_gates__qubit_swap__Verification.qs",
@@ -3901,39 +4105,31 @@ export default {
         },
         {
             "id": "single_qubit_measurements__distinguish_0_and_1__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n\n    operation StatePrep_IsQubitZero (q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |1⟩\n            X(q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates(\n            StatePrep_IsQubitZero,\n            Kata.IsQubitZero,\n            [\"|1⟩\", \"|0⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
-        },
-        {
-            "id": "single_qubit_measurements__Common.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Random;\n\n    // \"Framework\" operation for testing single-qubit tasks for distinguishing states of one qubit\n    // with Bool return\n    operation DistinguishTwoStates(\n        statePrep : ((Qubit, Int) => Unit is Adj),\n        testImpl : (Qubit => Bool),\n        stateName : String[],\n        checkFinalState : Bool) : Bool {\n\n        let nTotal = 100;\n        let nStates = 2;\n        mutable misclassifications = Repeated(0, nStates);\n\n        use q = Qubit();\n        for i in 1 .. nTotal {\n            // get a random bit to define whether qubit will be in a state corresponding to true return (1) or to false one (0)\n            // state = 0 false return\n            // state = 1 true return\n            let state = DrawRandomInt(0, 1);\n\n            // do state prep: convert |0⟩ to outcome with false return or to outcome with true return depending on state\n            statePrep(q, state);\n\n            // get the solution's answer and verify if NOT a match, then differentiate what kind of mismatch\n            let ans = testImpl(q);\n            if ans != (state == 1) {\n                set misclassifications w/= state <- misclassifications[state] + 1;\n            }\n\n            // If the final state is to be verified, check if it matches the measurement outcome\n            if checkFinalState {\n                Adjoint statePrep(q, state);\n                Fact(CheckZero(q), \"Returned Bool value does not match the expected qubit state.\");\n            } else {\n                Reset(q);\n            }\n        }\n\n        mutable totalMisclassifications = 0;\n        for i in 0 .. nStates - 1 {\n            if misclassifications[i] != 0 {\n                set totalMisclassifications += misclassifications[i];\n                Message($\"Misclassified {stateName[i]} as {stateName[1 - i]} in {misclassifications[i]} test runs.\");\n            }\n        }\n\n        return totalMisclassifications == 0;\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation StatePrep_IsQubitZero (q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |1⟩\n            X(q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates_SingleQubit(\n            StatePrep_IsQubitZero,\n            Kata.IsQubitZero,\n            [\"|1⟩\", \"|0⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
         },
         {
             "id": "single_qubit_measurements__distinguish_plus_and_minus__Verification.qs",
-            "code": "namespace Kata.Verification {\n\n    // Distinguish |+❭ and |-❭ using Measure operation\n    operation StatePrep_IsQubitMinus (q : Qubit, state : Int) : Unit is Adj {\n        if state == 1 {\n            // convert |0⟩ to |-⟩\n            X(q);\n            H(q);\n        } else {\n            // convert |0⟩ to |+⟩\n            H(q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates(\n            StatePrep_IsQubitMinus,\n            Kata.IsQubitMinus,\n            [\"|+⟩\", \"|-⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    // Distinguish |+❭ and |-❭ using Measure operation\n    operation StatePrep_IsQubitMinus (q : Qubit, state : Int) : Unit is Adj {\n        if state == 1 {\n            // convert |0⟩ to |-⟩\n            X(q);\n            H(q);\n        } else {\n            // convert |0⟩ to |+⟩\n            H(q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates_SingleQubit(\n            StatePrep_IsQubitMinus,\n            Kata.IsQubitMinus,\n            [\"|+⟩\", \"|-⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
         },
         {
             "id": "single_qubit_measurements__distinguish_orthogonal_states_1__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Math;\n\n    // Distinguish specific orthogonal states\n    // |ψ₊⟩ =   0.6 * |0⟩ + 0.8 * |1⟩,\n    // |ψ₋⟩ =  -0.8 * |0⟩ + 0.6 * |1⟩.\n    operation StatePrep_IsQubitPsiPlus(q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |ψ₋⟩\n            X(q);\n            Ry(2.0 * ArcTan2(0.8, 0.6), q);\n        } else {\n            // convert |0⟩ to |ψ₊⟩\n            Ry(2.0 * ArcTan2(0.8, 0.6), q);\n        }\n    }\n\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates(\n            StatePrep_IsQubitPsiPlus,\n            Kata.IsQubitPsiPlus,\n            [\"|ψ₋⟩\", \"|ψ₊⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Katas;\n\n    // Distinguish specific orthogonal states\n    // |ψ₊⟩ =   0.6 * |0⟩ + 0.8 * |1⟩,\n    // |ψ₋⟩ =  -0.8 * |0⟩ + 0.6 * |1⟩.\n    operation StatePrep_IsQubitPsiPlus(q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |ψ₋⟩\n            X(q);\n            Ry(2.0 * ArcTan2(0.8, 0.6), q);\n        } else {\n            // convert |0⟩ to |ψ₊⟩\n            Ry(2.0 * ArcTan2(0.8, 0.6), q);\n        }\n    }\n\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishTwoStates_SingleQubit(\n            StatePrep_IsQubitPsiPlus,\n            Kata.IsQubitPsiPlus,\n            [\"|ψ₋⟩\", \"|ψ₊⟩\"],\n            false);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        isCorrect\n    }\n\n}\n"
         },
         {
             "id": "single_qubit_measurements__distinguish_orthogonal_states_2__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n\n    // Distinguish states |A❭ and |B❭\n    // |A⟩ =   cos(alpha) * |0⟩ - i sin(alpha) * |1⟩,\n    // |B⟩ = - i sin(alpha) * |0⟩ + cos(alpha) * |1⟩.\n    operation StatePrep_IsQubitA(alpha : Double, q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |B⟩\n            X(q);\n            Rx(2.0 * alpha, q);\n        } else {\n            // convert |0⟩ to |A⟩\n            Rx(2.0 * alpha, q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let alpha = (PI() * IntAsDouble(i)) / 10.0;\n            let isCorrect = DistinguishTwoStates(\n                StatePrep_IsQubitA(alpha, _, _),\n                Kata.IsQubitA(alpha, _),\n                [$\"|B⟩ = -i sin({i}π/10)|0⟩ + cos({i}π/10)|1⟩\", $\"|A⟩ = cos({i}π/10)|0⟩ + i sin({i}π/10)|1⟩\"],\n                false);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Katas;\n\n    // Distinguish states |A❭ and |B❭\n    // |A⟩ =   cos(alpha) * |0⟩ - i sin(alpha) * |1⟩,\n    // |B⟩ = - i sin(alpha) * |0⟩ + cos(alpha) * |1⟩.\n    operation StatePrep_IsQubitA(alpha : Double, q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |B⟩\n            X(q);\n            Rx(2.0 * alpha, q);\n        } else {\n            // convert |0⟩ to |A⟩\n            Rx(2.0 * alpha, q);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let alpha = (PI() * IntAsDouble(i)) / 10.0;\n            let isCorrect = DistinguishTwoStates_SingleQubit(\n                StatePrep_IsQubitA(alpha, _, _),\n                Kata.IsQubitA(alpha, _),\n                [$\"|B⟩ = -i sin({i}π/10)|0⟩ + cos({i}π/10)|1⟩\", $\"|A⟩ = cos({i}π/10)|0⟩ + i sin({i}π/10)|1⟩\"],\n                false);\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
         },
         {
             "id": "single_qubit_measurements__a_b_basis_measurements__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n\n    // Measure state in {|A❭, |B❭} basis\n    // |A⟩ =   cos(alpha) * |0⟩ - i sin(alpha) * |1⟩,\n    // |B⟩ = - i sin(alpha) * |0⟩ + cos(alpha) * |1⟩.\n    operation StatePrep_IsQubitA (alpha : Double, q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |B⟩\n            X(q);\n            Rx(2.0 * alpha, q);\n        } else {\n            // convert |0⟩ to |A⟩\n            Rx(2.0 * alpha, q);\n        }\n    }\n\n    // We can use the StatePrep_IsQubitA operation for the testing\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let alpha = (PI() * IntAsDouble(i)) / 10.0;\n            let isCorrect = DistinguishTwoStates(\n                StatePrep_IsQubitA(alpha, _, _),\n                q => Kata.MeasureInABBasis(alpha, q) == Zero,\n                [$\"|B⟩=(-i sin({i}π/10)|0⟩ + cos({i}π/10)|1⟩)\", $\"|A⟩=(cos({i}π/10)|0⟩ + i sin({i}π/10)|1⟩)\"],\n                true);\n            if not isCorrect {\n                Message($\"Test fails for alpha={alpha}\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Katas;\n\n    // Measure state in {|A❭, |B❭} basis\n    // |A⟩ =   cos(alpha) * |0⟩ - i sin(alpha) * |1⟩,\n    // |B⟩ = - i sin(alpha) * |0⟩ + cos(alpha) * |1⟩.\n    operation StatePrep_IsQubitA (alpha : Double, q : Qubit, state : Int) : Unit is Adj {\n        if state == 0 {\n            // convert |0⟩ to |B⟩\n            X(q);\n            Rx(2.0 * alpha, q);\n        } else {\n            // convert |0⟩ to |A⟩\n            Rx(2.0 * alpha, q);\n        }\n    }\n\n    // We can use the StatePrep_IsQubitA operation for the testing\n    operation CheckSolution() : Bool {\n        for i in 0 .. 10 {\n            let alpha = (PI() * IntAsDouble(i)) / 10.0;\n            let isCorrect = DistinguishTwoStates_SingleQubit(\n                StatePrep_IsQubitA(alpha, _, _),\n                q => Kata.MeasureInABBasis(alpha, q) == Zero,\n                [$\"|B⟩=(-i sin({i}π/10)|0⟩ + cos({i}π/10)|1⟩)\", $\"|A⟩=(cos({i}π/10)|0⟩ + i sin({i}π/10)|1⟩)\"],\n                true);\n            if not isCorrect {\n                Message($\"Test fails for alpha={alpha}\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
         },
         {
             "id": "multi_qubit_measurements__full_measurements__Verification.qs",
-            "code": "namespace Kata.Verification {\n\n    // Distinguish four basis states\n    operation StatePrep_BasisStateMeasurement(qs : Qubit[], state : Int, dummyVar : Double) : Unit is Adj {\n        if state / 2 == 1 {\n            // |10⟩ or |11⟩\n            X(qs[0]);\n        }\n        if state % 2 == 1 {\n            // |01⟩ or |11⟩\n            X(qs[1]);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            2,\n            4,\n            StatePrep_BasisStateMeasurement,\n            Kata.BasisStateMeasurement,\n            false,\n            [\"|00⟩\", \"|01⟩\", \"|10⟩\", \"|11⟩\"]);\n\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect\n    }\n}\n"
-        },
-        {
-            "id": "multi_qubit_measurements__Common.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Random;\n\n    // \"Framework\" operation for testing multi-qubit tasks for distinguishing states of an array of qubits\n    // with Int return\n    operation DistinguishStates_MultiQubit(\n        nQubits : Int,\n        nStates : Int,\n        statePrep : ((Qubit[], Int, Double) => Unit is Adj),\n        testImpl : (Qubit[] => Int),\n        preserveState : Bool,\n        stateNames : String[]) : Bool {\n\n        let nTotal = 100;\n        // misclassifications will store the number of times state i has been classified as state j (dimension nStates^2)\n        mutable misclassifications = [0, size = nStates * nStates];\n        // unknownClassifications will store the number of times state i has been classified as some invalid state (index < 0 or >= nStates)\n        mutable unknownClassifications = [0, size = nStates];\n\n        use qs = Qubit[nQubits];\n        for i in 1 .. nTotal {\n            // get a random integer to define the state of the qubits\n            let state = DrawRandomInt(0, nStates - 1);\n            // get a random rotation angle to define the exact state of the qubits\n            // for some exercises, this value might be a dummy variable which does not matter\n            let alpha = DrawRandomDouble(0.0, 1.0) * PI();\n\n            // do state prep: convert |0...0⟩ to outcome with return equal to state\n            statePrep(qs, state, alpha);\n\n            // get the solution's answer and verify that it's a match, if not, increase the exact mismatch count\n            let ans = testImpl(qs);\n            if ((ans >= 0) and (ans < nStates)) {\n                // classification result is a valid state index - check if is it correct\n                if ans != state {\n                    set misclassifications w/= ((state * nStates) + ans) <- (misclassifications[(state * nStates) + ans] + 1);\n                }\n            }\n            else {\n                // classification result is an invalid state index - file it separately\n                set unknownClassifications w/= state <- (unknownClassifications[state] + 1);\n            }\n\n            if preserveState {\n                // check that the state of the qubit after the operation is unchanged\n                Adjoint statePrep(qs, state, alpha);\n                if not CheckAllZero(qs) {\n                    Message($\"Input quantum state {stateNames[state]} was not preserved during the measurement.\");\n                    ResetAll(qs);\n                    return false;\n                }\n            } else {\n                // we're not checking the state of the qubit after the operation\n                ResetAll(qs);\n            }\n        }\n        ResetAll(qs);\n\n        mutable totalMisclassifications = 0;\n        for i in 0 .. nStates - 1 {\n            for j in 0 .. nStates - 1 {\n                if misclassifications[(i * nStates) + j] != 0 {\n                    set totalMisclassifications += misclassifications[i * nStates + j];\n                    Message($\"Misclassified {stateNames[i]} as {stateNames[j]} in {misclassifications[(i * nStates) + j]} test runs.\");\n                }\n            }\n            if unknownClassifications[i] != 0 {\n                set totalMisclassifications += unknownClassifications[i];\n                Message($\"Misclassified {stateNames[i]} as Unknown State in {unknownClassifications[i]} test runs.\");\n            }\n        }\n        totalMisclassifications == 0\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    // Distinguish four basis states\n    operation StatePrep_BasisStateMeasurement(qs : Qubit[], state : Int, dummyVar : Double) : Unit is Adj {\n        if state / 2 == 1 {\n            // |10⟩ or |11⟩\n            X(qs[0]);\n        }\n        if state % 2 == 1 {\n            // |01⟩ or |11⟩\n            X(qs[1]);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            2,\n            4,\n            StatePrep_BasisStateMeasurement,\n            Kata.BasisStateMeasurement,\n            false,\n            [\"|00⟩\", \"|01⟩\", \"|10⟩\", \"|11⟩\"]);\n\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "multi_qubit_measurements__partial_measurements_for_system__Verification.qs",
-            "code": "namespace Kata.Verification {\n\n    // Distinguish orthogonal states using partial measurements\n    operation StatePrep_IsPlusPlusMinus(qs : Qubit[], state : Int, dummyVar : Double) : Unit is Adj {\n        if state == 0 {\n            // Prepare the state |++-⟩\n            X(qs[2]);\n        } else {\n            // Prepare the state |---⟩\n            ApplyToEachA(X, qs);\n        }\n        ApplyToEachA(H, qs);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            3,\n            2,\n            StatePrep_IsPlusPlusMinus,\n            Kata.IsPlusPlusMinus,\n            true,\n            [\"|++-⟩\", \"|---⟩\"]);\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect            \n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    // Distinguish orthogonal states using partial measurements\n    operation StatePrep_IsPlusPlusMinus(qs : Qubit[], state : Int, dummyVar : Double) : Unit is Adj {\n        if state == 0 {\n            // Prepare the state |++-⟩\n            X(qs[2]);\n        } else {\n            // Prepare the state |---⟩\n            ApplyToEachA(X, qs);\n        }\n        ApplyToEachA(H, qs);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            3,\n            2,\n            StatePrep_IsPlusPlusMinus,\n            Kata.IsPlusPlusMinus,\n            true,\n            [\"|++-⟩\", \"|---⟩\"]);\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect            \n    }\n}\n"
         },
         {
             "id": "multi_qubit_measurements__state_modification__Verification.qs",
@@ -3941,11 +4137,11 @@ export default {
         },
         {
             "id": "multi_qubit_measurements__state_preparation__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    // State preparation using partial measurements\n    operation StatePrep_Rotations(qs : Qubit[]) : Unit is Adj {\n        // Rotate first qubit to (sqrt(2) |0⟩ + |1⟩) / sqrt(3)\n        let theta = ArcSin(1.0 / Sqrt(3.0));\n        Ry(2.0 * theta, qs[0]);\n\n        // Split the state sqrt(2) |0⟩ ⊗ |0⟩ into |00⟩ + |01⟩\n        ApplyControlledOnInt(0, H, [qs[0]], qs[1]);\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = CheckOperationsEquivalenceOnZeroState(Kata.PostSelection, StatePrep_Rotations, 2);\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            // TODO #1207: refactor kata libraries ShowQuantumStateComparison to not require adjoint\n            use qs = Qubit[2];\n            Message(\"Expected quantum state after applying the operation:\");\n            StatePrep_Rotations(qs);\n            DumpMachine();\n            ResetAll(qs);\n\n            Kata.PostSelection(qs);\n            Message(\"Actual quantum state after applying the operation:\");\n            DumpMachine();\n            ResetAll(qs);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    // Reference solution that does not use measurements (to be adjointable)\n    operation StatePrep_Rotations(qs : Qubit[]) : Unit is Adj {\n        // Rotate first qubit to (sqrt(2) |0⟩ + |1⟩) / sqrt(3)\n        let theta = ArcSin(1.0 / Sqrt(3.0));\n        Ry(2.0 * theta, qs[0]);\n\n        // Split the state sqrt(2) |0⟩ ⊗ |0⟩ into |00⟩ + |01⟩\n        ApplyControlledOnInt(0, H, [qs[0]], qs[1]);\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckOperationsEquivalenceOnZeroStateWithFeedback(Kata.PostSelection, StatePrep_Rotations, 2)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_measurements__joint_measurements__Verification.qs",
-            "code": "namespace Kata.Verification {\n\n    // Two qubit parity Measurement\n    operation StatePrep_ParityMeasurement(qs : Qubit[], state : Int, alpha : Double) : Unit is Adj {\n        // prep cos(alpha) * |0..0⟩ + sin(alpha) * |1..1⟩\n        Ry(2.0 * alpha, qs[0]);\n        CNOT(qs[0], qs[1]);\n\n        if state == 1 {\n            // flip the state of the first qubit\n            X(qs[0]);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            2,\n            2,\n            StatePrep_ParityMeasurement,\n            Kata.ParityMeasurement,\n            true,\n            [\"α|00⟩ + β|11⟩\", \"α|01⟩ + β|10⟩\"]);\n\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    // Two qubit parity Measurement\n    operation StatePrep_ParityMeasurement(qs : Qubit[], state : Int, alpha : Double) : Unit is Adj {\n        // prep cos(alpha) * |0..0⟩ + sin(alpha) * |1..1⟩\n        Ry(2.0 * alpha, qs[0]);\n        CNOT(qs[0], qs[1]);\n\n        if state == 1 {\n            // flip the state of the first qubit\n            X(qs[0]);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = DistinguishStates_MultiQubit(\n            2,\n            2,\n            StatePrep_ParityMeasurement,\n            Kata.ParityMeasurement,\n            true,\n            [\"α|00⟩ + β|11⟩\", \"α|01⟩ + β|10⟩\"]);\n\n        if (isCorrect) {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "random_numbers__random_bit__Verification.qs",
@@ -3981,35 +4177,35 @@ export default {
         },
         {
             "id": "oracles__phase_oracle_seven__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation IsSeven_PhaseOracle_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        Controlled Z(Most(x), Tail(x));\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let N = 3;\n        let isCorrect = CheckOperationsEquivalenceStrict(\n            Kata.IsSeven_PhaseOracle,\n            IsSeven_PhaseOracle_Reference,\n            3);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            use initial = Qubit[3]; // |000〉\n            PrepRandomState(initial);\n            ShowQuantumStateComparison(initial, Kata.IsSeven_PhaseOracle, IsSeven_PhaseOracle_Reference);\n            ResetAll(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation IsSeven_PhaseOracle_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        Controlled Z(Most(x), Tail(x));\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let N = 3;\n        let isCorrect = CheckOperationsEquivalenceStrict(\n            Kata.IsSeven_PhaseOracle,\n            IsSeven_PhaseOracle_Reference,\n            3);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            ShowQuantumStateComparison(3, PrepRandomState, Kata.IsSeven_PhaseOracle, IsSeven_PhaseOracle_Reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "oracles__marking_oracle_seven__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation IsSeven_MarkingOracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        Controlled X(x, y);\n    }\n\n    // ------------------------------------------------------\n    @EntryPoint()\n    operation CheckSolution () : Bool {\n        let N = 3;\n        let sol = ApplyOracle(_, Kata.IsSeven_MarkingOracle);\n        let ref = ApplyOracle(_, IsSeven_MarkingOracle_Reference);\n        let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            use initial = Qubit[4]; // |000〉\n            PrepRandomState(initial[...2]);\n            ShowQuantumStateComparison(initial, sol, ref);\n            ResetAll(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation IsSeven_MarkingOracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        Controlled X(x, y);\n    }\n\n    // ------------------------------------------------------\n    @EntryPoint()\n    operation CheckSolution () : Bool {\n        let N = 3;\n        let sol = ApplyOracle(_, Kata.IsSeven_MarkingOracle);\n        let ref = ApplyOracle(_, IsSeven_MarkingOracle_Reference);\n        let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                \"transformation\");\n            ShowQuantumStateComparison(4, qs => PrepRandomState(qs[...2]), sol, ref);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "oracles__marking_oracle_as_phase__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Random;\n\n    operation ApplyMarkingOracleAsPhaseOracle_Reference(\n        markingOracle : ((Qubit[], Qubit) => Unit is Adj + Ctl),\n        qubits : Qubit[]) : Unit is Adj + Ctl {\n\n        use minus = Qubit();\n        within {\n            X(minus);\n            H(minus);\n        } apply {\n            markingOracle(qubits, minus);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N - 1 {\n                let pattern = IntAsBoolArray(k, N);\n                let marking = ApplyControlledOnBitString(pattern, X, _, _);\n                let sol = Kata.ApplyMarkingOracleAsPhaseOracle(marking, _);\n                let ref = ApplyMarkingOracleAsPhaseOracle_Reference(marking, _);\n\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle that marks the bit string {pattern}\");\n                    use initial = Qubit[N];\n                    PrepRandomState(initial);\n                    ShowQuantumStateComparison(initial, sol, ref);\n                    ResetAll(initial);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Random;\n\n    operation ApplyMarkingOracleAsPhaseOracle_Reference(\n        markingOracle : ((Qubit[], Qubit) => Unit is Adj + Ctl),\n        qubits : Qubit[]) : Unit is Adj + Ctl {\n\n        use minus = Qubit();\n        within {\n            X(minus);\n            H(minus);\n        } apply {\n            markingOracle(qubits, minus);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N - 1 {\n                let pattern = IntAsBoolArray(k, N);\n                let marking = ApplyControlledOnBitString(pattern, X, _, _);\n                let sol = Kata.ApplyMarkingOracleAsPhaseOracle(marking, _);\n                let ref = ApplyMarkingOracleAsPhaseOracle_Reference(marking, _);\n\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle that marks the bit string {pattern}\");\n                    ShowQuantumStateComparison(N, PrepRandomState, sol, ref);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
         },
         {
             "id": "oracles__or_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Random;\n\n    operation Or_Oracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        X(y);\n        ApplyControlledOnInt(0, X, x, y);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            let sol = ApplyOracle(_, Kata.Or_Oracle);\n            let ref = ApplyOracle(_, Or_Oracle_Reference);\n            let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                    $\"transformation for the {N}-bit oracle\");\n                use initial = Qubit[N + 1];\n                PrepRandomState(initial[...N - 1]);\n                ShowQuantumStateComparison(initial, sol, ref);\n                ResetAll(initial);\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Random;\n\n    operation Or_Oracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        X(y);\n        ApplyControlledOnInt(0, X, x, y);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            let sol = ApplyOracle(_, Kata.Or_Oracle);\n            let ref = ApplyOracle(_, Or_Oracle_Reference);\n            let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n\n            if not isCorrect {\n                Message(\"Incorrect.\");\n                Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                    $\"transformation for the {N}-bit oracle\");\n                ShowQuantumStateComparison(N + 1, qs => PrepRandomState(qs[...N - 1]), sol, ref);\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "oracles__kth_bit_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation KthBit_Oracle_Reference(x : Qubit[], k : Int) : Unit is Adj + Ctl {\n        Z(x[k]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. N - 1 {\n                let sol = Kata.KthBit_Oracle(_, k);\n                let ref = KthBit_Oracle_Reference(_, k);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for k = {k}\");\n                    use initial = Qubit[N];\n                    PrepRandomState(initial);\n                    ShowQuantumStateComparison(initial, sol, ref);\n                    ResetAll(initial);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation KthBit_Oracle_Reference(x : Qubit[], k : Int) : Unit is Adj + Ctl {\n        Z(x[k]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. N - 1 {\n                let sol = Kata.KthBit_Oracle(_, k);\n                let ref = KthBit_Oracle_Reference(_, k);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for k = {k}\");\n                    ShowQuantumStateComparison(N, PrepRandomState, sol, ref);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "oracles__or_but_kth_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation Or_Oracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        X(y);\n        ApplyControlledOnInt(0, X, x, y);\n    }\n\n    operation OrOfBitsExceptKth_Oracle_Reference(x : Qubit[], k : Int) : Unit is Adj + Ctl {\n        use minus = Qubit();\n        within {\n            X(minus);\n            H(minus);\n        } apply {\n            Or_Oracle_Reference(x[...k-1] + x[k+1...], minus);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 2 .. 4 {\n            for k in 0 .. N - 1 {\n                let sol = Kata.OrOfBitsExceptKth_Oracle(_, k);\n                let ref = OrOfBitsExceptKth_Oracle_Reference(_, k);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for k = {k}\");\n                    use initial = Qubit[N];\n                    PrepRandomState(initial);\n                    ShowQuantumStateComparison(initial, sol, ref);\n                    ResetAll(initial);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation Or_Oracle_Reference(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        X(y);\n        ApplyControlledOnInt(0, X, x, y);\n    }\n\n    operation OrOfBitsExceptKth_Oracle_Reference(x : Qubit[], k : Int) : Unit is Adj + Ctl {\n        use minus = Qubit();\n        within {\n            X(minus);\n            H(minus);\n        } apply {\n            Or_Oracle_Reference(x[...k-1] + x[k+1...], minus);\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 2 .. 4 {\n            for k in 0 .. N - 1 {\n                let sol = Kata.OrOfBitsExceptKth_Oracle(_, k);\n                let ref = OrOfBitsExceptKth_Oracle_Reference(_, k);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for k = {k}\");\n                    ShowQuantumStateComparison(N, PrepRandomState, sol, ref);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "oracles__bit_pattern_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    operation ArbitraryBitPattern_Oracle_Reference(x : Qubit[], y : Qubit, pattern : Bool[]) : Unit  is Adj + Ctl {\n        ApplyControlledOnBitString(pattern, X, x, y);\n    }\n\n    // ------------------------------------------------------\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N - 1 {\n                let pattern = IntAsBoolArray(k, N);\n\n                let sol = ApplyOracle(_, Kata.ArbitraryBitPattern_Oracle(_, _, pattern));\n                let ref = ApplyOracle(_, ArbitraryBitPattern_Oracle_Reference(_, _, pattern));\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for the pattern {pattern}\");\n                    use initial = Qubit[N + 1];\n                    PrepRandomState(initial[...N - 1]);\n                    ShowQuantumStateComparison(initial, sol, ref);\n                    ResetAll(initial);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    operation ArbitraryBitPattern_Oracle_Reference(x : Qubit[], y : Qubit, pattern : Bool[]) : Unit  is Adj + Ctl {\n        ApplyControlledOnBitString(pattern, X, x, y);\n    }\n\n    // ------------------------------------------------------\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N - 1 {\n                let pattern = IntAsBoolArray(k, N);\n\n                let sol = ApplyOracle(_, Kata.ArbitraryBitPattern_Oracle(_, _, pattern));\n                let ref = ApplyOracle(_, ArbitraryBitPattern_Oracle_Reference(_, _, pattern));\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N + 1);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for the pattern {pattern}\");\n                    ShowQuantumStateComparison(N + 1, qs => PrepRandomState(qs[...N - 1]), sol, ref);\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
         },
         {
             "id": "oracles__bit_pattern_challenge__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    operation ArbitraryBitPattern_Oracle_Challenge_Reference(x : Qubit[], pattern : Bool[]) : Unit is Adj + Ctl {\n        within {\n            for i in IndexRange(x) {\n                if not pattern[i] {\n                    X(x[i]);\n                }\n            }\n        } apply {\n            Controlled Z(Most(x), Tail(x));\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N -1 {\n                let pattern = IntAsBoolArray(k, N);\n\n                let sol = Kata.ArbitraryBitPattern_Oracle_Challenge(_, pattern);\n                let ref = ArbitraryBitPattern_Oracle_Challenge_Reference(_, pattern);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for pattern = {pattern}\");\n                    use initial = Qubit[N];\n                    PrepRandomState(initial);\n                    ShowQuantumStateComparison(initial, sol, ref);\n                    ResetAll(initial);\n                    return false;\n                }\n            }\n        }\n        Message(\"All tests passed.\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    operation ArbitraryBitPattern_Oracle_Challenge_Reference(x : Qubit[], pattern : Bool[]) : Unit is Adj + Ctl {\n        within {\n            for i in IndexRange(x) {\n                if not pattern[i] {\n                    X(x[i]);\n                }\n            }\n        } apply {\n            Controlled Z(Most(x), Tail(x));\n        }\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for N in 1 .. 3 {\n            for k in 0 .. 2^N -1 {\n                let pattern = IntAsBoolArray(k, N);\n\n                let sol = Kata.ArbitraryBitPattern_Oracle_Challenge(_, pattern);\n                let ref = ArbitraryBitPattern_Oracle_Challenge_Reference(_, pattern);\n                let isCorrect = CheckOperationsEquivalenceStrict(sol, ref, N);\n\n                if not isCorrect {\n                    Message(\"Incorrect.\");\n                    Message(\"Hint: examine how your solution transforms the given state and compare it with the expected \" +\n                        $\"transformation for the {N}-bit oracle for pattern = {pattern}\");\n                    ShowQuantumStateComparison(N, PrepRandomState, sol, ref);\n                    return false;\n                }\n            }\n        }\n        Message(\"All tests passed.\");\n        true\n    }\n}\n"
         },
         {
             "id": "oracles__meeting_oracle__Verification.qs",
@@ -4017,7 +4213,7 @@ export default {
         },
         {
             "id": "deutsch_algo__one_minus_x_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_OneMinusX_Reference(x : Qubit) : Unit is Adj + Ctl {\n        Z(x);\n        R(PauliI, 2.0 * PI(), x);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.PhaseOracle_OneMinusX(register[0]);\n        let reference = register => PhaseOracle_OneMinusX_Reference(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n            use initial = Qubit(); // |0〉\n            Ry(ArcTan2(0.8, 0.6) * 2.0, initial); // 0.6|0〉 + 0.8|1〉\n            ShowQuantumStateComparison([initial], solution, reference);\n            Reset(initial);\n        }\n        isCorrect\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_OneMinusX_Reference(x : Qubit) : Unit is Adj + Ctl {\n        Z(x);\n        R(PauliI, 2.0 * PI(), x);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = register => Kata.PhaseOracle_OneMinusX(register[0]);\n        let reference = register => PhaseOracle_OneMinusX_Reference(register[0]);\n        let isCorrect = CheckOperationsEquivalenceStrict(solution, reference, 1);\n\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            Message(\"Hint: examine the effect your solution has on the state 0.6|0〉 + 0.8|1〉 and compare it with the effect it \" +\n                \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n            ShowQuantumStateComparison(1, (qs => Ry(ArcTan2(0.8, 0.6) * 2.0, qs[0])), solution, reference);\n        }\n        isCorrect\n    }\n}\n"
         },
         {
             "id": "deutsch_algo__implement_algo__Verification.qs",
@@ -4025,11 +4221,11 @@ export default {
         },
         {
             "id": "deutsch_jozsa__msb_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_MostSignificantBit_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        Z(x[0]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.PhaseOracle_MostSignificantBit;\n        let reference = PhaseOracle_MostSignificantBit_Reference;\n        for N in 1 .. 4 {\n            if not CheckOperationsEquivalenceStrict(solution, reference, N) {\n                Message(\"Incorrect.\");\n                Message($\"Hint: examine the effect your solution has on the {N}-qubit and compare it with the effect it \" +\n                    \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                    \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n                use initial = Qubit[N];\n                PrepRandomState(initial);\n                ShowQuantumStateComparison(initial, solution, reference);\n                ResetAll(initial);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_MostSignificantBit_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        Z(x[0]);\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.PhaseOracle_MostSignificantBit;\n        let reference = PhaseOracle_MostSignificantBit_Reference;\n        for N in 1 .. 4 {\n            if not CheckOperationsEquivalenceStrict(solution, reference, N) {\n                Message(\"Incorrect.\");\n                Message($\"Hint: examine the effect your solution has on the {N}-qubit and compare it with the effect it \" +\n                    \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                    \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n                ShowQuantumStateComparison(N, PrepRandomState, solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "deutsch_jozsa__parity_oracle__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_Parity_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        for xi in x {\n            Z(xi);\n        }\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.PhaseOracle_Parity;\n        let reference = PhaseOracle_Parity_Reference;\n        for N in 1 .. 4 {\n            if not CheckOperationsEquivalenceStrict(solution, reference, N) {\n                Message(\"Incorrect.\");\n                Message($\"Hint: examine the effect your solution has on the {N}-qubit and compare it with the effect it \" +\n                    \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                    \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n                use initial = Qubit[N];\n                PrepRandomState(initial);\n                ShowQuantumStateComparison(initial, solution, reference);\n                ResetAll(initial);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n\n    operation PhaseOracle_Parity_Reference(x : Qubit[]) : Unit is Adj + Ctl {\n        for xi in x {\n            Z(xi);\n        }\n    }\n\n    operation CheckSolution() : Bool {\n        let solution = Kata.PhaseOracle_Parity;\n        let reference = PhaseOracle_Parity_Reference;\n        for N in 1 .. 4 {\n            if not CheckOperationsEquivalenceStrict(solution, reference, N) {\n                Message(\"Incorrect.\");\n                Message($\"Hint: examine the effect your solution has on the {N}-qubit and compare it with the effect it \" +\n                    \"is expected to have. Note that the simulator might drop the global phase -1, so if you're getting \" +\n                    \"verdict \\\"Incorrect\\\" but the actual state matches the expected one, check that you're handling the global phase correctly.\");\n                ShowQuantumStateComparison(N, PrepRandomState, solution, reference);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "deutsch_jozsa__implement_dj__Verification.qs",