qsharp-lang 1.3.6-dev → 1.4.0

package/dist/katas-content.generated.js

@@ -1745,8 +1745,8 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "asHtml": "<p>Just like with single qubits, Dirac notation provides a useful shorthand for writing down states of multi-qubit systems.</p>\n<p>As we&#39;ve seen earlier, multi-qubit systems have their own canonical bases, and the basis states can be represented as tensor products of single-qubit basis states. Any multi-qubit system can be represented as a linear combination of these basis states:</p>\n<p>$$\n\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\nx_0\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} +\nx_1\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix} +\nx_2\\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix} +\nx_3\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix} =\nx_0|0\\rangle \\otimes |0\\rangle +\nx_1|0\\rangle \\otimes |1\\rangle +\nx_2|1\\rangle \\otimes |0\\rangle +\nx_3|1\\rangle \\otimes |1\\rangle\n$$</p>\n<p>To simplify this, tensor products of basis states have their own notation:</p>\n<p>$$|0\\rangle \\otimes |0\\rangle = |00\\rangle$$\n$$|0\\rangle \\otimes |1\\rangle = |01\\rangle$$\n$$|1\\rangle \\otimes |0\\rangle = |10\\rangle$$\n$$|1\\rangle \\otimes |1\\rangle = |11\\rangle$$</p>\n<p>$$|0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = |000\\rangle$$</p>\n<p>And so on.</p>\n<p>Or, more generally:</p>\n<p>$$|i_0\\rangle \\otimes |i_1\\rangle \\otimes \\dotsb \\otimes |i_n\\rangle = |i_0i_1...i_n\\rangle$$</p>\n<p>Using this notation simplifies our example:</p>\n<p>$$\n\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\nx_0|00\\rangle + x_1|01\\rangle + x_2|10\\rangle + x_3|11\\rangle\n$$</p>\n<p>Just like with single qubits, we can put arbitrary symbols within the kets the same way variables are used in algebra.\nWhether a ket represents a single qubit or an entire system depends on the context.\nSome ket symbols have a commonly accepted usage, such as the symbols for the Bell basis:</p>\n<p>$$|\\phi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle + |11\\rangle\\big)$$\n$$|\\phi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle - |11\\rangle\\big)$$\n$$|\\psi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle + |10\\rangle\\big)$$\n$$|\\psi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle - |10\\rangle\\big)$$</p>\n<blockquote>\n<h2>Endianness</h2>\n<p>In classical computing, endianness refers to the order of bits (or bytes) when representing numbers in binary. You&#39;re probably familiar with the typical way of writing numbers in binary: $0 = 0_2$, $1 = 1_2$, $2 = 10_2$, $3 = 11_2$, $4 = 100_2$, $5 = 101_2$, $6 = 110_2$, etc. This is known as <strong>big-endian format</strong>. In big-endian format, the <em>most significant</em> bits come first. For example: $110_2 = 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 4 + 2 = 6$.</p>\n<p>There is an alternate way of writing binary numbers - <strong>little-endian format</strong>. In little-endian format, the <em>least significant</em> bits come first. For example, $2$ would be written as $01$, $4$ as $001$, and $6$ as $011$. To put it another way, in little endian format, the number is written backwards compared to the big-endian format.</p>\n<p>In Dirac notation for multi-qubit systems, it&#39;s common to see integer numbers within the kets instead of bit sequences. What those numbers mean depends on the context - whether the notation used is big-endian or little-endian.</p>\n<p>Examples with a 3 qubit system:</p>\n<table>\n   <tr>\n       <th>Integer Ket</th>\n       <td>$|0\\rangle$</td>\n       <td>$|1\\rangle$</td>\n       <td>$|2\\rangle$</td>\n       <td>$|3\\rangle$</td>\n       <td>$|4\\rangle$</td>\n       <td>$|5\\rangle$</td>\n       <td>$|6\\rangle$</td>\n       <td>$|7\\rangle$</td>\n   </tr>\n   <tr>\n       <th>Big-endian</th>\n       <td>$|000\\rangle$</td>\n       <td>$|001\\rangle$</td>\n       <td>$|010\\rangle$</td>\n       <td>$|011\\rangle$</td>\n       <td>$|100\\rangle$</td>\n       <td>$|101\\rangle$</td>\n       <td>$|110\\rangle$</td>\n       <td>$|111\\rangle$</td>\n   </tr>\n   <tr>\n       <th>Little-endian</th>\n       <td>$|000\\rangle$</td>\n       <td>$|100\\rangle$</td>\n       <td>$|010\\rangle$</td>\n       <td>$|110\\rangle$</td>\n       <td>$|001\\rangle$</td>\n       <td>$|101\\rangle$</td>\n       <td>$|011\\rangle$</td>\n       <td>$|111\\rangle$</td>\n   </tr>\n</table>\n\n<p>Multi-qubit quantum systems that store superpositions of numbers are often referred to as <strong>quantum registers</strong>.</p>\n</blockquote>\n",
-                            "asMarkdown": "\nJust like with single qubits, Dirac notation provides a useful shorthand for writing down states of multi-qubit systems.\n\nAs we've seen earlier, multi-qubit systems have their own canonical bases, and the basis states can be represented as tensor products of single-qubit basis states. Any multi-qubit system can be represented as a linear combination of these basis states:\n\n$$\n\\begin{bmatrix} x_0 \\\\\\ x_1 \\\\\\ x_2 \\\\\\ x_3 \\end{bmatrix} =\nx_0\\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} +\nx_1\\begin{bmatrix} 0 \\\\\\ 1 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} +\nx_2\\begin{bmatrix} 0 \\\\\\ 0 \\\\\\ 1 \\\\\\ 0 \\end{bmatrix} +\nx_3\\begin{bmatrix} 0 \\\\\\ 0 \\\\\\ 0 \\\\\\ 1 \\end{bmatrix} =\nx_0|0\\rangle \\otimes |0\\rangle +\nx_1|0\\rangle \\otimes |1\\rangle +\nx_2|1\\rangle \\otimes |0\\rangle +\nx_3|1\\rangle \\otimes |1\\rangle\n$$\n\nTo simplify this, tensor products of basis states have their own notation:\n\n$$|0\\rangle \\otimes |0\\rangle = |00\\rangle$$\n$$|0\\rangle \\otimes |1\\rangle = |01\\rangle$$\n$$|1\\rangle \\otimes |0\\rangle = |10\\rangle$$\n$$|1\\rangle \\otimes |1\\rangle = |11\\rangle$$\n\n$$|0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = |000\\rangle$$\n\nAnd so on.\n\nOr, more generally:\n\n$$|i_0\\rangle \\otimes |i_1\\rangle \\otimes \\dotsb \\otimes |i_n\\rangle = |i_0i_1...i_n\\rangle$$\n\nUsing this notation simplifies our example:\n\n$$\n\\begin{bmatrix} x_0 \\\\\\ x_1 \\\\\\ x_2 \\\\\\ x_3 \\end{bmatrix} =\nx_0|00\\rangle + x_1|01\\rangle + x_2|10\\rangle + x_3|11\\rangle\n$$\n\nJust like with single qubits, we can put arbitrary symbols within the kets the same way variables are used in algebra.\nWhether a ket represents a single qubit or an entire system depends on the context.\nSome ket symbols have a commonly accepted usage, such as the symbols for the Bell basis:\n\n$$|\\phi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle + |11\\rangle\\big)$$\n$$|\\phi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle - |11\\rangle\\big)$$\n$$|\\psi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle + |10\\rangle\\big)$$\n$$|\\psi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle - |10\\rangle\\big)$$\n\n>## Endianness\n>\n> In classical computing, endianness refers to the order of bits (or bytes) when representing numbers in binary. You're probably familiar with the typical way of writing numbers in binary: $0 = 0_2$, $1 = 1_2$, $2 = 10_2$, $3 = 11_2$, $4 = 100_2$, $5 = 101_2$, $6 = 110_2$, etc. This is known as **big-endian format**. In big-endian format, the *most significant* bits come first. For example: $110_2 = 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 4 + 2 = 6$.\n>\n> There is an alternate way of writing binary numbers - **little-endian format**. In little-endian format, the *least significant* bits come first. For example, $2$ would be written as $01$, $4$ as $001$, and $6$ as $011$. To put it another way, in little endian format, the number is written backwards compared to the big-endian format.\n>\n> In Dirac notation for multi-qubit systems, it's common to see integer numbers within the kets instead of bit sequences. What those numbers mean depends on the context - whether the notation used is big-endian or little-endian.\n>\n> Examples with a 3 qubit system:\n>\n> <table>\n>    <tr>\n>        <th>Integer Ket</th>\n>        <td>$|0\\rangle$</td>\n>        <td>$|1\\rangle$</td>\n>        <td>$|2\\rangle$</td>\n>        <td>$|3\\rangle$</td>\n>        <td>$|4\\rangle$</td>\n>        <td>$|5\\rangle$</td>\n>        <td>$|6\\rangle$</td>\n>        <td>$|7\\rangle$</td>\n>    </tr>\n>    <tr>\n>        <th>Big-endian</th>\n>        <td>$|000\\rangle$</td>\n>        <td>$|001\\rangle$</td>\n>        <td>$|010\\rangle$</td>\n>        <td>$|011\\rangle$</td>\n>        <td>$|100\\rangle$</td>\n>        <td>$|101\\rangle$</td>\n>        <td>$|110\\rangle$</td>\n>        <td>$|111\\rangle$</td>\n>    </tr>\n>    <tr>\n>        <th>Little-endian</th>\n>        <td>$|000\\rangle$</td>\n>        <td>$|100\\rangle$</td>\n>        <td>$|010\\rangle$</td>\n>        <td>$|110\\rangle$</td>\n>        <td>$|001\\rangle$</td>\n>        <td>$|101\\rangle$</td>\n>        <td>$|011\\rangle$</td>\n>        <td>$|111\\rangle$</td>\n>    </tr>\n></table>\n>\n> Multi-qubit quantum systems that store superpositions of numbers are often referred to as **quantum registers**."
+                            "asHtml": "<p>Just like with single qubits, Dirac notation provides a useful shorthand for writing down states of multi-qubit systems.</p>\n<p>As we&#39;ve seen earlier, multi-qubit systems have their own canonical bases, and the basis states can be represented as tensor products of single-qubit basis states. Any multi-qubit system can be represented as a linear combination of these basis states:</p>\n<p>$$\n\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\nx_0\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} +\nx_1\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix} +\nx_2\\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix} +\nx_3\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix} =\nx_0|0\\rangle \\otimes |0\\rangle +\nx_1|0\\rangle \\otimes |1\\rangle +\nx_2|1\\rangle \\otimes |0\\rangle +\nx_3|1\\rangle \\otimes |1\\rangle\n$$</p>\n<p>To simplify this, tensor products of basis states have their own notation:</p>\n<p>$$|0\\rangle \\otimes |0\\rangle = |00\\rangle$$\n$$|0\\rangle \\otimes |1\\rangle = |01\\rangle$$\n$$|1\\rangle \\otimes |0\\rangle = |10\\rangle$$\n$$|1\\rangle \\otimes |1\\rangle = |11\\rangle$$</p>\n<p>$$|0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = |000\\rangle$$</p>\n<p>And so on.</p>\n<p>Or, more generally:</p>\n<p>$$|i_0\\rangle \\otimes |i_1\\rangle \\otimes \\dotsb \\otimes |i_n\\rangle = |i_0i_1...i_n\\rangle$$</p>\n<p>Using this notation simplifies our example:</p>\n<p>$$\n\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\nx_0|00\\rangle + x_1|01\\rangle + x_2|10\\rangle + x_3|11\\rangle\n$$</p>\n<p>Just like with single qubits, we can put arbitrary symbols within the kets the same way variables are used in algebra.\nWhether a ket represents a single qubit or an entire system depends on the context.\nSome ket symbols have a commonly accepted usage, such as the symbols for the Bell basis:</p>\n<p>$$|\\Phi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle + |11\\rangle\\big)$$\n$$|\\Phi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle - |11\\rangle\\big)$$\n$$|\\Psi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle + |10\\rangle\\big)$$\n$$|\\Psi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle - |10\\rangle\\big)$$</p>\n<blockquote>\n<h2>Endianness</h2>\n<p>In classical computing, endianness refers to the order of bits (or bytes) when representing numbers in binary. You&#39;re probably familiar with the typical way of writing numbers in binary: $0 = 0_2$, $1 = 1_2$, $2 = 10_2$, $3 = 11_2$, $4 = 100_2$, $5 = 101_2$, $6 = 110_2$, etc. This is known as <strong>big-endian format</strong>. In big-endian format, the <em>most significant</em> bits come first. For example: $110_2 = 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 4 + 2 = 6$.</p>\n<p>There is an alternate way of writing binary numbers - <strong>little-endian format</strong>. In little-endian format, the <em>least significant</em> bits come first. For example, $2$ would be written as $01$, $4$ as $001$, and $6$ as $011$. To put it another way, in little endian format, the number is written backwards compared to the big-endian format.</p>\n<p>In Dirac notation for multi-qubit systems, it&#39;s common to see integer numbers within the kets instead of bit sequences. What those numbers mean depends on the context - whether the notation used is big-endian or little-endian.</p>\n<p>Examples with a 3 qubit system:</p>\n<table>\n   <tr>\n       <th>Integer Ket</th>\n       <td>$|0\\rangle$</td>\n       <td>$|1\\rangle$</td>\n       <td>$|2\\rangle$</td>\n       <td>$|3\\rangle$</td>\n       <td>$|4\\rangle$</td>\n       <td>$|5\\rangle$</td>\n       <td>$|6\\rangle$</td>\n       <td>$|7\\rangle$</td>\n   </tr>\n   <tr>\n       <th>Big-endian</th>\n       <td>$|000\\rangle$</td>\n       <td>$|001\\rangle$</td>\n       <td>$|010\\rangle$</td>\n       <td>$|011\\rangle$</td>\n       <td>$|100\\rangle$</td>\n       <td>$|101\\rangle$</td>\n       <td>$|110\\rangle$</td>\n       <td>$|111\\rangle$</td>\n   </tr>\n   <tr>\n       <th>Little-endian</th>\n       <td>$|000\\rangle$</td>\n       <td>$|100\\rangle$</td>\n       <td>$|010\\rangle$</td>\n       <td>$|110\\rangle$</td>\n       <td>$|001\\rangle$</td>\n       <td>$|101\\rangle$</td>\n       <td>$|011\\rangle$</td>\n       <td>$|111\\rangle$</td>\n   </tr>\n</table>\n\n<p>Multi-qubit quantum systems that store superpositions of numbers are often referred to as <strong>quantum registers</strong>.</p>\n</blockquote>\n",
+                            "asMarkdown": "\nJust like with single qubits, Dirac notation provides a useful shorthand for writing down states of multi-qubit systems.\n\nAs we've seen earlier, multi-qubit systems have their own canonical bases, and the basis states can be represented as tensor products of single-qubit basis states. Any multi-qubit system can be represented as a linear combination of these basis states:\n\n$$\n\\begin{bmatrix} x_0 \\\\\\ x_1 \\\\\\ x_2 \\\\\\ x_3 \\end{bmatrix} =\nx_0\\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} +\nx_1\\begin{bmatrix} 0 \\\\\\ 1 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} +\nx_2\\begin{bmatrix} 0 \\\\\\ 0 \\\\\\ 1 \\\\\\ 0 \\end{bmatrix} +\nx_3\\begin{bmatrix} 0 \\\\\\ 0 \\\\\\ 0 \\\\\\ 1 \\end{bmatrix} =\nx_0|0\\rangle \\otimes |0\\rangle +\nx_1|0\\rangle \\otimes |1\\rangle +\nx_2|1\\rangle \\otimes |0\\rangle +\nx_3|1\\rangle \\otimes |1\\rangle\n$$\n\nTo simplify this, tensor products of basis states have their own notation:\n\n$$|0\\rangle \\otimes |0\\rangle = |00\\rangle$$\n$$|0\\rangle \\otimes |1\\rangle = |01\\rangle$$\n$$|1\\rangle \\otimes |0\\rangle = |10\\rangle$$\n$$|1\\rangle \\otimes |1\\rangle = |11\\rangle$$\n\n$$|0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = |000\\rangle$$\n\nAnd so on.\n\nOr, more generally:\n\n$$|i_0\\rangle \\otimes |i_1\\rangle \\otimes \\dotsb \\otimes |i_n\\rangle = |i_0i_1...i_n\\rangle$$\n\nUsing this notation simplifies our example:\n\n$$\n\\begin{bmatrix} x_0 \\\\\\ x_1 \\\\\\ x_2 \\\\\\ x_3 \\end{bmatrix} =\nx_0|00\\rangle + x_1|01\\rangle + x_2|10\\rangle + x_3|11\\rangle\n$$\n\nJust like with single qubits, we can put arbitrary symbols within the kets the same way variables are used in algebra.\nWhether a ket represents a single qubit or an entire system depends on the context.\nSome ket symbols have a commonly accepted usage, such as the symbols for the Bell basis:\n\n$$|\\Phi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle + |11\\rangle\\big)$$\n$$|\\Phi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle - |11\\rangle\\big)$$\n$$|\\Psi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle + |10\\rangle\\big)$$\n$$|\\Psi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle - |10\\rangle\\big)$$\n\n>## Endianness\n>\n> In classical computing, endianness refers to the order of bits (or bytes) when representing numbers in binary. You're probably familiar with the typical way of writing numbers in binary: $0 = 0_2$, $1 = 1_2$, $2 = 10_2$, $3 = 11_2$, $4 = 100_2$, $5 = 101_2$, $6 = 110_2$, etc. This is known as **big-endian format**. In big-endian format, the *most significant* bits come first. For example: $110_2 = 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 4 + 2 = 6$.\n>\n> There is an alternate way of writing binary numbers - **little-endian format**. In little-endian format, the *least significant* bits come first. For example, $2$ would be written as $01$, $4$ as $001$, and $6$ as $011$. To put it another way, in little endian format, the number is written backwards compared to the big-endian format.\n>\n> In Dirac notation for multi-qubit systems, it's common to see integer numbers within the kets instead of bit sequences. What those numbers mean depends on the context - whether the notation used is big-endian or little-endian.\n>\n> Examples with a 3 qubit system:\n>\n> <table>\n>    <tr>\n>        <th>Integer Ket</th>\n>        <td>$|0\\rangle$</td>\n>        <td>$|1\\rangle$</td>\n>        <td>$|2\\rangle$</td>\n>        <td>$|3\\rangle$</td>\n>        <td>$|4\\rangle$</td>\n>        <td>$|5\\rangle$</td>\n>        <td>$|6\\rangle$</td>\n>        <td>$|7\\rangle$</td>\n>    </tr>\n>    <tr>\n>        <th>Big-endian</th>\n>        <td>$|000\\rangle$</td>\n>        <td>$|001\\rangle$</td>\n>        <td>$|010\\rangle$</td>\n>        <td>$|011\\rangle$</td>\n>        <td>$|100\\rangle$</td>\n>        <td>$|101\\rangle$</td>\n>        <td>$|110\\rangle$</td>\n>        <td>$|111\\rangle$</td>\n>    </tr>\n>    <tr>\n>        <th>Little-endian</th>\n>        <td>$|000\\rangle$</td>\n>        <td>$|100\\rangle$</td>\n>        <td>$|010\\rangle$</td>\n>        <td>$|110\\rangle$</td>\n>        <td>$|001\\rangle$</td>\n>        <td>$|101\\rangle$</td>\n>        <td>$|011\\rangle$</td>\n>        <td>$|111\\rangle$</td>\n>    </tr>\n></table>\n>\n> Multi-qubit quantum systems that store superpositions of numbers are often referred to as **quantum registers**."
                         }
                     ]
                 },
@@ -1934,6 +1934,108 @@ export default {
                         ]
                     }
                 },
+                {
+                    "type": "lesson",
+                    "id": "multi_qubit_systems__modifying_entangled_states",
+                    "title": "Modifying Entangled States",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "asHtml": "<p>Entangled quantum states can be manipulated using single-qubit gates. For example, each state in the Bell basis is entangled and can be transformed into another Bell state through the application of single-qubit gates. In this lesson, you&#39;ll learn how to do that. (And we will learn more about applying single-qubit gates to multi-qubit states in the next kata.)</p>\n",
+                            "asMarkdown": "\nEntangled quantum states can be manipulated using single-qubit gates. For example, each state in the Bell basis is entangled and can be transformed into another Bell state through the application of single-qubit gates. In this lesson, you'll learn how to do that. (And we will learn more about applying single-qubit gates to multi-qubit states in the next kata.)"
+                        }
+                    ]
+                },
+                {
+                    "type": "exercise",
+                    "id": "multi_qubit_systems__bell_state_change_1 ",
+                    "title": "Bell State Change 1",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.</p>\n<p><strong>Goal:</strong> Change the two-qubit state to $|\\Phi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle - |11\\rangle\\big)$.</p>\n",
+                        "asMarkdown": "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n\n**Goal:** Change the two-qubit state to $|\\Phi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle - |11\\rangle\\big)$.\n"
+                    },
+                    "sourceIds": [
+                        "multi_qubit_systems__bell_state_change_1__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation BellStateChange1 (qs : Qubit[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We recognize that the goal is another Bell state. In fact, it is one of the four Bell states.</p>\n<p>We remember from the Single-Qubit Gates kata that the Pauli Z gate will change the state of the $|1\\rangle$ basis state of a single qubit, so this gate seems like a good candidate for what we want to achieve. This gate leaves the sign of the $|0\\rangle$ basis state of a superposition unchanged, but flips the sign of the $|1\\rangle$ basis state of the superposition.</p>\n<p>Don&#39;t forget that the Z gate acts on only a single qubit, and we have two here.\nLet&#39;s also remember how the Bell state is made up from its individual qubits.</p>\n<p>If the two qubits are A and B, where A is <code>qs[0]</code> and B is <code>qs[1]</code>, we can write that\n$|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0_{A}0_{B}\\rangle + |1_{A}1_{B}\\rangle\\big)$.\nIf we apply the Z gate to the qubit A, it will flip the phase of the basis state $|1_A\\rangle$. As this phase is in a sense spread across the entangled state, with $|1_A\\rangle$ basis state being part of the second half of the superposition, this application has the effect of flipping the sign of the whole basis state $|1_A1_B\\rangle$, as you can see by running the solution below.</p>\n<p>The exact same calculations can be done if we apply Z to the qubit B, so that&#39;s another possible solution.</p>\n",
+                                "asMarkdown": "\nWe recognize that the goal is another Bell state. In fact, it is one of the four Bell states.\n\nWe remember from the Single-Qubit Gates kata that the Pauli Z gate will change the state of the $|1\\rangle$ basis state of a single qubit, so this gate seems like a good candidate for what we want to achieve. This gate leaves the sign of the $|0\\rangle$ basis state of a superposition unchanged, but flips the sign of the $|1\\rangle$ basis state of the superposition.\n\nDon't forget that the Z gate acts on only a single qubit, and we have two here.\nLet's also remember how the Bell state is made up from its individual qubits.\n\nIf the two qubits are A and B, where A is `qs[0]` and B is `qs[1]`, we can write that\n$|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0_{A}0_{B}\\rangle + |1_{A}1_{B}\\rangle\\big)$.\nIf we apply the Z gate to the qubit A, it will flip the phase of the basis state $|1_A\\rangle$. As this phase is in a sense spread across the entangled state, with $|1_A\\rangle$ basis state being part of the second half of the superposition, this application has the effect of flipping the sign of the whole basis state $|1_A1_B\\rangle$, as you can see by running the solution below.\n\nThe exact same calculations can be done if we apply Z to the qubit B, so that's another possible solution."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_systems__bell_state_change_1_solution",
+                                "code": "namespace Kata {\n    operation BellStateChange1 (qs : Qubit[]) : Unit is Adj + Ctl {\n        Z(qs[0]);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "multi_qubit_systems__bell_state_change_2 ",
+                    "title": "Bell State Change 2",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.</p>\n<p><strong>Goal:</strong>  Change the two-qubit state to $|\\Psi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$.</p>\n",
+                        "asMarkdown": "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n\n**Goal:**  Change the two-qubit state to $|\\Psi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$."
+                    },
+                    "sourceIds": [
+                        "multi_qubit_systems__bell_state_change_2__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation BellStateChange2 (qs : Qubit[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n        \n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We have seen in the Single-Qubit Gates kata that the Pauli X gate flips $|0\\rangle$ to $|1\\rangle$ and vice versa, and as we seem to need some flipping of states, perhaps this gate may be of use. (Bearing in mind, of course, that the X gate operates on a single qubit).</p>\n<p>Let&#39;s compare the starting state $\\frac{1}{\\sqrt{2}} \\big(|0_A0_B\\rangle + |1_A1_B\\rangle\\big)$ with the goal state $\\frac{1}{\\sqrt{2}} \\big(1_A0_B\\rangle + |0_A1_B\\rangle\\big)$ term by term and see how we need to transform it to reach the goal.</p>\n<p>Using our nomenclature from &quot;Bell state change  1&quot;, we can now see by comparing terms that $|0_{A}\\rangle$ has flipped to $|1_A\\rangle$ to get the first term, and $|1_{A}\\rangle$ has flipped to $|0_A\\rangle$ to get the second term. This allows us to say that the correct gate to use is Pauli X, applied to <code>qs[0]</code>.</p>\n",
+                                "asMarkdown": "\nWe have seen in the Single-Qubit Gates kata that the Pauli X gate flips $|0\\rangle$ to $|1\\rangle$ and vice versa, and as we seem to need some flipping of states, perhaps this gate may be of use. (Bearing in mind, of course, that the X gate operates on a single qubit).\n\nLet's compare the starting state $\\frac{1}{\\sqrt{2}} \\big(|0_A0_B\\rangle + |1_A1_B\\rangle\\big)$ with the goal state $\\frac{1}{\\sqrt{2}} \\big(1_A0_B\\rangle + |0_A1_B\\rangle\\big)$ term by term and see how we need to transform it to reach the goal.\n\nUsing our nomenclature from \"Bell state change  1\", we can now see by comparing terms that $|0_{A}\\rangle$ has flipped to $|1_A\\rangle$ to get the first term, and $|1_{A}\\rangle$ has flipped to $|0_A\\rangle$ to get the second term. This allows us to say that the correct gate to use is Pauli X, applied to `qs[0]`."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_systems__bell_state_change_2_solution",
+                                "code": "namespace Kata {\n    operation BellStateChange2 (qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "multi_qubit_systems__bell_state_change_3 ",
+                    "title": "Bell State Change 3",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.</p>\n<p><strong>Goal:</strong>  Change the two-qubit state, without adding a global phase, to $|\\Psi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle - |10\\rangle\\big)$.</p>\n",
+                        "asMarkdown": "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n\n**Goal:**  Change the two-qubit state, without adding a global phase, to $|\\Psi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle - |10\\rangle\\big)$."
+                    },
+                    "sourceIds": [
+                        "multi_qubit_systems__bell_state_change_3__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation BellStateChange3(qs : Qubit[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We remember from the Single-Qubit Gates kata that the Pauli Z gate leaves the sign of the $|0\\rangle$ component of the single qubit superposition unchanged but flips the sign of the $|1\\rangle$ component of the superposition. We have also just seen in &quot;Bell State Change 2&quot; how to change our input state to the state $\\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$, which is almost our goal state (disregarding the phase change for the moment). So it would seem that a combination of these two gates will be what we need here. The remaining question is in what order to apply them, and to which qubit.</p>\n<p>First of all, which qubit? Looking back at the task &quot;Bell state change 2&quot;, it seems clear that we need to use qubit <code>qs[0]</code>, like we did there.</p>\n<p>Second, in what order should we apply the gates? Remember that the Pauli Z gate flips the phase of the $|1\\rangle$ component of the superposition and leaves the $|0\\rangle$ component alone.\nLet&#39;s experiment with applying X to <code>qs[0]</code> first. Looking at our &quot;halfway answer&quot; state $\\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$, we can see that if we apply the Z gate to <code>qs[0]</code>, it will leave the $|0_{A}\\rangle$ alone but flip the phase of $|1_{A}\\rangle$ to $-|1_{A}\\rangle$, thus flipping the phase of the $|11\\rangle$ component of our Bell state.</p>\n",
+                                "asMarkdown": "\nWe remember from the Single-Qubit Gates kata that the Pauli Z gate leaves the sign of the $|0\\rangle$ component of the single qubit superposition unchanged but flips the sign of the $|1\\rangle$ component of the superposition. We have also just seen in \"Bell State Change 2\" how to change our input state to the state $\\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$, which is almost our goal state (disregarding the phase change for the moment). So it would seem that a combination of these two gates will be what we need here. The remaining question is in what order to apply them, and to which qubit.\n\nFirst of all, which qubit? Looking back at the task \"Bell state change 2\", it seems clear that we need to use qubit `qs[0]`, like we did there.\n\nSecond, in what order should we apply the gates? Remember that the Pauli Z gate flips the phase of the $|1\\rangle$ component of the superposition and leaves the $|0\\rangle$ component alone.\nLet's experiment with applying X to `qs[0]` first. Looking at our \"halfway answer\" state $\\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$, we can see that if we apply the Z gate to `qs[0]`, it will leave the $|0_{A}\\rangle$ alone but flip the phase of $|1_{A}\\rangle$ to $-|1_{A}\\rangle$, thus flipping the phase of the $|11\\rangle$ component of our Bell state."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_systems__bell_state_change_3_solution",
+                                "code": "namespace Kata {\n    operation BellStateChange3(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        Z(qs[0]);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "lesson",
                     "id": "multi_qubit_systems__conclusion",
@@ -2018,6 +2120,36 @@ export default {
                         }
                     ]
                 },
+                {
+                    "type": "exercise",
+                    "id": "multi_qubit_gates__entangle_qubits",
+                    "title": "Entangle Qubits",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> Two unentangled qubits (stored in an array of length 2).\nThe first qubit will be in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$, the second - in state $|0\\rangle$\n(this can be written as two-qubit state $\\big(\\alpha |0\\rangle + \\beta |1\\rangle \\big) \\otimes |0\\rangle = \\alpha |00\\rangle + \\beta |10\\rangle$).</p>\n<p><strong>Goal:</strong> Change the two-qubit state to $\\alpha |00\\rangle + \\beta |11\\rangle$.</p>\n",
+                        "asMarkdown": "**Input:** Two unentangled qubits (stored in an array of length 2).\nThe first qubit will be in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$, the second - in state $|0\\rangle$\n(this can be written as two-qubit state $\\big(\\alpha |0\\rangle + \\beta |1\\rangle \\big) \\otimes |0\\rangle = \\alpha |00\\rangle + \\beta |10\\rangle$).\n\n**Goal:** Change the two-qubit state to $\\alpha |00\\rangle + \\beta |11\\rangle$.\n"
+                    },
+                    "sourceIds": [
+                        "multi_qubit_gates__entangle_qubits__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation EntangleQubits (qs : Qubit[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>Let&#39;s denote the first qubit in state $\\alpha |0\\rangle + \\beta |1\\rangle$ as A and the second qubit in state $|0\\rangle$ as B.</p>\n<p>Compare our input state $\\alpha |0_A0_B\\rangle + \\beta |1_A0_B\\rangle$ with the goal state $\\alpha |0_A0_B\\rangle + \\beta |1_A1_B\\rangle$. \nWe want to pass our input qubit through a gate or gates (to be decided) that do the following. If qubit A is in the $|0\\rangle$ state, then we want to leave qubit B alone (the first term of the superposition). \nHowever, if A is in the $|1\\rangle$ state, we want to flip qubit B from $|0\\rangle$ into $|1\\rangle$ state. In other words, the state of B is to be made contingent upon the state of A. \nThis is exactly the effect of the $CNOT$ gate. Depending upon the state of the <strong>control</strong> qubit (A in our case), the value of the controlled or <strong>target</strong> qubit (B in our case) is inverted or unchanged. Thus, we get the goal state $\\alpha |00\\rangle + \\beta |11\\rangle$.</p>\n",
+                                "asMarkdown": "\nLet's denote the first qubit in state $\\alpha |0\\rangle + \\beta |1\\rangle$ as A and the second qubit in state $|0\\rangle$ as B.\n\nCompare our input state $\\alpha |0_A0_B\\rangle + \\beta |1_A0_B\\rangle$ with the goal state $\\alpha |0_A0_B\\rangle + \\beta |1_A1_B\\rangle$. \nWe want to pass our input qubit through a gate or gates (to be decided) that do the following. If qubit A is in the $|0\\rangle$ state, then we want to leave qubit B alone (the first term of the superposition). \nHowever, if A is in the $|1\\rangle$ state, we want to flip qubit B from $|0\\rangle$ into $|1\\rangle$ state. In other words, the state of B is to be made contingent upon the state of A. \nThis is exactly the effect of the $CNOT$ gate. Depending upon the state of the **control** qubit (A in our case), the value of the controlled or **target** qubit (B in our case) is inverted or unchanged. Thus, we get the goal state $\\alpha |00\\rangle + \\beta |11\\rangle$."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_gates__entangle_qubits_solution",
+                                "code": "namespace Kata {\n    operation EntangleQubits (qs : Qubit[]) : Unit is Adj + Ctl {\n        CNOT(qs[0], qs[1]);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "exercise",
                     "id": "multi_qubit_gates__preparing_bell_state",
@@ -2048,6 +2180,58 @@ export default {
                         ]
                     }
                 },
+                {
+                    "type": "lesson",
+                    "id": "multi_qubit_gates__cz_gate",
+                    "title": "CZ Gate",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "asHtml": "<p>The $CZ$ (&quot;controlled-Z&quot;) gate is a two-qubit gate, with one qubit referred to as the <strong>control</strong> qubit, and the other as the <strong>target</strong> qubit. Interestingly, for the $CZ$ gate it doesn&#39;t matter which qubit is control and which is target - the effect of the gate is the same either way!</p>\n<p>The $CZ$ gate acts as a conditional gate: if the control qubit is in state $|1\\rangle$, it applies the $Z$ gate to the target qubit, otherwise it does nothing.</p>\n<table>\n    <tr>\n        <th>Gate</th>\n        <th>Matrix</th>\n        <th>Applying to $|\\psi\\rangle = \\alpha|00\\rangle + \\beta|01\\rangle + \\gamma|10\\rangle + \\delta|11\\rangle$</th>\n        <th>Applying to basis states</th>\n    </tr>\n    <tr>\n        <td>$CZ$</td>\n        <td>\n            $$\\begin{bmatrix}\n                1 & 0 & 0 & 0 \\\\\n                0 & 1 & 0 & 0 \\\\\n                0 & 0 & 1 & 0 \\\\\n                0 & 0 & 0 & -1\n            \\end{bmatrix}$$\n        </td>\n        <td>$CZ|\\psi\\rangle = \\alpha|00\\rangle + \\beta|01\\rangle + \\gamma|10\\rangle - \\delta|11\\rangle$</td>\n        <td>\n            $$CZ|00\\rangle = |00\\rangle$$\n            $$CZ|01\\rangle = |01\\rangle$$\n            $$CZ|10\\rangle = |10\\rangle$$\n            $$CZ|11\\rangle = -|11\\rangle$$\n        </td>\n    </tr>\n</table>\n\n<p>The $CZ$ gate is particularly useful for creating and manipulating entangled states where the phase of the quantum state is crucial. Consider the following separable state:</p>\n<p>$$\\big(\\alpha|0\\rangle + \\beta|1\\rangle\\big) \\otimes \\big(\\gamma|0\\rangle + \\delta|1\\rangle\\big) = \\alpha\\gamma|00\\rangle + \\alpha\\delta|01\\rangle + \\beta\\gamma|10\\rangle + \\beta\\delta|11\\rangle$$</p>\n<p>If we apply the $CZ$ gate to it, with the first qubit as the control and the second as the target (or vice versa), we get the following state, which can no longer be separated:</p>\n<p>$$\\alpha\\gamma|00\\rangle + \\alpha\\delta|01\\rangle + \\beta\\gamma|10\\rangle - \\beta\\delta|11\\rangle$$</p>\n<p>The $CZ$ gate is also self-adjoint: applying it a second time reverses its effect, similar to the $CNOT$ gate.</p>\n",
+                            "asMarkdown": "\nThe $CZ$ (\"controlled-Z\") gate is a two-qubit gate, with one qubit referred to as the **control** qubit, and the other as the **target** qubit. Interestingly, for the $CZ$ gate it doesn't matter which qubit is control and which is target - the effect of the gate is the same either way!\n\nThe $CZ$ gate acts as a conditional gate: if the control qubit is in state $|1\\rangle$, it applies the $Z$ gate to the target qubit, otherwise it does nothing.\n\n<table>\n    <tr>\n        <th>Gate</th>\n        <th>Matrix</th>\n        <th>Applying to $|\\psi\\rangle = \\alpha|00\\rangle + \\beta|01\\rangle + \\gamma|10\\rangle + \\delta|11\\rangle$</th>\n        <th>Applying to basis states</th>\n    </tr>\n    <tr>\n        <td>$CZ$</td>\n        <td>\n            $$\\begin{bmatrix}\n                1 & 0 & 0 & 0 \\\\\n                0 & 1 & 0 & 0 \\\\\n                0 & 0 & 1 & 0 \\\\\n                0 & 0 & 0 & -1\n            \\end{bmatrix}$$\n        </td>\n        <td>$CZ|\\psi\\rangle = \\alpha|00\\rangle + \\beta|01\\rangle + \\gamma|10\\rangle - \\delta|11\\rangle$</td>\n        <td>\n            $$CZ|00\\rangle = |00\\rangle$$\n            $$CZ|01\\rangle = |01\\rangle$$\n            $$CZ|10\\rangle = |10\\rangle$$\n            $$CZ|11\\rangle = -|11\\rangle$$\n        </td>\n    </tr>\n</table>\n\nThe $CZ$ gate is particularly useful for creating and manipulating entangled states where the phase of the quantum state is crucial. Consider the following separable state:\n\n$$\\big(\\alpha|0\\rangle + \\beta|1\\rangle\\big) \\otimes \\big(\\gamma|0\\rangle + \\delta|1\\rangle\\big) = \\alpha\\gamma|00\\rangle + \\alpha\\delta|01\\rangle + \\beta\\gamma|10\\rangle + \\beta\\delta|11\\rangle$$\n\nIf we apply the $CZ$ gate to it, with the first qubit as the control and the second as the target (or vice versa), we get the following state, which can no longer be separated:\n\n$$\\alpha\\gamma|00\\rangle + \\alpha\\delta|01\\rangle + \\beta\\gamma|10\\rangle - \\beta\\delta|11\\rangle$$\n\nThe $CZ$ gate is also self-adjoint: applying it a second time reverses its effect, similar to the $CNOT$ gate."
+                        }
+                    ]
+                },
+                {
+                    "type": "exercise",
+                    "id": "multi_qubit_gates__relative_phase_minusone",
+                    "title": "Relative Phase -1",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Input:</strong> Two unentangled qubits (stored in an array of length 2) in state $|+\\rangle \\otimes |+\\rangle = \\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle {\\color{blue}+} |11\\rangle \\big)$.</p>\n<p><strong>Goal:</strong> Change the two-qubit state to $\\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle {\\color{red}-} |11\\rangle \\big)$.</p>\n",
+                        "asMarkdown": "**Input:** Two unentangled qubits (stored in an array of length 2) in state $|+\\rangle \\otimes |+\\rangle = \\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle {\\color{blue}+} |11\\rangle \\big)$.\n\n**Goal:** Change the two-qubit state to $\\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle {\\color{red}-} |11\\rangle \\big)$.\n"
+                    },
+                    "sourceIds": [
+                        "multi_qubit_gates__relative_phase_minusone__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation RelativePhaseMinusOne (qs : Qubit[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>Firstly we notice that we are dealing with an unentangled pair of qubits.\nIn vector form the transformation we need is \n$$\n\\frac{1}{2}\\begin{bmatrix}1\\\\ 1\\\\ 1\\\\ 1\\\\ \\end{bmatrix} \n\\rightarrow \n\\frac{1}{2}\\begin{bmatrix}1\\\\ 1\\\\ 1\\\\ -1\\\\ \\end{bmatrix}\n$$</p>\n<p>All that needs to happen to change the input into the goal is that the $|11\\rangle$ basis state needs to have its sign flipped.</p>\n<p>We remember that the Pauli $Z$ gate flips signs in the single qubit case, and that $CZ$ is the 2-qubit version of this gate. And indeed, the effect of the $CZ$ gate is exactly the transformation we&#39;re looking for here.</p>\n",
+                                "asMarkdown": "\nFirstly we notice that we are dealing with an unentangled pair of qubits.\nIn vector form the transformation we need is \n$$\n\\frac{1}{2}\\begin{bmatrix}1\\\\\\ 1\\\\\\ 1\\\\\\ 1\\\\\\ \\end{bmatrix} \n\\rightarrow \n\\frac{1}{2}\\begin{bmatrix}1\\\\\\ 1\\\\\\ 1\\\\\\ -1\\\\\\ \\end{bmatrix}\n$$\n\nAll that needs to happen to change the input into the goal is that the $|11\\rangle$ basis state needs to have its sign flipped.\n\nWe remember that the Pauli $Z$ gate flips signs in the single qubit case, and that $CZ$ is the 2-qubit version of this gate. And indeed, the effect of the $CZ$ gate is exactly the transformation we're looking for here."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_gates__two_qubit_gate_2_solution_a",
+                                "code": "namespace Kata {\n    operation RelativePhaseMinusOne (qs : Qubit[]) : Unit is Adj + Ctl {\n        CZ(qs[0], qs[1]);\n    }\n}"
+                            },
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>Alternatively, we can express this gate using the intrinsic gate Z and its controlled variant using the Controlled functor:</p>\n",
+                                "asMarkdown": "\nAlternatively, we can express this gate using the intrinsic gate Z and its controlled variant using the Controlled functor:"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "multi_qubit_gates__two_qubit_gate_2_solution_b",
+                                "code": "namespace Kata {\n    operation RelativePhaseMinusOne (qs : Qubit[]) : Unit is Adj + Ctl {\n        Controlled Z([qs[0]], qs[1]);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
                 {
                     "type": "lesson",
                     "id": "multi_qubit_gates__ket_bra_representation",
@@ -4083,14 +4267,34 @@ export default {
             "id": "multi_qubit_systems__prepare_with_complex__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareWithComplex_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        H(qs[1]);\n        S(qs[0]);\n        T(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckOperationsEquivalenceOnZeroStateWithFeedback(Kata.PrepareWithComplex, \n            PrepareWithComplex_Reference, 2)\n    }\n}\n"
         },
+        {
+            "id": "multi_qubit_systems__bell_state_change_1__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareBellState(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        CNOT(qs[0], qs[1]);\n    }\n\n\n    operation BellStateChange1_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        Z(qs[0]);\n    }\n\n\n    operation CheckOperationsEquivalenceOnInitialStateStrict(\n        initialState : Qubit[] => Unit is Adj,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n        use (control, target) = (Qubit(), Qubit[inputSize]);\n        within {\n            H(control);\n            initialState(target);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n\n\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = CheckOperationsEquivalenceOnInitialStateStrict(\n            PrepareBellState,\n            Kata.BellStateChange1, \n            BellStateChange1_Reference, \n            2);\n\n\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect\");\n            ShowQuantumStateComparison(2, PrepareBellState, Kata.BellStateChange1, BellStateChange1_Reference);\n        }\n\n\n        return isCorrect;\n    }\n\n   \n}\n"
+        },
+        {
+            "id": "multi_qubit_systems__bell_state_change_2__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareBellState(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        CNOT(qs[0], qs[1]);\n    }\n\n\n    operation BellStateChange2_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n    }\n\n\n    operation CheckOperationsEquivalenceOnInitialStateStrict(\n        initialState : Qubit[] => Unit is Adj,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n        use (control, target) = (Qubit(), Qubit[inputSize]);\n        within {\n            H(control);\n            initialState(target);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n\n\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = CheckOperationsEquivalenceOnInitialStateStrict(\n            PrepareBellState,\n            Kata.BellStateChange2, \n            BellStateChange2_Reference, \n            2);\n\n\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect\");\n            ShowQuantumStateComparison(2, PrepareBellState, Kata.BellStateChange2, BellStateChange2_Reference);\n        }\n\n\n        return isCorrect;\n    }\n\n   \n}\n"
+        },
+        {
+            "id": "multi_qubit_systems__bell_state_change_3__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareBellState(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        CNOT(qs[0], qs[1]);\n    }\n\n\n    operation BellStateChange3_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        Z(qs[0]);\n    }\n\n\n    operation CheckOperationsEquivalenceOnInitialStateStrict(\n        initialState : Qubit[] => Unit is Adj,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n        use (control, target) = (Qubit(), Qubit[inputSize]);\n        within {\n            H(control);\n            initialState(target);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n\n\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = CheckOperationsEquivalenceOnInitialStateStrict(\n            PrepareBellState,\n            Kata.BellStateChange3, \n            BellStateChange3_Reference, \n            2);\n\n\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect\");\n            ShowQuantumStateComparison(2, PrepareBellState, Kata.BellStateChange3, BellStateChange3_Reference);\n        }\n\n\n        return isCorrect;\n    }\n\n   \n}\n"
+        },
         {
             "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            ShowQuantumStateComparison(3, PrepRandomState, solution, reference);\n        }\n\n        isCorrect\n    }\n}"
         },
+        {
+            "id": "multi_qubit_gates__entangle_qubits__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Convert;\n\n    operation  EntangleQubits (qs : Qubit[]) : Unit is Adj + Ctl {\n        CNOT(qs[0], qs[1]);\n    }\n\n    operation CheckOperationsEquivalenceOnInitialStateStrict(\n        initialState : Qubit[] => Unit is Adj,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n        use (control, target) = (Qubit(), Qubit[inputSize]);\n        within {\n            H(control);\n            initialState(target);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n    \n    operation CheckSolution() : Bool {\n        let range = 10;\n        for i in 0 .. range - 1 {\n            let angle = 2.0 * PI() * IntAsDouble(i) / IntAsDouble(range);\n            let initialState = qs => Ry(2.0 * angle, qs[0]);\n            let isCorrect = CheckOperationsEquivalenceOnInitialStateStrict(\n                initialState,\n                Kata.EntangleQubits, \n                EntangleQubits, \n                2);\n            if not isCorrect {\n                Message(\"Incorrect\");\n                Message($\"Test fails for alpha = {Cos(angle)}, beta = {Sin(angle)}.\");\n                ShowQuantumStateComparison(2, initialState, Kata.EntangleQubits, EntangleQubits);\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\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            ShowQuantumStateComparison(2, (qs => ()), solution, reference);\n        }\n\n        isCorrect\n    }\n}"
         },
+        {
+            "id": "multi_qubit_gates__relative_phase_minusone__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Diagnostics;\n\n    operation PrepareState(qs : Qubit[]) : Unit is Adj + Ctl {\n        ApplyToEachCA(H, qs);\n    }\n    operation  RelativePhaseMinusOne (qs : Qubit[]) : Unit is Adj + Ctl {\n        CZ(qs[0], qs[1]);\n    }\n\n    operation CheckOperationsEquivalenceOnInitialStateStrict(\n        initialState : Qubit[] => Unit is Adj,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl),\n        inputSize : Int\n    ) : Bool {\n        use (control, target) = (Qubit(), Qubit[inputSize]);\n        within {\n            H(control);\n            initialState(target);\n        }\n        apply {\n            Controlled op([control], target);\n            Adjoint Controlled reference([control], target);\n        }\n        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\n    }\n\n    operation CheckSolution() : Bool {\n        let isCorrect = CheckOperationsEquivalenceOnInitialStateStrict(\n            PrepareState,\n            Kata.RelativePhaseMinusOne, \n            RelativePhaseMinusOne, \n            2);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect\");\n            ShowQuantumStateComparison(2, PrepareState, Kata.RelativePhaseMinusOne, RelativePhaseMinusOne);\n        }\n\n        return isCorrect;\n    }\n}"
+        },
         {
             "id": "multi_qubit_gates__qubit_swap__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Katas;\n\n    operation QubitSwap (qs : Qubit[], index1 : Int, index2 : Int) : Unit is Adj + Ctl {\n       SWAP(qs[index1], qs[index2]);\n    }\n\n    operation CheckSolution() : Bool {\n        for N in 2 .. 5 {\n            for index1 in 0 .. N-2 {\n                for index2 in index1+1 .. N-1 {\n                    let solution = register => Kata.QubitSwap(register, index1, index2);\n                    let reference = register => QubitSwap(register, index1, index2);\n                    if not CheckOperationsEquivalence(solution, reference, N) {\n                        Message(\"Incorrect.\");\n                        Message($\"Swapping qubits {index1} and {index2} out of $N$ didn't have the expected effect.\");\n                        return false;\n                    }\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}"

package/docs/Microsoft.Quantum.Arrays/All.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.All
 title: All function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Any.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Any
 title: Any function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Chunks.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Chunks
 title: Chunks function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/CircularlyShifted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.CircularlyShifted
 title: CircularlyShifted function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/ColumnAt.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ColumnAt
 title: ColumnAt function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Count.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Count
 title: Count function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays
@@ -37,6 +37,6 @@ The number of elements in `array` that satisfy the predicate.
 
 ## Example
 ```qsharp
- let evensCount = Count(x -> x % 2 == 0, [1, 3, 6, 7, 9]);
+let evensCount = Count(x -> x % 2 == 0, [1, 3, 6, 7, 9]);
 // evensCount is 1.
 ```

package/docs/Microsoft.Quantum.Arrays/Diagonal.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Diagonal
 title: Diagonal function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/DrawMany.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.DrawMany
 title: DrawMany operation
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Enumerated.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Enumerated
 title: Enumerated function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Excluding.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Excluding
 title: Excluding function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Filtered.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Filtered
 title: Filtered function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/FlatMapped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.FlatMapped
 title: FlatMapped function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Flattened.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Flattened
 title: Flattened function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Fold.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Fold
 title: Fold function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/ForEach.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ForEach
 title: ForEach operation
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Head.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Head
 title: Head function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/HeadAndRest.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.HeadAndRest
 title: HeadAndRest function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IndexOf.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IndexOf
 title: IndexOf function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IndexRange.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IndexRange
 title: IndexRange function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Interleaved.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Interleaved
 title: Interleaved function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsEmpty.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsEmpty
 title: IsEmpty function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsRectangularArray.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsRectangularArray
 title: IsRectangularArray function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsSorted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsSorted
 title: IsSorted function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsSquareArray.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsSquareArray
 title: IsSquareArray function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Mapped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Mapped
 title: Mapped function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/MappedByIndex.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.MappedByIndex
 title: MappedByIndex function
-ms.date: 04/17/2024 12:00:00 AM
+ms.date: 04/23/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays