qsharp-lang 1.5.6-dev → 1.6.0

package/dist/katas-content.generated.js

@@ -6111,6 +6111,157 @@ export default {
             ],
             "published": false
         },
+        {
+            "id": "marking_oracles",
+            "title": "Marking Oracles",
+            "sections": [
+                {
+                    "type": "lesson",
+                    "id": "marking_oracles__overview",
+                    "title": "Overview",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "asHtml": "<p>Quantum oracles are a key part of many quantum algorithms that rely on a quantum implementation of a classical function. The algorithms' discussions often assume that the quantum oracle that implements the function of interest is provided.\nHowever, in practice implementing a quantum oracle for a specific problem can be quite challenging.</p>\n<p>This kata continues the exploration of quantum oracles started in the Oracles kata, offering you a variety of practice problems on implementing marking oracles. If you're not familiar with the concept of quantum oracles, make sure to check out the Oracles kata that introduces the key concepts in this topic and offers a lot of simple practice problems.</p>\n<p><strong>This kata covers the following topics:</strong></p>\n<ul>\n<li>Implementation of marking oracles for different classical functions</li>\n</ul>\n<p><strong>What you should know to start working on this kata:</strong></p>\n<ul>\n<li>Fundamental quantum concepts</li>\n<li>Controlled gates</li>\n<li>Oracles, in particular marking oracles</li>\n</ul>\n",
+                            "asMarkdown": "\nQuantum oracles are a key part of many quantum algorithms that rely on a quantum implementation of a classical function. The algorithms' discussions often assume that the quantum oracle that implements the function of interest is provided.\nHowever, in practice implementing a quantum oracle for a specific problem can be quite challenging.\n\nThis kata continues the exploration of quantum oracles started in the Oracles kata, offering you a variety of practice problems on implementing marking oracles. If you're not familiar with the concept of quantum oracles, make sure to check out the Oracles kata that introduces the key concepts in this topic and offers a lot of simple practice problems.\n\n**This kata covers the following topics:**\n\n- Implementation of marking oracles for different classical functions\n\n**What you should know to start working on this kata:**\n\n- Fundamental quantum concepts\n- Controlled gates\n- Oracles, in particular marking oracles"
+                        }
+                    ]
+                },
+                {
+                    "type": "exercise",
+                    "id": "marking_oracles__kth_bit",
+                    "title": "K-th Bit",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>$N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).</li>\n<li>A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).</li>\n<li>An integer $k$ such that $0 \\le k &lt; N$.</li>\n</ol>\n<p><strong>Goal:</strong>\nImplement a marking oracle which calculates the $k$-th bit of the input array, that is, the function\n$$f(x) = x_k$$</p>\n<p>In other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in.\nYour solution should work on inputs in superposition, and not use any measurements.</p>\n",
+                        "asMarkdown": "**Inputs:** \n\n1. $N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).\n2. A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).\n3. An integer $k$ such that $0 \\le k < N$.\n\n**Goal:** \nImplement a marking oracle which calculates the $k$-th bit of the input array, that is, the function\n$$f(x) = x_k$$\n\nIn other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in. \nYour solution should work on inputs in superposition, and not use any measurements.\n"
+                    },
+                    "sourceIds": [
+                        "marking_oracles__kth_bit__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation Oracle_Kth_Bit(x : Qubit[], y : Qubit, k : Int) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>Since the effect of this oracle depends only on the value of the $k$-th qubit, we can ignore the rest of the qubits and focus on just <code>x[k]</code>. We need to flip the state of the target qubit if the input qubit <code>x[k]</code> is in the $\\ket{1}$ state and leave it unchanged otherwise - this is exactly the effect of the $CNOT$ gate with the qubit <code>x[k]</code> used as control and the qubit <code>y</code> used as target.</p>\n",
+                                "asMarkdown": "\nSince the effect of this oracle depends only on the value of the $k$-th qubit, we can ignore the rest of the qubits and focus on just `x[k]`. We need to flip the state of the target qubit if the input qubit `x[k]` is in the $\\ket{1}$ state and leave it unchanged otherwise - this is exactly the effect of the $CNOT$ gate with the qubit `x[k]` used as control and the qubit `y` used as target."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "marking_oracles__kth_bit_solution",
+                                "code": "namespace Kata {\n    operation Oracle_Kth_Bit(x : Qubit[], y : Qubit, k : Int) : Unit is Adj + Ctl {\n        CNOT(x[k], y);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "marking_oracles__parity",
+                    "title": "Parity Function",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>$N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).</li>\n<li>A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).</li>\n</ol>\n<p><strong>Goal:</strong>\nImplement a marking oracle which calculates the parity of the input array, that is, the function\n$$f(x) = 1 \\text{ if } x \\text{ has an odd number of 1s, and } 0 \\text{ otherwise }$$</p>\n<p>In other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in.\nYour solution should work on inputs in superposition, and not use any measurements.</p>\n<details>\n<summary><strong>Need a hint?</strong></summary>\n$f(x)$ can be represented as $x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}$.\n</details>\n",
+                        "asMarkdown": "**Inputs:** \n\n1. $N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).\n2. A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).\n\n**Goal:** \nImplement a marking oracle which calculates the parity of the input array, that is, the function\n$$f(x) = 1 \\text{ if } x \\text{ has an odd number of 1s, and } 0 \\text{ otherwise }$$\n\nIn other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in. \nYour solution should work on inputs in superposition, and not use any measurements.\n\n<details>\n<summary><strong>Need a hint?</strong></summary>\n$f(x)$ can be represented as $x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}$.\n</details>\n"
+                    },
+                    "sourceIds": [
+                        "marking_oracles__parity__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation Oracle_Parity(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>We can write $f(x)$ as follows:</p>\n<p>$$f(x) = x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}$$</p>\n<p>Let's substitute this expression in the expression for the oracle effect on the quantum state:</p>\n<p>$$U_f \\ket{x} \\ket{y} = \\ket{x} \\ket{y \\oplus f(x)} = \\ket{x} \\ket{y \\oplus x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}}$$</p>\n<p>Now, we can represent the final state of the target qubit as a result of a series of $N$ marking oracles applied sequentially, marking oracle $j$ flipping its state if the state of the input qubit $j$ $\\ket{x_j}$ is $\\ket{1}$.\nAs we saw in the previous task, each of these marking oracles can be implemented as a single $CNOT$ gate.</p>\n",
+                                "asMarkdown": "\nWe can write $f(x)$ as follows:\n\n$$f(x) = x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}$$\n\nLet's substitute this expression in the expression for the oracle effect on the quantum state:\n\n$$U_f \\ket{x} \\ket{y} = \\ket{x} \\ket{y \\oplus f(x)} = \\ket{x} \\ket{y \\oplus x_0 \\oplus x_1 \\oplus ... \\oplus x_{N-1}}$$\n\nNow, we can represent the final state of the target qubit as a result of a series of $N$ marking oracles applied sequentially, marking oracle $j$ flipping its state if the state of the input qubit $j$ $\\ket{x_j}$ is $\\ket{1}$.\nAs we saw in the previous task, each of these marking oracles can be implemented as a single $CNOT$ gate."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "marking_oracles__parity_solution",
+                                "code": "namespace Kata {\n    operation Oracle_Parity(x : Qubit[], y : Qubit) : Unit is Adj + Ctl {\n        for xi in x {\n            CNOT(xi, y);\n        }\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "marking_oracles__product",
+                    "title": "Product Function",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>$N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).</li>\n<li>A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).</li>\n<li>A bit vector $r$ of length $N$ represented as a <code>Bool[]</code>.</li>\n</ol>\n<p><strong>Goal:</strong>\nImplement a marking oracle which calculates the scalar product function\n$$f(x) = \\bigoplus\\limits_{i=0}^{N-1} r_i x_i$$</p>\n<p>In other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in.\nYour solution should work on inputs in superposition, and not use any measurements.</p>\n",
+                        "asMarkdown": "**Inputs:** \n\n1. $N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).\n2. A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).\n3. A bit vector $r$ of length $N$ represented as a `Bool[]`.\n\n**Goal:** \nImplement a marking oracle which calculates the scalar product function\n$$f(x) = \\bigoplus\\limits_{i=0}^{N-1} r_i x_i$$\n\nIn other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in. \nYour solution should work on inputs in superposition, and not use any measurements.\n"
+                    },
+                    "sourceIds": [
+                        "marking_oracles__product__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation Oracle_Product(x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>This problem is similar to the previous one, but this time the input qubit <code>x[j]</code> affects the state of the target qubit only if the classical input <code>r[i]</code> is set to <code>true</code>.\nWe can use a similar approach to the solution as well: iterate through all input qubits, check whether the corresponding input bit <code>r[i]</code> is <code>true</code>, and if it is, apply a $CNOT$ gate with qubit <code>x[j]</code> as the control and the qubit <code>y</code> as the target.</p>\n",
+                                "asMarkdown": "\nThis problem is similar to the previous one, but this time the input qubit `x[j]` affects the state of the target qubit only if the classical input `r[i]` is set to `true`. \nWe can use a similar approach to the solution as well: iterate through all input qubits, check whether the corresponding input bit `r[i]` is `true`, and if it is, apply a $CNOT$ gate with qubit `x[j]` as the control and the qubit `y` as the target."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "marking_oracles__product_solution",
+                                "code": "namespace Kata {\n    operation Oracle_Product(x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {\n        for i in 0 .. Length(x) - 1 {\n            if r[i] {\n                CNOT(x[i], y);\n            }\n        }\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "marking_oracles__product_negation",
+                    "title": "Product Function with Negation",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p><strong>Inputs:</strong></p>\n<ol>\n<li>$N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).</li>\n<li>A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).</li>\n<li>A bit vector $r$ of length $N$ represented as a <code>Bool[]</code>.</li>\n</ol>\n<p><strong>Goal:</strong>\nImplement a marking oracle which calculates the following function:\n$$f(x) = \\bigoplus\\limits_{i=0}^{N-1} \\left(r_i x_i \\oplus (1 - r_i) (1 - x_i) \\right)$$</p>\n<p>In other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in.\nYour solution should work on inputs in superposition, and not use any measurements.</p>\n<details>\n<summary><strong>Need a hint?</strong></summary>\nSince each addition is done modulo $2$, you can evaluate the effect of each term independently.\n</details>\n",
+                        "asMarkdown": "**Inputs:** \n\n1. $N$ qubits in an arbitrary state $\\ket{x}$ (input/query register).\n2. A qubit in an arbitrary state $\\ket{y}$ (output/target qubit).\n3. A bit vector $r$ of length $N$ represented as a `Bool[]`.\n\n**Goal:** \nImplement a marking oracle which calculates the following function:\n$$f(x) = \\bigoplus\\limits_{i=0}^{N-1} \\left(r_i x_i \\oplus (1 - r_i) (1 - x_i) \\right)$$\n\nIn other words, for each basis state $\\ket{x}$, flip the state of the target qubit $\\ket{y}$ if $f(x) = 1$, and leave it unchanged otherwise.\nLeave the qubits in the input register in the same state they started in. \nYour solution should work on inputs in superposition, and not use any measurements.\n\n<details>\n<summary><strong>Need a hint?</strong></summary>\nSince each addition is done modulo $2$, you can evaluate the effect of each term independently.\n</details>\n"
+                    },
+                    "sourceIds": [
+                        "marking_oracles__product_negation__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation Oracle_ProductWithNegation(x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {\n        // Implement your solution here...\n\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>Again, this problem is similar to the previous one. This time, each input qubit <code>x[j]</code> always affects the state of the target qubit, and the matching classical input <code>r[i]</code> specifies the way how it does that.\nIf the bit <code>r[i]</code> is <code>true</code>, the state of the target qubit is flipped if the input qubit <code>x[j]</code> is in the $\\ket{1}$ state;\notherwise, it is flipped if <code>x[j]</code> is in the $\\ket{0}$ state. (You can check that this is exactly what the formula\n$\\left(r_i x_i \\oplus (1 - r_i) (1 - x_i) \\right)$ evaluates to!)</p>\n<p>This means that we need to modify our solution to the previous task to add a second clause to the if statement, to handle the case when <code>r[i]</code> is <code>false</code>. The gate we need to apply in this scenario is controlled-on-zero $X$, which we can implement using the library operation <code>ApplyControlledOnInt</code>.</p>\n",
+                                "asMarkdown": "\nAgain, this problem is similar to the previous one. This time, each input qubit `x[j]` always affects the state of the target qubit, and the matching classical input `r[i]` specifies the way how it does that. \nIf the bit `r[i]` is `true`, the state of the target qubit is flipped if the input qubit `x[j]` is in the $\\ket{1}$ state;\notherwise, it is flipped if `x[j]` is in the $\\ket{0}$ state. (You can check that this is exactly what the formula \n$\\left(r_i x_i \\oplus (1 - r_i) (1 - x_i) \\right)$ evaluates to!)\n\nThis means that we need to modify our solution to the previous task to add a second clause to the if statement, to handle the case when `r[i]` is `false`. The gate we need to apply in this scenario is controlled-on-zero $X$, which we can implement using the library operation `ApplyControlledOnInt`."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "marking_oracles__product_negation_solution",
+                                "code": "namespace Kata {\n    operation Oracle_ProductWithNegation(x : Qubit[], y : Qubit, r : Bool[]) : Unit is Adj + Ctl {\n        for i in 0 .. Length(x) - 1 {\n            if r[i] {\n                CNOT(x[i], y);\n            } else {\n                ApplyControlledOnInt(0, X, [x[i]], y);\n            }\n        }\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "lesson",
+                    "id": "marking_oracles__conclusion",
+                    "title": "Conclusion",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "asHtml": "<p>Congratulations! In this kata you got a lot of practice building quantum oracles for different classical functions.</p>\n",
+                            "asMarkdown": "\nCongratulations! In this kata you got a lot of practice building quantum oracles for different classical functions."
+                        }
+                    ]
+                }
+            ],
+            "published": false
+        },
         {
             "id": "teleportation",
             "title": "Teleportation",
@@ -6262,6 +6413,68 @@ export default {
                             }
                         ]
                     }
+                },
+                {
+                    "type": "exercise",
+                    "id": "teleportation__prepare_and_send_message",
+                    "title": "Prepare Message and Send It",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p>Given a message represented as a Pauli basis and a Result value indicating a basis state of that basis, prepare a message qubit in that state.\nResult values <code>Zero</code> and <code>One</code> correspond to preparing states $\\ket{0}$ or $\\ket{1}$ for <code>PauliZ</code> basis, $\\ket{+}$ or $\\ket{-}$ for <code>PauliX</code> basis, and $\\ket{i}$ or $\\ket{-i}$ for <code>PauliY</code> basis. Then entangle this <code>qMessage</code> qubit with Alice's qubit, and extract two classical bits to be sent to Bob.</p>\n<p><strong>Inputs:</strong></p>\n<ol>\n<li>Alice's part of the entangled pair of qubits <code>qAlice</code>.</li>\n<li>A basis in which the message qubit should be prepared - <code>PauliX</code>, <code>PauliY</code>, or <code>PauliZ</code>.</li>\n<li>A Result value indicating the qubit state.</li>\n</ol>\n<p><strong>Outputs:</strong>\nTwo classical bits Alice will send to Bob via classical channel as a tuple of <code>Bool</code> values. Same as in the earlier task, the first bit in the tuple should hold the result of measurement of the message qubit and the second bit, the result of measurement of Alice's qubit. Represent measurement result <code>One</code> as <code>true</code> and <code>Zero</code> as <code>false</code>. The state of the qubit <code>qAlice</code> in the end of the operation doesn't matter.</p>\n",
+                        "asMarkdown": "Given a message represented as a Pauli basis and a Result value indicating a basis state of that basis, prepare a message qubit in that state. \nResult values `Zero` and `One` correspond to preparing states $\\ket{0}$ or $\\ket{1}$ for `PauliZ` basis, $\\ket{+}$ or $\\ket{-}$ for `PauliX` basis, and $\\ket{i}$ or $\\ket{-i}$ for `PauliY` basis. Then entangle this `qMessage` qubit with Alice's qubit, and extract two classical bits to be sent to Bob.\n\n**Inputs:** \n1. Alice's part of the entangled pair of qubits `qAlice`.\n2. A basis in which the message qubit should be prepared - `PauliX`, `PauliY`, or `PauliZ`.\n3. A Result value indicating the qubit state.\n\n**Outputs:** \nTwo classical bits Alice will send to Bob via classical channel as a tuple of `Bool` values. Same as in the earlier task, the first bit in the tuple should hold the result of measurement of the message qubit and the second bit, the result of measurement of Alice's qubit. Represent measurement result `One` as `true` and `Zero` as `false`. The state of the qubit `qAlice` in the end of the operation doesn't matter."
+                    },
+                    "sourceIds": [
+                        "teleportation__prepare_and_send_message__Verification.qs",
+                        "KatasLibrary.qs",
+                        "teleportation__Common.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation PrepareAndSendMessage(qAlice : Qubit, basis : Pauli, state : Result) : (Bool, Bool) {\n        // Implement your solution here...\n        return (false, false);\n    }\n    \n    // You might find this helper operation from earlier tasks useful.\n    operation SendMessage(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {\n        CNOT(qMessage, qAlice);\n        H(qMessage);\n        return (M(qMessage) == One, M(qAlice) == One);\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>The exercise aims to prepare the <code>qMessage</code> as one of the basis states of the required Pauli bases.</p>\n<ul>\n<li>Initialize the <code>qMessage</code> qubit in $\\ket{0}$ or $\\ket{1}$ based on the value of <code>state</code>. These are the eigenstates of Pauli $Z$ gate.</li>\n<li>Using the $H$ gate, eigenstates of the Pauli $X$ gate can be prepared from the eigenstates of Pauli $Z$:\n$$\\ket{+} = H\\ket{0}, \\ket{-} = H\\ket{1}$$</li>\n<li>Using the $S$ gate, eigenstates of the Pauli $Y$ gate can be prepared from the eigenstates of Pauli $X$:\n$$\\ket{i} = S\\ket{+}, \\ket{-i} = S\\ket{-}$$</li>\n</ul>\n<p>Finally, use the <code>SendMessage</code> operation implemented in the earlier exercise to send the message.</p>\n",
+                                "asMarkdown": "\nThe exercise aims to prepare the `qMessage` as one of the basis states of the required Pauli bases.\n\n- Initialize the `qMessage` qubit in $\\ket{0}$ or $\\ket{1}$ based on the value of `state`. These are the eigenstates of Pauli $Z$ gate.\n- Using the $H$ gate, eigenstates of the Pauli $X$ gate can be prepared from the eigenstates of Pauli $Z$:\n  $$\\ket{+} = H\\ket{0}, \\ket{-} = H\\ket{1}$$\n- Using the $S$ gate, eigenstates of the Pauli $Y$ gate can be prepared from the eigenstates of Pauli $X$:\n  $$\\ket{i} = S\\ket{+}, \\ket{-i} = S\\ket{-}$$\n\nFinally, use the `SendMessage` operation implemented in the earlier exercise to send the message."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "teleportation__prepare_and_send_message_solution",
+                                "code": "namespace Kata {\n    operation PrepareAndSendMessage(qAlice : Qubit, basis : Pauli, state : Result) : (Bool, Bool) {\n        use qMessage = Qubit();\n        if state == One {\n            X(qMessage);\n        }\n        if basis != PauliZ {\n            H(qMessage);\n        }\n        if basis == PauliY {\n            S(qMessage);\n        }\n        let classicalBits = SendMessage(qAlice, qMessage);\n        Reset(qMessage);\n        return classicalBits;\n    }\n\n    operation SendMessage(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {\n        CNOT(qMessage, qAlice);\n        H(qMessage);\n        return (M(qMessage) == One, M(qAlice) == One);\n    }\n}"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "teleportation__reconstruct_and_measure_message",
+                    "title": "Reconstruct Message and Measure It",
+                    "description": {
+                        "type": "text-content",
+                        "asHtml": "<p>Transform Bob's qubit into the required state using the two classical bits received from Alice and measure it in the same basis in which she prepared the message.</p>\n<p><strong>Inputs:</strong></p>\n<ol>\n<li>Bob's part of the entangled pair of qubits <code>qBob</code>.</li>\n<li>The tuple of classical bits received from Alice, in the format used in the Send Message exercise.</li>\n<li>The basis in which the message qubit was originally prepared - <code>PauliX</code>, <code>PauliY</code>, or <code>PauliZ</code>.</li>\n</ol>\n<p><strong>Output:</strong>\nA Result value indicating the basis state in which the message qubit was prepared, <code>One</code> or <code>Zero</code>. The state of the qubit <code>qBob</code> in the end of the operation doesn't matter.</p>\n",
+                        "asMarkdown": "Transform Bob's qubit into the required state using the two classical bits received from Alice and measure it in the same basis in which she prepared the message.\n\n**Inputs:** \n1. Bob's part of the entangled pair of qubits `qBob`.\n2. The tuple of classical bits received from Alice, in the format used in the Send Message exercise.\n3. The basis in which the message qubit was originally prepared - `PauliX`, `PauliY`, or `PauliZ`.\n\n**Output:** \nA Result value indicating the basis state in which the message qubit was prepared, `One` or `Zero`. The state of the qubit `qBob` in the end of the operation doesn't matter."
+                    },
+                    "sourceIds": [
+                        "teleportation__reconstruct_and_measure_message__Verification.qs",
+                        "KatasLibrary.qs",
+                        "teleportation__Common.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation ReconstructAndMeasureMessage(qBob : Qubit, (b1 : Bool, b2 : Bool), basis : Pauli) : Result {    \n        // Implement your solution here...\n        return Zero;\n    }\n    \n    // You might find this helper operation from earlier tasks useful.\n    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {\n        if b1 {\n            Z(qBob);\n        }\n        if b2 {\n            X(qBob);\n        }\n    }\n}",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "asHtml": "<p>The exercise can be done easily using solutions to earlier exercises.</p>\n<ul>\n<li>First, reconstruct the state of qubit <code>qBob</code> using the <code>ReconstructMessage</code> operation from an earlier exercise. This would bring the <code>qBob</code> state into one of the basis states of the given basis.</li>\n<li>Now, we know from the &quot;Measurements in Single-Qubit Systems&quot; kata that the default measurement operation <code>M</code> performs measurement in the <code>Pauli Z</code> basis. To get the correct result for the measurement of <code>qBob</code> qubit, you need to perform the measurement in the given basis using the operation <code>Measure</code>.</li>\n</ul>\n",
+                                "asMarkdown": "\nThe exercise can be done easily using solutions to earlier exercises.\n- First, reconstruct the state of qubit `qBob` using the `ReconstructMessage` operation from an earlier exercise. This would bring the `qBob` state into one of the basis states of the given basis.\n- Now, we know from the \"Measurements in Single-Qubit Systems\" kata that the default measurement operation `M` performs measurement in the `Pauli Z` basis. To get the correct result for the measurement of `qBob` qubit, you need to perform the measurement in the given basis using the operation `Measure`."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "teleportation__reconstruct_and_measure_solution",
+                                "code": "namespace Kata {\n    operation ReconstructAndMeasureMessage(qBob : Qubit, (b1 : Bool, b2 : Bool), basis : Pauli) : Result {\n        ReconstructMessage(qBob, (b1, b2));\n        return Measure([basis], [qBob]);\n    }\n\n    operation ReconstructMessage(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {\n        if b1 {\n            Z(qBob);\n        }\n        if b2 {\n            X(qBob);\n        }\n    }\n}"
+                            }
+                        ]
+                    }
                 }
             ],
             "published": false
@@ -6274,7 +6487,7 @@ export default {
         },
         {
             "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.Math;\n    open Microsoft.Quantum.Random;\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 CheckOperationsAreEqualStrict(\n        inputSize : Int,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl))\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 = CheckOperationsAreEqual(inputSize + 1, controlledOp, controlledReference);\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\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the given initial state composed of `inputSize` qubits.\n    /// The initial state is prepared by applying the `initialState` operation to the state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉.\n    /// This operation introduces a control qubit to convert a global phase into a relative phase to be able to detect it.\n    /// `initialState` operation should be deterministic.\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        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\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.\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        CheckOperationsEquivalenceOnInitialStateStrict(qs => (), op, reference, inputSize)\n    }\n\n\n    /// # Summary\n    /// Shows the comparison of the quantum states produced by a specific operation and a reference operation\n    /// when applied to the state prepared using deterministic operation `initialState`.\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 PrepDemoState(qs : Qubit[]) : Unit {\n        Fact(Length(qs) <= 4, \"States with 5 qubits or more are not supported.\");\n        let probs = [0.36, 0.25, 1. / 3., 1. / 5.][... Length(qs) - 1];\n        for (q, prob) in Zipped(qs, probs) {\n            Ry(ArcCos(Sqrt(prob)) * 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"
+            "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.Convert;\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 (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 CheckOperationsAreEqualStrict(\n        inputSize : Int,\n        op : (Qubit[] => Unit is Adj + Ctl),\n        reference : (Qubit[] => Unit is Adj + Ctl))\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 = CheckOperationsAreEqual(inputSize + 1, controlledOp, controlledReference);\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\n    /// # Summary\n    /// Given two operations, checks whether they act identically on the given initial state composed of `inputSize` qubits.\n    /// The initial state is prepared by applying the `initialState` operation to the state |0〉 ⊗ |0〉 ⊗ ... ⊗ |0〉.\n    /// This operation introduces a control qubit to convert a global phase into a relative phase to be able to detect it.\n    /// `initialState` operation should be deterministic.\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        let isCorrect = CheckAllZero([control] + target);\n        ResetAll([control] + target);\n        isCorrect\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.\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        CheckOperationsEquivalenceOnInitialStateStrict(qs => (), op, reference, inputSize)\n    }\n\n\n    /// # Summary\n    /// Shows the comparison of the quantum states produced by a specific operation and a reference operation\n    /// when applied to the state prepared using deterministic operation `initialState`.\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 PrepDemoState(qs : Qubit[]) : Unit {\n        Fact(Length(qs) <= 4, \"States with 5 qubits or more are not supported.\");\n        let probs = [0.36, 0.25, 1. / 3., 1. / 5.][... Length(qs) - 1];\n        for (q, prob) in Zipped(qs, probs) {\n            Ry(ArcCos(Sqrt(prob)) * 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    /// # Summary\n    /// Given a marking oracle acting on N inputs, and a classical function acting on N bits, \n    /// checks whether the oracle effect matches that of the function on every classical input.\n    operation CheckOracleImplementsFunction (\n        N : Int, \n        oracle : (Qubit[], Qubit) => Unit, \n        f : Bool[] -> Bool\n    ) : Bool {\n        let size = 1 <<< N;\n        use (input, target) = (Qubit[N], Qubit());\n        for k in 0 .. size - 1 {\n            // Prepare k-th bit vector\n            let binaryLE = IntAsBoolArray(k, N);\n            \n            // \"binary\" is little-endian notation, so the second vector tried has qubit 0 in state 1 and the rest in state 0\n            ApplyPauliFromBitString(PauliX, true, binaryLE, input);\n            \n            // Apply the operation\n            oracle(input, target);\n            \n            // Calculate the expected classical result\n            let val = f(binaryLE);\n\n            // Apply operations that will revert the qubits to the 0 state if the oracle acted correctly.\n            if val {\n                X(target);\n            }\n            ApplyPauliFromBitString(PauliX, true, binaryLE, input);\n\n            if not CheckAllZero(input + [target]) {\n                Message($\"Unexpected result on input {binaryLE}.\");\n                if not CheckAllZero(input) {\n                    Message(\"The state of the input qubits changed, or they ended up entangled with the target qubit.\");\n                    Message(\"The state of the system after oracle application:\");\n                    DumpMachine();\n                } else {\n                    Message($\"Expected result `{val}`, got `{not val}`.\");\n                }\n                ResetAll(input + [target]);\n                return false;\n            }\n        }\n        return true;\n    }\n}\n"
         },
         {
             "id": "complex_arithmetic__powers_of_i__Verification.qs",
@@ -6856,13 +7069,29 @@ export default {
             "id": "distinguishing_states__Common.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Random;\n\n    operation DistinguishStates_MultiQubit_Threshold (nQubit : Int, \n                                                      nState : Int, \n                                                      threshold : Double, \n                                                      statePrep : ((Qubit, Int) => Unit), \n                                                      testImpl : (Qubit => Bool)) : Bool {\n        let nTotal = 1000;\n        mutable nOk = 0;\n\n        use qs = Qubit[nQubit];\n        for i in 1 .. nTotal {\n            // get a random integer to define the state of the qubits\n            let state = DrawRandomInt(0, nState - 1);\n\n            // do state prep: convert |0⟩ to outcome with return equal to state\n            statePrep(qs[0], state);\n\n            // get the solution's answer and verify that it's a match\n            let ans = testImpl(qs[0]);\n            if ans == (state == 0) {\n                set nOk += 1;\n            }\n\n            // we're not checking the state of the qubit after the operation\n            ResetAll(qs);\n        }\n\n        if IntAsDouble(nOk) < threshold * IntAsDouble(nTotal) {\n            Message($\"{nTotal - nOk} test runs out of {nTotal} returned incorrect state, which does not meet the required threshold of at least {threshold * 100.0}%.\");\n            Message(\"Incorrect.\");\n            return false;\n        } else {\n            Message(\"Correct!\");\n            return true;\n        }\n    }\n}\n"
         },
+        {
+            "id": "marking_oracles__kth_bit__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    function F_Kth_Bit(x : Bool[], k : Int) : Bool {\n        x[k]\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for n in 3 .. 5 {\n            for k in 0 .. n - 1 {\n                if not CheckOracleImplementsFunction(n, Kata.Oracle_Kth_Bit(_, _, k), F_Kth_Bit(_, k)) {\n                    Message($\"Test failed for n = {n}, k = {k}\");\n                    return false;\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "marking_oracles__parity__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    function F_Parity(x : Bool[]) : Bool {\n        mutable parity = false;\n        for xi in x {\n            if xi {\n                set parity = not parity;\n            }\n        }\n        parity\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for n in 1 .. 5 {\n            if not CheckOracleImplementsFunction(n, Kata.Oracle_Parity, F_Parity) {\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "marking_oracles__product__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    function F_Product(x : Bool[], r : Bool[]) : Bool {\n        mutable product = false;\n        for i in 0 .. Length(x) - 1 {\n            if r[i] and x[i] {\n                set product = not product;\n            }\n        }\n        product\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let n = 3;\n        for mask in 0 .. 2 ^ n - 1 {\n            let r = IntAsBoolArray(mask, 3);\n            if not CheckOracleImplementsFunction(n, Kata.Oracle_Product(_, _, r), F_Product(_, r)) {\n                Message($\"Test failed for n = {n}, r = {r}\");\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "marking_oracles__product_negation__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Katas;\n\n    function F_ProductWithNegation(x : Bool[], r : Bool[]) : Bool {\n        mutable product = false;\n        for i in 0 .. Length(x) - 1 {\n            if r[i] and x[i] or (not r[i] and not x[i]) {\n                set product = not product;\n            }\n        }\n        product\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let n = 3;\n        for mask in 0 .. 2 ^ n - 1 {\n            let r = IntAsBoolArray(mask, 3);\n            if not CheckOracleImplementsFunction(n, Kata.Oracle_ProductWithNegation(_, _, r), F_ProductWithNegation(_, r)) {\n                Message($\"Test failed for n = {n}, r = {r}\");\n                return false;\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
         {
             "id": "teleportation__entangled_pair__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation Entangle_Wrapper (qs : Qubit[]) : Unit is Adj {\n        Kata.Entangle(qs[0], qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        \n        return CheckOperationsEquivalenceOnZeroStateWithFeedback(\n            Entangle_Wrapper,\n            EntangleWrapper_Reference,\n            2\n        );\n        \n    }\n}\n"
         },
         {
             "id": "teleportation__Common.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n\n    operation EntangleWrapper_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        let (qAlice, qBob) = (qs[0], qs[1]);\n        H(qAlice);\n        CNOT(qAlice, qBob);\n    }\n\n    // ------------------------------------------------------\n    // Helper which prepares proper Bell state on two qubits\n    // 0 - |Φ⁺⟩ = (|00⟩ + |11⟩) / sqrt(2)\n    // 1 - |Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2)\n    // 2 - |Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2)\n    // 3 - |Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2)\n    operation StatePrep_BellState(q1 : Qubit, q2 : Qubit, state : Int) : Unit {\n        H(q1);\n        CNOT(q1, q2);\n        \n        // now we have |00⟩ + |11⟩ - modify it based on state arg\n        if state % 2 == 1 {\n            // negative phase\n            Z(q2);\n        }\n        \n        if state / 2 == 1 {\n            X(q2);\n        }\n    }\n\n    // ------------------------------------------------------\n    // Helper operation that run teleportation using the given operations to prepare the message qubit\n    // and the entangled pair, and to run sender and receiver parts of the protocol.\n    operation ComposeTeleportation(\n        bellPrepOp : ((Qubit, Qubit) => Unit), \n        getDescriptionOp : ((Qubit, Qubit) => (Bool, Bool)), \n        reconstructOp : ((Qubit, (Bool, Bool)) => Unit),\n        qAlice : Qubit, \n        qBob : Qubit, \n        qMessage : Qubit) : Unit {\n\n        bellPrepOp(qAlice, qBob);\n        let classicalBits = getDescriptionOp(qAlice, qMessage);\n        \n        // Alice sends the classical bits to Bob.\n        // Bob uses these bits to transform his part of the entangled pair into the message.\n        reconstructOp(qBob, classicalBits);\n    }\n    \n    operation SendMessage_Reference(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {\n        CNOT(qMessage, qAlice);\n        H(qMessage);\n        return (M(qMessage) == One, M(qAlice) == One);\n    }\n\n    operation ReconstructMessage_Reference(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {\n        if b1 {\n            Z(qBob);\n        }\n        if b2 {\n            X(qBob);\n        }\n    }\n\n    // ------------------------------------------------------\n    // Helper operation that runs a teleportation operation (specified by teleportOp).\n    // The state to teleport is set up using an operation (specified by setupPsiOp).\n    //\n    // Specifying the state to teleport through an operation allows to get the inverse\n    // which makes testing easier.\n    operation TeleportTestHelper(\n        teleportOp : ((Qubit, Qubit, Qubit) => Unit), \n        setupPsiOp : (Qubit => Unit is Adj),\n        psiName: String) : Bool {\n        \n        use (qMessage, qAlice, qBob) = (Qubit(), Qubit(), Qubit());\n        setupPsiOp(qMessage);\n            \n        // This should modify qBob to be identical to the state\n        // of qMessage before the function call.\n        teleportOp(qAlice, qBob, qMessage);\n            \n        // Applying the inverse of the setup operation to qBob\n        // should make it Zero.\n        Adjoint setupPsiOp(qBob);\n        if not CheckZero(qBob) {\n            Message($\"Incorrect. The state {psiName} was teleported incorrectly.\");\n            setupPsiOp(qBob);\n            Message(\"The state of the qubits [qMessage, qAlice, qBob] after teleportation:\");\n            DumpMachine();\n            ResetAll([qMessage, qAlice, qBob]);\n            return false;\n        }\n        ResetAll([qMessage, qAlice, qBob]);\n        return true;\n    }\n\n    // ------------------------------------------------------\n    // Run teleportation for a number of different states.\n    // After each teleportation success is asserted.\n    // Also repeats for each state several times as\n    // code is expected to take different paths each time because\n    // measurements done by Alice are not deterministic.\n    operation TeleportTestLoop(teleportOp : ((Qubit, Qubit, Qubit) => Unit)) : Bool {\n        // Define setup operations for the message qubit\n        // on which to test teleportation: |0⟩, |1⟩, |0⟩ + |1⟩, unequal superposition.\n        let setupPsiOps = [(I, \"|0⟩\"), (X, \"|1⟩\"), (H, \"|+⟩\"), (Ry(ArcCos(0.6) * 2.0, _), \"0.6|0⟩ + 0.8|1⟩\")];\n        \n        // As part of teleportation Alice runs some measurements\n        // with nondeterministic outcome.\n        // Depending on the outcomes different paths are taken on Bob's side.\n        // We repeat each test run several times to ensure that all paths are checked.\n        let numRepetitions = 100;\n        for (psiOp, psiName) in setupPsiOps {\n            for j in 1 .. numRepetitions {\n                if not TeleportTestHelper(teleportOp, psiOp, psiName) {\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct.\");\n        return true;\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n\n    operation EntangleWrapper_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        let (qAlice, qBob) = (qs[0], qs[1]);\n        H(qAlice);\n        CNOT(qAlice, qBob);\n    }\n\n    // ------------------------------------------------------\n    // Helper which prepares proper Bell state on two qubits\n    // 0 - |Φ⁺⟩ = (|00⟩ + |11⟩) / sqrt(2)\n    // 1 - |Φ⁻⟩ = (|00⟩ - |11⟩) / sqrt(2)\n    // 2 - |Ψ⁺⟩ = (|01⟩ + |10⟩) / sqrt(2)\n    // 3 - |Ψ⁻⟩ = (|01⟩ - |10⟩) / sqrt(2)\n    operation StatePrep_BellState(q1 : Qubit, q2 : Qubit, state : Int) : Unit {\n        H(q1);\n        CNOT(q1, q2);\n        \n        // now we have |00⟩ + |11⟩ - modify it based on state arg\n        if state % 2 == 1 {\n            // negative phase\n            Z(q2);\n        }\n        \n        if state / 2 == 1 {\n            X(q2);\n        }\n    }\n\n    // ------------------------------------------------------\n    // Helper operation that run teleportation using the given operations to prepare the message qubit\n    // and the entangled pair, and to run sender and receiver parts of the protocol.\n    operation ComposeTeleportation(\n        bellPrepOp : ((Qubit, Qubit) => Unit), \n        getDescriptionOp : ((Qubit, Qubit) => (Bool, Bool)), \n        reconstructOp : ((Qubit, (Bool, Bool)) => Unit),\n        qAlice : Qubit, \n        qBob : Qubit, \n        qMessage : Qubit) : Unit {\n\n        bellPrepOp(qAlice, qBob);\n        let classicalBits = getDescriptionOp(qAlice, qMessage);\n        \n        // Alice sends the classical bits to Bob.\n        // Bob uses these bits to transform his part of the entangled pair into the message.\n        reconstructOp(qBob, classicalBits);\n    }\n    \n    operation SendMessage_Reference(qAlice: Qubit, qMessage: Qubit) : (Bool, Bool) {\n        CNOT(qMessage, qAlice);\n        H(qMessage);\n        return (M(qMessage) == One, M(qAlice) == One);\n    }\n\n    operation ReconstructMessage_Reference(qBob : Qubit, (b1 : Bool, b2 : Bool)) : Unit {\n        if b1 {\n            Z(qBob);\n        }\n        if b2 {\n            X(qBob);\n        }\n    }\n\n    // ------------------------------------------------------\n    // Helper operation that runs a teleportation operation (specified by teleportOp).\n    // The state to teleport is set up using an operation (specified by setupPsiOp).\n    //\n    // Specifying the state to teleport through an operation allows to get the inverse\n    // which makes testing easier.\n    operation TeleportTestHelper(\n        teleportOp : ((Qubit, Qubit, Qubit) => Unit), \n        setupPsiOp : (Qubit => Unit is Adj),\n        psiName: String) : Bool {\n        \n        use (qMessage, qAlice, qBob) = (Qubit(), Qubit(), Qubit());\n        setupPsiOp(qMessage);\n            \n        // This should modify qBob to be identical to the state\n        // of qMessage before the function call.\n        teleportOp(qAlice, qBob, qMessage);\n            \n        // Applying the inverse of the setup operation to qBob\n        // should make it Zero.\n        Adjoint setupPsiOp(qBob);\n        if not CheckZero(qBob) {\n            Message($\"Incorrect. The state {psiName} was teleported incorrectly.\");\n            setupPsiOp(qBob);\n            Message(\"The state of the qubits [qMessage, qAlice, qBob] after teleportation:\");\n            DumpMachine();\n            ResetAll([qMessage, qAlice, qBob]);\n            return false;\n        }\n        ResetAll([qMessage, qAlice, qBob]);\n        return true;\n    }\n\n    // ------------------------------------------------------\n    // Run teleportation for a number of different states.\n    // After each teleportation success is asserted.\n    // Also repeats for each state several times as\n    // code is expected to take different paths each time because\n    // measurements done by Alice are not deterministic.\n    operation TeleportTestLoop(teleportOp : ((Qubit, Qubit, Qubit) => Unit)) : Bool {\n        // Define setup operations for the message qubit\n        // on which to test teleportation: |0⟩, |1⟩, |0⟩ + |1⟩, unequal superposition.\n        let setupPsiOps = [(I, \"|0⟩\"), (X, \"|1⟩\"), (H, \"|+⟩\"), (Ry(ArcCos(0.6) * 2.0, _), \"0.6|0⟩ + 0.8|1⟩\")];\n        \n        // As part of teleportation Alice runs some measurements\n        // with nondeterministic outcome.\n        // Depending on the outcomes different paths are taken on Bob's side.\n        // We repeat each test run several times to ensure that all paths are checked.\n        let numRepetitions = 100;\n        for (psiOp, psiName) in setupPsiOps {\n            for j in 1 .. numRepetitions {\n                if not TeleportTestHelper(teleportOp, psiOp, psiName) {\n                    return false;\n                }\n            }\n        }\n        Message(\"Correct.\");\n        return true;\n    }\n\n    operation PrepareAndSendMessage_Reference(qAlice : Qubit, basis : Pauli, state : Result) : (Bool, Bool) {\n        use qMessage = Qubit();\n        if state == One {\n            X(qMessage);\n        }\n        if basis != PauliZ {\n            H(qMessage);\n        }\n        if basis == PauliY {\n            S(qMessage);\n        }\n        let classicalBits = SendMessage_Reference(qAlice, qMessage);\n        Reset(qMessage);\n        return classicalBits;\n    }\n\n    operation ReconstructAndMeasureMessage_Reference(qBob : Qubit, (b1 : Bool, b2 : Bool), basis : Pauli) : Result {\n        ReconstructMessage_Reference(qBob, (b1, b2));\n        return Measure([basis], [qBob]);\n    }\n\n    // ------------------------------------------------------\n    // Runs teleportation for each state that is to be prepared and\n    // sent by Alice. Success is asserted after each teleportation.\n    // Also repeats for each state several times; this is because\n    // code is expected to take different paths each time since\n    // measurements done by Alice are not deterministic.\n    operation TeleportPreparedStateTestLoop(\n        prepareAndSendMessageOp : ((Qubit, Pauli, Result) => (Bool, Bool)), \n        reconstructAndMeasureMessageOp : ((Qubit, (Bool, Bool), Pauli) => Result)\n        ) : Bool {\n        \n        let messages = [(PauliX, Zero, \"|+⟩\"), \n                        (PauliX, One, \"|-⟩\"), \n                        (PauliY, Zero, \"|i⟩\"), \n                        (PauliY, One, \"|-i⟩\"), \n                        (PauliZ, Zero, \"|0⟩\"), \n                        (PauliZ, One, \"|1⟩\")];\n        let numRepetitions = 100;\n        use (qAlice, qBob) = (Qubit(), Qubit());\n        for (basis, sentState, stateName) in messages {\n            for j in 1 .. numRepetitions {\n                StatePrep_BellState(qAlice, qBob, 0);\n                let classicalBits = prepareAndSendMessageOp(qAlice, basis, sentState);\n                let receivedState = reconstructAndMeasureMessageOp(qBob, classicalBits, basis);\n                if sentState != receivedState {\n                    Message($\"Received incorrect basis state when sending {stateName} in the {basis} basis.\");\n                    ResetAll([qAlice, qBob]);\n                    return false;\n                }\n                ResetAll([qAlice, qBob]);\n            }\n        }\n        Message($\"Correct\");\n        return true;\n    }\n}"
         },
         {
             "id": "teleportation__send_message__Verification.qs",
@@ -6875,6 +7104,14 @@ export default {
         {
             "id": "teleportation__standard_teleportation_protocol__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let teleport = Kata.StandardTeleport;\n        return TeleportTestLoop(teleport);\n    }\n\n}"
+        },
+        {
+            "id": "teleportation__prepare_and_send_message__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        return TeleportPreparedStateTestLoop(Kata.PrepareAndSendMessage, ReconstructAndMeasureMessage_Reference);\n    }\n\n}"
+        },
+        {
+            "id": "teleportation__reconstruct_and_measure_message__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        return TeleportPreparedStateTestLoop(PrepareAndSendMessage_Reference, Kata.ReconstructAndMeasureMessage);\n    }\n\n}"
         }
     ]
 };

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.All
 title: All function
-ms.date: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Diagonal
 title: Diagonal function
-ms.date: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/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: 06/03/2024 12:00:00 AM
+ms.date: 06/06/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays