qsharp-lang 1.6.4-dev → 1.6.5-dev

package/dist/katas-content.generated.js

@@ -7685,6 +7685,113 @@ export default {
                 }
             ],
             "published": true
+        },
+        {
+            "id": "nonlocal_games",
+            "title": "Nonlocal Games",
+            "sections": [
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__overview",
+                    "title": "Overview",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>This kata introduces three quantum nonlocal games that display &quot;quantum pseudo-telepathy&quot; -\nthe use of quantum entanglement to eliminate the need for classical communication.\nIn this context, &quot;nonlocal&quot; means that the playing parties are separated by a great distance,\nso they cannot communicate with each other during the game.\nAnother characteristics of these games is that they are &quot;refereed&quot;, which means the players try to win against the referee.</p>\n<p><strong>This kata covers the following topics:</strong></p>\n<ul>\n<li>Clauser, Horne, Shimony, and Hold thought experiment (often abbreviated as CHSH game)</li>\n<li>Greenberger-Horne-Zeilinger game (often abbreviated as GHZ game)</li>\n<li>The Mermin-Peres Magic Square game</li>\n</ul>\n<p><strong>What you should know to start working on this kata:</strong></p>\n<ul>\n<li>Basic linear algebra</li>\n<li>Basic knowledge of quantum gates and measurements</li>\n</ul>\n"
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__chsh_game",
+                    "title": "CHSH Game",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>In <strong>CHSH Game</strong>, two players (Alice and Bob) try to win the following game:</p>\n<p>Each of them is given a bit (Alice gets X and Bob gets Y), and\nthey have to return new bits (Alice returns A and Bob returns B)\nso that X ∧ Y = A ⊕ B. The trick is, they can not communicate during the game.</p>\n<blockquote>\n<ul>\n<li>∧ is the standard bitwise AND operator.</li>\n<li>⊕ is the exclusive or, or XOR operator, so (P ⊕ Q) is true if exactly one of P and Q is true.</li>\n</ul>\n</blockquote>\n"
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__chsh_game_classical",
+                    "title": "Part I. Classical CHSH",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>To start with, let's take a look at how you would play the classical variant of this game without access to any quantum tools.</p>\n"
+                        }
+                    ]
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__chsh_classical_win_condition",
+                    "title": "Win Condition",
+                    "description": {
+                        "type": "text-content",
+                        "content": "<p><strong>Input:</strong></p>\n<ul>\n<li>Alice and Bob's starting bits (X and Y).</li>\n<li>Alice and Bob's output bits (A and B).</li>\n</ul>\n<p><strong>Output:</strong>\nTrue if Alice and Bob won the CHSH game, that is, if X ∧ Y = A ⊕ B, and false otherwise.</p>\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__chsh_classical_win_condition__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    function WinCondition (x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "<p>There are four input pairs (X, Y) possible, (0,0), (0,1), (1,0), and (1,1), each with 25% probability.\nIn order to win, Alice and Bob have to output different bits if the input is (1,1), and same bits otherwise.</p>\n<p>To check whether the win condition holds, you need to compute $x ∧ y$ and $a ⊕ b$ and to compare these values: if they are equal, Alice and Bob won. You can compute these values using <a href=\"https://learn.microsoft.com/azure/quantum/user-guide/language/expressions/logicalexpressions\">built-in operators</a>: $x ∧ y$ as <code>x and y</code> and $a ⊕ b$ as <code>a != b</code>.</p>\n"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__chsh_classical_win_condition_solution",
+                                "code": "namespace Kata {\n    function WinCondition (x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        return (x and y) == (a != b);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__chsh_classical_strategy",
+                    "title": "Alice and Bob's Classical Strategy",
+                    "description": {
+                        "type": "text-content",
+                        "content": "<p>In this task you have to implement two functions, one for Alice's classical strategy and one for Bob's.\nNote that they are covered by one test, so you have to implement both to pass the test.</p>\n<p><strong>Input:</strong>\nAlice and Bob's starting bits (X and Y).</p>\n<p><strong>Output:</strong>\nAlice and Bob's output bits (A and B) to maximize their chance of winning.</p>\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__chsh_classical_strategy__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    function AliceClassical (x : Bool) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    function BobClassical (y : Bool) : Bool {\n        // Implement your solution here...\n\n        return true;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "<p>If Alice and Bob always return TRUE, they will have a 75% win rate, since TRUE ⊕ TRUE = FALSE, and the AND operation on their input bits will be FALSE with 75% probability.\nAlternatively, Alice and Bob could agree to always return FALSE to achieve the same 75% win probability. A classical strategy cannot achieve a higher success probability.</p>\n"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__chsh_classical_strategy_solution",
+                                "code": "namespace Kata {\n    function AliceClassical (x : Bool) : Bool {\n        return false;\n    }\n\n    function BobClassical (y : Bool) : Bool {\n        return false;\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__conclusion",
+                    "title": "Conclusion",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>Congratulations! In this kata you learned how to use quantum entanglement in nonlocal quantum games to get results that are better than any classical strategy can offer.</p>\n"
+                        }
+                    ]
+                }
+            ],
+            "published": false
         }
     ],
     "globalCodeSources": [
@@ -8511,6 +8618,14 @@ export default {
         {
             "id": "qec_shor__shor_detect__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Random;\n\n    operation ShorEncode (qs : Qubit[]) : Unit is Adj + Ctl {\n        BitflipEncode(qs[0 .. 3 .. 8]);\n        ApplyToEachCA(H, qs[0 .. 3 .. 8]);\n        for i in 0 .. 2 {\n            BitflipEncode(qs[3 * i .. 3 * i + 2]);\n        }\n    }\n\n    operation BitflipEncode (qs : Qubit[]) : Unit is Adj + Ctl {\n        CNOT(qs[0], qs[1]);\n        CNOT(qs[0], qs[2]);\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for err_ind in -1 .. 8 {\n            for err in [PauliX, PauliZ, PauliY] {\n                for _ in 1 .. 10 {\n                    mutable correct = true;\n                    mutable msg = \"\";\n                    use qs = Qubit[9];\n                    let theta = DrawRandomDouble(0.0, 1.0);\n                    within {\n                        // Prepare logical state on first qubit\n                        Ry(2.0 * theta * PI(), qs[0]);\n                        // Encode the state in multiple qubits\n                        ShorEncode(qs);\n                        // Introduce the error\n                        if err_ind > -1 {\n                            if err == PauliX {\n                                X(qs[err_ind]);\n                            } elif err == PauliZ {\n                                Z(qs[err_ind]);\n                            } else {\n                                Y(qs[err_ind]);\n                            }\n                        }\n                    } apply {\n                        // Call solution to detect error\n                        let (detected_ind, detected_err) = Kata.ShorDetectError(qs);\n                        // Check that it is correct\n                        if err_ind == -1 {\n                            // No error\n                            if detected_ind != -1 {\n                                set correct = false;\n                                set msg = $\"There was no error, but the solution detected error at qubit {detected_ind}\";\n                            }\n                        } else {\n                            // There was an error\n                            if detected_err != err {\n                                set correct = false;\n                                set msg = $\"There was a {err} error, but the solution detected {detected_err} error\";\n                            } else {\n                                if err == PauliX or err == PauliY {\n                                    if detected_ind != err_ind {\n                                        set correct = false;\n                                        set msg = $\"There was a {err} error at qubit {err_ind}, but the solution detected it at qubit {detected_ind}\";\n                                    }\n                                } else {\n                                    // For PauliZ errors, cannot say for certain in which qubit of the triplet it happened, so identify triplet\n                                    if detected_ind != err_ind / 3 {\n                                        set correct = false;\n                                        set msg = $\"There was a {err} error at qubit {err_ind}, but the solution detected it at qubit triplet {detected_ind}\";\n                                    }\n                                }\n                            }\n                        }\n                    }\n                    // Check that the state was not modified by the solution\n                    if not CheckAllZero(qs) {\n                        set correct = false;\n                        set msg = \"The state of the qubits changed after the solution was applied\";\n                    }\n\n                    if not correct {\n                        Message(\"Incorrect.\");\n                        Message(msg);\n                        ResetAll(qs);\n                        return false;\n                    }\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__chsh_classical_win_condition__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n\n    function WinCondition_Reference(x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        return (x and y) == (a != b);\n    }\n\n    @EntryPoint()\n    function CheckSolution() : Bool {\n        for i in 0..1 <<< 4 - 1 {\n            let bits = IntAsBoolArray(i, 4);\n            let expected = WinCondition_Reference(bits[0], bits[1], bits[2], bits[3]);\n            let actual = Kata.WinCondition(bits[0], bits[1], bits[2], bits[3]);\n\n            if actual != expected {\n                Message($\"Win condition '{actual}' isn't as expected for X = {bits[0]}, Y = {bits[1]}, \" + \n\t\t        $\"A = {bits[2]}, B = {bits[3]}\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__chsh_classical_strategy__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Random;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        mutable wins = 0;\n        for i in 1..1000 {\n            let x = DrawRandomInt(0, 1) == 1 ? true | false;\n            let y = DrawRandomInt(0, 1) == 1 ? true | false;\n            let (a, b) = (Kata.AliceClassical(x), Kata.BobClassical(y));\n            if ((x and y) == (a != b)) {\n                set wins = wins + 1;\n            }\n        }\n        Message($\"Win rate {IntAsDouble(wins) / 1000.}\");\n        if (wins < 700) {\n            Message(\"Alice and Bob's classical strategy is not optimal\");\n            return false;\n        }\n        Message(\"Correct!\");\n        true\n    }\n\n}\n"
         }
     ]
 };

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

@@ -7685,6 +7685,113 @@ export default {
                 }
             ],
             "published": true
+        },
+        {
+            "id": "nonlocal_games",
+            "title": "Nonlocal Games",
+            "sections": [
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__overview",
+                    "title": "Overview",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nThis kata introduces three quantum nonlocal games that display \"quantum pseudo-telepathy\" -\nthe use of quantum entanglement to eliminate the need for classical communication.\nIn this context, \"nonlocal\" means that the playing parties are separated by a great distance,\nso they cannot communicate with each other during the game.\nAnother characteristics of these games is that they are \"refereed\", which means the players try to win against the referee.\n\n**This kata covers the following topics:**\n - Clauser, Horne, Shimony, and Hold thought experiment (often abbreviated as CHSH game)\n - Greenberger-Horne-Zeilinger game (often abbreviated as GHZ game)\n - The Mermin-Peres Magic Square game\n\n**What you should know to start working on this kata:**\n - Basic linear algebra\n - Basic knowledge of quantum gates and measurements"
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__chsh_game",
+                    "title": "CHSH Game",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nIn **CHSH Game**, two players (Alice and Bob) try to win the following game:\n\nEach of them is given a bit (Alice gets X and Bob gets Y), and\nthey have to return new bits (Alice returns A and Bob returns B)\nso that X ∧ Y = A ⊕ B. The trick is, they can not communicate during the game.\n\n> * ∧ is the standard bitwise AND operator.\n> * ⊕ is the exclusive or, or XOR operator, so (P ⊕ Q) is true if exactly one of P and Q is true."
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__chsh_game_classical",
+                    "title": "Part I. Classical CHSH",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nTo start with, let's take a look at how you would play the classical variant of this game without access to any quantum tools."
+                        }
+                    ]
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__chsh_classical_win_condition",
+                    "title": "Win Condition",
+                    "description": {
+                        "type": "text-content",
+                        "content": "**Input:** \n* Alice and Bob's starting bits (X and Y).\n* Alice and Bob's output bits (A and B).\n\n**Output:**\n  True if Alice and Bob won the CHSH game, that is, if X ∧ Y = A ⊕ B, and false otherwise.\n\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__chsh_classical_win_condition__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    function WinCondition (x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "\nThere are four input pairs (X, Y) possible, (0,0), (0,1), (1,0), and (1,1), each with 25% probability.\nIn order to win, Alice and Bob have to output different bits if the input is (1,1), and same bits otherwise.\n\nTo check whether the win condition holds, you need to compute $x ∧ y$ and $a ⊕ b$ and to compare these values: if they are equal, Alice and Bob won. You can compute these values using [built-in operators](https://learn.microsoft.com/azure/quantum/user-guide/language/expressions/logicalexpressions): $x ∧ y$ as `x and y` and $a ⊕ b$ as `a != b`."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__chsh_classical_win_condition_solution",
+                                "code": "namespace Kata {\n    function WinCondition (x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        return (x and y) == (a != b);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__chsh_classical_strategy",
+                    "title": "Alice and Bob's Classical Strategy",
+                    "description": {
+                        "type": "text-content",
+                        "content": "In this task you have to implement two functions, one for Alice's classical strategy and one for Bob's. \nNote that they are covered by one test, so you have to implement both to pass the test.\n\n**Input:** \nAlice and Bob's starting bits (X and Y).\n\n**Output:**\n  Alice and Bob's output bits (A and B) to maximize their chance of winning.\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__chsh_classical_strategy__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    function AliceClassical (x : Bool) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    function BobClassical (y : Bool) : Bool {\n        // Implement your solution here...\n\n        return true;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "\nIf Alice and Bob always return TRUE, they will have a 75% win rate, since TRUE ⊕ TRUE = FALSE, and the AND operation on their input bits will be FALSE with 75% probability.\nAlternatively, Alice and Bob could agree to always return FALSE to achieve the same 75% win probability. A classical strategy cannot achieve a higher success probability."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__chsh_classical_strategy_solution",
+                                "code": "namespace Kata {\n    function AliceClassical (x : Bool) : Bool {\n        return false;\n    }\n\n    function BobClassical (y : Bool) : Bool {\n        return false;\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__conclusion",
+                    "title": "Conclusion",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nCongratulations! In this kata you learned how to use quantum entanglement in nonlocal quantum games to get results that are better than any classical strategy can offer."
+                        }
+                    ]
+                }
+            ],
+            "published": false
         }
     ],
     "globalCodeSources": [
@@ -8511,6 +8618,14 @@ export default {
         {
             "id": "qec_shor__shor_detect__Verification.qs",
             "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Random;\n\n    operation ShorEncode (qs : Qubit[]) : Unit is Adj + Ctl {\n        BitflipEncode(qs[0 .. 3 .. 8]);\n        ApplyToEachCA(H, qs[0 .. 3 .. 8]);\n        for i in 0 .. 2 {\n            BitflipEncode(qs[3 * i .. 3 * i + 2]);\n        }\n    }\n\n    operation BitflipEncode (qs : Qubit[]) : Unit is Adj + Ctl {\n        CNOT(qs[0], qs[1]);\n        CNOT(qs[0], qs[2]);\n    }\n\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        for err_ind in -1 .. 8 {\n            for err in [PauliX, PauliZ, PauliY] {\n                for _ in 1 .. 10 {\n                    mutable correct = true;\n                    mutable msg = \"\";\n                    use qs = Qubit[9];\n                    let theta = DrawRandomDouble(0.0, 1.0);\n                    within {\n                        // Prepare logical state on first qubit\n                        Ry(2.0 * theta * PI(), qs[0]);\n                        // Encode the state in multiple qubits\n                        ShorEncode(qs);\n                        // Introduce the error\n                        if err_ind > -1 {\n                            if err == PauliX {\n                                X(qs[err_ind]);\n                            } elif err == PauliZ {\n                                Z(qs[err_ind]);\n                            } else {\n                                Y(qs[err_ind]);\n                            }\n                        }\n                    } apply {\n                        // Call solution to detect error\n                        let (detected_ind, detected_err) = Kata.ShorDetectError(qs);\n                        // Check that it is correct\n                        if err_ind == -1 {\n                            // No error\n                            if detected_ind != -1 {\n                                set correct = false;\n                                set msg = $\"There was no error, but the solution detected error at qubit {detected_ind}\";\n                            }\n                        } else {\n                            // There was an error\n                            if detected_err != err {\n                                set correct = false;\n                                set msg = $\"There was a {err} error, but the solution detected {detected_err} error\";\n                            } else {\n                                if err == PauliX or err == PauliY {\n                                    if detected_ind != err_ind {\n                                        set correct = false;\n                                        set msg = $\"There was a {err} error at qubit {err_ind}, but the solution detected it at qubit {detected_ind}\";\n                                    }\n                                } else {\n                                    // For PauliZ errors, cannot say for certain in which qubit of the triplet it happened, so identify triplet\n                                    if detected_ind != err_ind / 3 {\n                                        set correct = false;\n                                        set msg = $\"There was a {err} error at qubit {err_ind}, but the solution detected it at qubit triplet {detected_ind}\";\n                                    }\n                                }\n                            }\n                        }\n                    }\n                    // Check that the state was not modified by the solution\n                    if not CheckAllZero(qs) {\n                        set correct = false;\n                        set msg = \"The state of the qubits changed after the solution was applied\";\n                    }\n\n                    if not correct {\n                        Message(\"Incorrect.\");\n                        Message(msg);\n                        ResetAll(qs);\n                        return false;\n                    }\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__chsh_classical_win_condition__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n\n    function WinCondition_Reference(x : Bool, y : Bool, a : Bool, b : Bool) : Bool {\n        return (x and y) == (a != b);\n    }\n\n    @EntryPoint()\n    function CheckSolution() : Bool {\n        for i in 0..1 <<< 4 - 1 {\n            let bits = IntAsBoolArray(i, 4);\n            let expected = WinCondition_Reference(bits[0], bits[1], bits[2], bits[3]);\n            let actual = Kata.WinCondition(bits[0], bits[1], bits[2], bits[3]);\n\n            if actual != expected {\n                Message($\"Win condition '{actual}' isn't as expected for X = {bits[0]}, Y = {bits[1]}, \" + \n\t\t        $\"A = {bits[2]}, B = {bits[3]}\");\n                return false;\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__chsh_classical_strategy__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Random;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        mutable wins = 0;\n        for i in 1..1000 {\n            let x = DrawRandomInt(0, 1) == 1 ? true | false;\n            let y = DrawRandomInt(0, 1) == 1 ? true | false;\n            let (a, b) = (Kata.AliceClassical(x), Kata.BobClassical(y));\n            if ((x and y) == (a != b)) {\n                set wins = wins + 1;\n            }\n        }\n        Message($\"Win rate {IntAsDouble(wins) / 1000.}\");\n        if (wins < 700) {\n            Message(\"Alice and Bob's classical strategy is not optimal\");\n            return false;\n        }\n        Message(\"Correct!\");\n        true\n    }\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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/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: 07/12/2024 12:00:00 AM
+ms.date: 07/16/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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