qsharp-lang 1.12.2-dev → 1.12.3-dev

package/dist/compiler/compiler.d.ts

@@ -5,8 +5,9 @@ import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
-    getHir(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
+    getAst(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
+    getHir(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
+    getRir(program: ProgramConfig): Promise<string[]>;
     run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
     runWithPauliNoise(program: ProgramConfig, expr: string, shots: number, pauliNoise: number[], eventHandler: IQscEventTarget): Promise<void>;
     getQir(program: ProgramConfig): Promise<string>;
@@ -23,7 +24,7 @@ export type ProgramConfig = ({
     /** An array of source objects, each containing a name and contents. */
     sources: [string, string][];
     /** An array of language features to be opted in to in this compilation. */
-    languageFeatures?: string[];
+    languageFeatures: string[];
 } | {
     /** Sources from all resolved dependencies, along with their languageFeatures configuration */
     packageGraphSources: IPackageGraphSources;
@@ -37,8 +38,9 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
+    getAst(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
+    getRir(program: ProgramConfig): Promise<string[]>;
     run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
     runWithPauliNoise(program: ProgramConfig, expr: string, shots: number, pauliNoise: number[], eventHandler: IQscEventTarget): Promise<void>;
     getQir(program: ProgramConfig): Promise<string>;

package/dist/compiler/compiler.js

@@ -32,10 +32,14 @@ export class Compiler {
         return diags;
     }
     async getAst(code, languageFeatures, profile) {
-        return this.wasm.get_ast(code, languageFeatures ?? [], profile ?? "adaptive_ri");
+        return this.wasm.get_ast(code, languageFeatures, profile);
     }
     async getHir(code, languageFeatures, profile) {
-        return this.wasm.get_hir(code, languageFeatures ?? [], profile ?? "adaptive_ri");
+        return this.wasm.get_hir(code, languageFeatures, profile);
+    }
+    async getRir(program) {
+        const config = toWasmProgramConfig(program, program.profile || "adaptive_ri");
+        return this.wasm.get_rir(config);
     }
     async run(program, expr, shots, eventHandler) {
         // All results are communicated as events, but if there is a compiler error (e.g. an invalid
@@ -133,6 +137,7 @@ export const compilerProtocol = {
         checkCode: "request",
         getAst: "request",
         getHir: "request",
+        getRir: "request",
         getQir: "request",
         getEstimates: "request",
         getCircuit: "request",

package/dist/katas-content.generated.js

@@ -8721,7 +8721,7 @@ export default {
                 },
                 {
                     "type": "lesson",
-                    "id": "nonlocal_games__discussion",
+                    "id": "nonlocal_games__chsh_discussion",
                     "title": "Discussion: Probability of Victory for Quantum Strategy",
                     "items": [
                         {
@@ -8841,6 +8841,89 @@ export default {
                         ]
                     }
                 },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__ghz_create_entangled_state",
+                    "title": "Create Entangled Triple",
+                    "description": {
+                        "type": "text-content",
+                        "content": "<p>In the quantum version of the game, the players still can not communicate during the game, but they are allowed to share\nqubits from an entangled triple before the start of the game.</p>\n<p><strong>Input:</strong>\nAn array of three qubits in the $\\ket{000}$ state.</p>\n<p><strong>Goal:</strong>\nCreate the entangled state $\\ket{\\Phi} = \\frac{1}{2} \\big(\\ket{000} - \\ket{011} - \\ket{101} - \\ket{110} \\big)$ on these qubits.</p>\n<blockquote>\n<p>This state is equivalent to the three-qubit <a href=\"https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state\">GHZ state</a>\n$$\\frac{1}{\\sqrt{2}} \\big(\\ket{000} + \\ket{111} \\big)$$\nup to local unitary operations. Please refer to the follow-up GHZ Quantum Strategy discussion for details.</p>\n</blockquote>\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__ghz_create_entangled_triple__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit {\n        // Implement your solution here...\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "<ol>\n<li>Apply an X gate to the first and the second qubits to get the $\\ket{110}$ state.</li>\n<li>Appy an H gate to the first and the second qubits to get the following state:\n$$\\frac12 \\big( \\ket{000} - \\ket{010} - \\ket{100} + \\ket{110} \\big)$$</li>\n<li>Flip the sign of the last term using a controlled Z gate with the first qubit as control and the second qubit as target (or vice versa):\n$$\\frac12 \\big( \\ket{000} - \\ket{010} - \\ket{100} -{\\color{blue}\\ket{110}} \\big)$$</li>\n<li>Now we have the right signs for each term, and the first and the last terms match those of the state we're preparing, so we just need to adjust the two middle terms.\nTo do this, we can use <a href=\"https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.canon/applycontrolledonbitstring\">ControlledOnBitString</a> operation to flip the state of the last qubit if the first two qubits are in $\\ket{01}$ or in $\\ket{10}$ states, which gives us:\n$$\\frac{1}{2} \\big(\\ket{000} - {\\color{blue}\\ket{011}} - {\\color{blue}\\ket{101}} - \\ket{110} \\big)$$</li>\n</ol>\n"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__ghz_create_entangled_triple_solution",
+                                "code": "namespace Kata {\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__ghz_quantum_strategy",
+                    "title": "Quantum Strategy",
+                    "description": {
+                        "type": "text-content",
+                        "content": "<p>In this task, you should implement three functions, one for each player's quantum strategy.\nNote that they are covered by one test, so you must implement all of them to pass the test.</p>\n<p><strong>Inputs:</strong></p>\n<ol>\n<li>The input bit for one of each of the players (R, S and T respectively),</li>\n<li>That player's qubit of the entangled triple shared between the players.</li>\n</ol>\n<p><strong>Goal:</strong>\nMeasure the qubit in the Z basis if the bit is 0 (FALSE), or the X basis if the bit is 1 (TRUE), and return the result.\nThe state of the qubit after the operation does not matter.</p>\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__ghz_quantum_strategy__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "<p>In Q#, you can perform measurements in a specific basis using either the\n<a href=\"https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.intrinsic/measure\">Measure operation</a>\nor convenient shorthands for measure-and-reset-to-$\\ket{0}$ sequence of operations\n<a href=\"https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.measurement/mresetz\">MResetZ</a> and\n<a href=\"https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.measurement/mresetx\">MResetX</a>.</p>\n<p>Alternatively, you can recall that measuring the qubit in the X basis is equivalent to applying an H gate to it and measuring it in the Z basis.</p>\n"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__ghz_quantum_strategy_solution",
+                                "code": "namespace Kata {\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    // alternative implementation\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            H(qubit);\n        }    \n        return M(qubit) == One;\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__ghz_discussion",
+                    "title": "Discussion: Why the GHZ Quantum Strategy has a 100% Win Rate",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<hr />\n<p>Recall the formula for the win condition:</p>\n<ol>\n<li>The sum of the answer bits must be even if the question bits are (0,0,0)</li>\n<li>The sum of the answer bits must be odd if the question bits are (1,1,0), (1,0,1) or (0,1,1).</li>\n</ol>\n<blockquote>\n<p>As a reminder, the probability &quot;wavefunction&quot; for three qubits is given by the following vector of length 8:\n$$\\begin{bmatrix}\n\\psi_{000}\\\\\n\\psi_{001}\\\\\n\\psi_{010}\\\\\n\\psi_{011}\\\\\n\\psi_{100}\\\\\n\\psi_{101}\\\\\n\\psi_{110}\\\\\n\\psi_{111}\n\\end{bmatrix}$$\n$|\\psi_{ijk}|^2$ gives the probability of observing the corresponding basis state $\\ket{ijk}$ upon measuring the qubit trio.</p>\n</blockquote>\n<p>Now, the entangled state $\\ket{\\Phi}$ that Alice, Bob and Charlie have agreed to use is represented as</p>\n<p>$$\\begin{bmatrix}\n+1/2\\\\\n 0\\\\\n 0\\\\\n-1/2\\\\\n 0\\\\\n-1/2\\\\\n-1/2\\\\\n 0\n\\end{bmatrix}$$</p>\n<p>Let's first consider the case in which <strong>all three players got the 0 bit</strong>.</p>\n<p>When the players make their measurements, they will collectively get one of the basis states of the original state - 000, 011, 101 or 110.\nThis means they'll report back zero &quot;1&quot; bits between them (with $25\\%$ probability) or two &quot;1&quot; bits between them (with $75\\%$ probability),\neither way satisfying the win condition for the team.</p>\n<p>Now, suppose <strong>Alice gets a 0 bit and the others get 1</strong>.</p>\n<p>Alice, looking at the 0, takes a Z basis measurement as before, while Bob and Charlie each take X basis measurements.\n(An X basis measurement is also equivalent to performing a Hadamard transform followed by a standard Z basis measurement,\nas the X basis is the $\\ket{+}$ / $\\ket{-}$, and a Hadamard transform rotates the $\\ket{0}$ / $\\ket{1}$ basis to $\\ket{+}$ / $\\ket{-}$.)\nSo Bob and Charlie apply a Hadamard transform to their qubits, which corresponds to the following transformation applied to the whole system state:</p>\n<p>$$I \\otimes H \\otimes H = \\begin{bmatrix}\n1/2 &amp; 1/2 &amp; 1/2 &amp; 1/2 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\\\\n1/2 &amp; -1/2 &amp; 1/2 &amp; -1/2 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\\\\n1/2 &amp; 1/2 &amp; -1/2 &amp; -1/2 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\\\\n1/2 &amp; -1/2 &amp; -1/2 &amp; 1/2 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\\\\n0 &amp; 0 &amp; 0 &amp; 0 &amp; 1/2 &amp; 1/2 &amp; 1/2 &amp; 1/2\\\\\n0 &amp; 0 &amp; 0 &amp; 0 &amp; 1/2 &amp; -1/2 &amp; 1/2 &amp; -1/2\\\\\n0 &amp; 0 &amp; 0 &amp; 0 &amp; 1/2 &amp; 1/2 &amp; -1/2 &amp; -1/2\\\\\n0 &amp; 0 &amp; 0 &amp; 0 &amp; 1/2 &amp; -1/2 &amp; -1/2 &amp; 1/2\n\\end{bmatrix}$$</p>\n<p>When applied to the original entangled state, all the amplitude shifts to the states corresponding to $\\ket{001}$, $\\ket{010}$, $\\ket{100}$, and $\\ket{111}$.\nThe precise configuration of the new entangled state is</p>\n<p>$$\\begin{bmatrix}\n 0\\\\\n 1/2\\\\\n 1/2\\\\\n 0\\\\\n-1/2\\\\\n 0\\\\\n 0\\\\\n 1/2\n\\end{bmatrix}$$</p>\n<p>Now the players perform their measurements, and an odd number of them will see &quot;1&quot; (thanks to the new entangled state), again satisfying the win condition.\nSimilarly, if <strong>Alice and Charlie get &quot;1&quot; bits and Bob a &quot;0&quot;</strong>, Alice and Charlie will apply Hadamard transforms to their qubits to give the tensor product</p>\n<p>$$ H \\otimes I \\otimes H = \\begin{bmatrix}\n1/2 &amp; 1/2  &amp; 0   &amp; 0    &amp; 1/2  &amp; 1/2  &amp; 0    &amp; 0\\\\\n1/2 &amp; -1/2 &amp; 0   &amp; 0    &amp; 1/2  &amp; -1/2 &amp; 0    &amp; 0\\\\\n0   &amp; 0    &amp; 1/2 &amp; 1/2  &amp; 0    &amp; 0    &amp; 1/2  &amp; 1/2\\\\\n0   &amp; 0    &amp; 1/2 &amp; -1/2 &amp; 0    &amp; 0    &amp; 1/2  &amp; -1/2\\\\\n1/2 &amp; 1/2  &amp; 0   &amp; 0    &amp; -1/2 &amp; -1/2 &amp; 0    &amp; 0\\\\\n1/2 &amp; -1/2 &amp; 0   &amp; 0    &amp; -1/2 &amp; 1/2  &amp; 0    &amp; 0\\\\\n0   &amp; 0    &amp; 1/2 &amp; 1/2  &amp; 0    &amp; 0    &amp; -1/2 &amp; -1/2\\\\\n0   &amp; 0    &amp; 1/2 &amp; -1/2 &amp; 0    &amp; 0    &amp; -1/2 &amp; 1/2\n\\end{bmatrix}$$</p>\n<p>The resulting state vector before the measurement will be the same as in the previous case, except that the $\\ket{010}$ state\nends up with the negative amplitude instead of $\\ket{100}$. Again the players report back an odd number of true bits between them and the team wins.</p>\n<p>Finally if Charlie got the &quot;0&quot; bit and Alice and Bob both got &quot;1&quot;, the latter two will apply Hadamard transform for the tensor product</p>\n<p>$$ H \\otimes H \\otimes I = \\begin{bmatrix}\n1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; 1/2 &amp; 0\\\\\n0 &amp; 1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; 1/2\\\\\n1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; -1/2 &amp; 0\\\\\n0 &amp; 1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; -1/2\\\\\n1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; -1/2 &amp; 0\\\\\n0 &amp; 1/2 &amp; 0 &amp; 1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; -1/2\\\\\n1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; 1/2 &amp; 0\\\\\n0 &amp; 1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; -1/2 &amp; 0 &amp; 1/2\n\\end{bmatrix}$$</p>\n<p>Operating with this on the original entangled state yields $(\\ket{100} + \\ket{010} - \\ket{001} + \\ket{111})/2$ and\nonce more the team will report back an odd number of true bits between them and win.</p>\n"
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__ghz_e2e",
+                    "title": "Running GHZ Game End to End",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>Putting together the building blocks we've implemented into a strategy is very simple:</p>\n<ol>\n<li>Allocate three qubits and prepare our entangled state on them (using <code>CreateEntangledTriple</code>).</li>\n<li>Send one of the qubits to each of the players (this step is &quot;virtual&quot;, not directly reflected in Q# code, other than making sure that the strategies each act on their qubit only).</li>\n<li>Have the players perform their measurements on their respective qubits using corresponding elements of the <code>strategies</code> array.</li>\n<li>Reset qubits to $\\ket{0}$ before they are released.</li>\n<li>Return their measurement results.</li>\n</ol>\n<p>In the example below you can compare winning percentage of classical and quantum games.</p>\n<blockquote>\n<p>You may play with the code and check if there is a difference in results when</p>\n<ol>\n<li>The referee picks non-random bits. How can the referee minimize player's win probability?</li>\n<li>Players get the <a href=\"https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state\">GHZ state</a>.\nHow to change the quantum strategies to get $100\\%$ win rate?</li>\n</ol>\n</blockquote>\n"
+                        },
+                        {
+                            "type": "example",
+                            "id": "nonlocal_games__ghz_e2edemo",
+                            "code": "namespace Quantum.Kata.GHZGame {\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Convert;\n\n    function WinCondition (rst : Bool[], abc : Bool[]) : Bool {\n        return (rst[0] or rst[1] or rst[2]) == (abc[0] != abc[1] != abc[2]);\n    }\n\n    function AliceClassical (r : Bool) : Bool {\n        return true;\n    }\n\n    function BobClassical (s : Bool) : Bool {\n        return true;\n    }\n\n    function CharlieClassical (t : Bool) : Bool {\n        return true;\n    }\n\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation getRandomRefereeBits () : Bool[] {\n        let bits = [[false, false, false],\n                    [true, true, false],\n                    [false, true, true],\n                    [true, false, true]];\n        return bits[DrawRandomInt(0, 3)];\n    }\n\n    @EntryPoint()\n    operation GHZ_GameDemo () : Unit {\n        use (aliceQubit, bobQubit, charlieQubit) = (Qubit(), Qubit(), Qubit());\n        mutable classicalWins = 0;\n        mutable quantumWins = 0;\n        let iterations = 1000;\n        for _ in 1 .. iterations {\n            CreateEntangledTriple([aliceQubit, bobQubit, charlieQubit]);\n            let inputs = getRandomRefereeBits();\n            let coutputs = [AliceClassical(inputs[0]), BobClassical(inputs[1]), CharlieClassical(inputs[2])];\n            if WinCondition(inputs, coutputs) {\n                set classicalWins += 1;\n            }\n            let qoutputs = [AliceQuantum(inputs[0], aliceQubit), BobQuantum(inputs[1], bobQubit), CharlieQuantum(inputs[2], charlieQubit)];\n            if WinCondition(inputs, qoutputs) {\n                set quantumWins += 1;\n            }\n            ResetAll([aliceQubit, bobQubit, charlieQubit]);\n        }\n        Message($\"Percentage of classical wins is {100.0*IntAsDouble(classicalWins)/IntAsDouble(iterations)}%\");\n        Message($\"Percentage of quantum wins is {100.0*IntAsDouble(quantumWins)/IntAsDouble(iterations)}%\");\n    }\n}\n"
+                        }
+                    ]
+                },
                 {
                     "type": "lesson",
                     "id": "nonlocal_games__conclusion",
@@ -9808,6 +9891,14 @@ export default {
         {
             "id": "nonlocal_games__ghz_classical_game__Verification.qs",
             "code": "namespace Kata.Verification {\n\n    // All possible starting bits (r, s and t) that the referee can give\n    // to Alice, Bob and Charlie.\n    function RefereeBits () : Bool[][] {\n        return [[false, false, false],\n                [true, true, false],\n                [false, true, true],\n                [true, false, true]];\n    }\n\n    operation TestStrategy (input : Bool, mode : Int) : Bool {\n        return mode == 0 ? false | mode == 1 ? true | mode == 2 ? input | not input;\n    }\n\n    operation PlayClassicalGHZ_Reference (strategies : (Bool => Bool)[], inputs : Bool[]) : Bool[] {\n        let r = inputs[0];\n        let s = inputs[1];\n        let t = inputs[2];\n        let a = strategies[0](r);\n        let b = strategies[1](s);\n        let c = strategies[2](t);\n        return [a, b, c];\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let inputs = RefereeBits();\n        for rst in inputs {\n            // To test the interaction, run it on deterministic strategies (not necessarily good ones)\n            // This logic helps to detect errors in user PlayClassicalGHZ implementation like\n            // using the wrong sequence of output bits or not using the strategies at all. \n            for mode_1 in 0 .. 3 {\n                for mode_2 in 0 .. 3 {\n                    for mode_3 in 0 .. 3 {\n                        let strategies = [TestStrategy(_, mode_1), TestStrategy(_, mode_2), TestStrategy(_, mode_3)];\n                        let actual = Kata.PlayClassicalGHZ(strategies, rst);\n                        let expected = PlayClassicalGHZ_Reference(strategies, rst);\n                        if actual != expected {\n                            Message($\"Expected {expected}, got {actual} for {rst}\");\n                            return false;\n                        }\n                    }\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__ghz_create_entangled_triple__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation CreateEntangledTriple_Reference (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckOperationsEquivalenceOnZeroStateWithFeedback(Kata.CreateEntangledTriple, CreateEntangledTriple_Reference, 3)\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__ghz_quantum_strategy__Verification.qs",
+            "code": "namespace Kata.Verification {\n\n    function WinCondition_Reference (rst : Bool[], abc : Bool[]) : Bool {\n        return (rst[0] or rst[1] or rst[2]) == (abc[0] != abc[1] != abc[2]);\n    }\n\n    function RefereeBits () : Bool[][] {\n        return [[false, false, false],\n                [true, true, false],\n                [false, true, true],\n                [true, false, true]];\n    }\n\n    operation CreateEntangledTriple_Reference (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    operation PlayQuantumGHZ_Reference (strategies : ((Bool, Qubit) => Bool)[], inputs : Bool[], qubits : Qubit[]) : Bool[] {\n        let r = inputs[0];\n        let s = inputs[1];\n        let t = inputs[2];\n        let a = strategies[0](r, qubits[0]);\n        let b = strategies[1](s, qubits[1]);\n        let c = strategies[2](t, qubits[2]);\n        return [a, b, c];\n    }\n\n    @EntryPoint()\n    operation CheckSolution () : Bool {\n        use qs = Qubit[3];\n        let inputs = RefereeBits();\n        let strategies = [Kata.AliceQuantum, Kata.BobQuantum, Kata.CharlieQuantum];\n\n        let iterations = 1000;\n        mutable wins = 0;\n        for _ in 1 .. iterations {\n            for bits in inputs {\n                CreateEntangledTriple_Reference(qs);\n                let abc = PlayQuantumGHZ_Reference(strategies, bits, qs);\n                if WinCondition_Reference(bits, abc) {\n                    set wins = wins + 1;\n                }\n\t\tResetAll(qs);\n            }\n        }\n        if wins < iterations*Length(inputs) {\n            Message($\"Players' quantum strategies get {wins} wins out of {iterations*Length(inputs)} runs, which is not optimal\");\n            return false;\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         }
     ]
 };

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

@@ -8721,7 +8721,7 @@ export default {
                 },
                 {
                     "type": "lesson",
-                    "id": "nonlocal_games__discussion",
+                    "id": "nonlocal_games__chsh_discussion",
                     "title": "Discussion: Probability of Victory for Quantum Strategy",
                     "items": [
                         {
@@ -8841,6 +8841,89 @@ export default {
                         ]
                     }
                 },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__ghz_create_entangled_state",
+                    "title": "Create Entangled Triple",
+                    "description": {
+                        "type": "text-content",
+                        "content": "In the quantum version of the game, the players still can not communicate during the game, but they are allowed to share\nqubits from an entangled triple before the start of the game.\n\n**Input:**\nAn array of three qubits in the $\\ket{000}$ state.\n\n**Goal:**\nCreate the entangled state $\\ket{\\Phi} = \\frac{1}{2} \\big(\\ket{000} - \\ket{011} - \\ket{101} - \\ket{110} \\big)$ on these qubits.\n\n>This state is equivalent to the three-qubit [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state)\n>$$\\frac{1}{\\sqrt{2}} \\big(\\ket{000} + \\ket{111} \\big)$$\n>up to local unitary operations. Please refer to the follow-up GHZ Quantum Strategy discussion for details.\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__ghz_create_entangled_triple__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit {\n        // Implement your solution here...\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "\n1. Apply an X gate to the first and the second qubits to get the $\\ket{110}$ state.\n2. Appy an H gate to the first and the second qubits to get the following state:\n$$\\frac12 \\big( \\ket{000} - \\ket{010} - \\ket{100} + \\ket{110} \\big)$$\n3. Flip the sign of the last term using a controlled Z gate with the first qubit as control and the second qubit as target (or vice versa):\n$$\\frac12 \\big( \\ket{000} - \\ket{010} - \\ket{100} -{\\color{blue}\\ket{110}} \\big)$$\n4. Now we have the right signs for each term, and the first and the last terms match those of the state we're preparing, so we just need to adjust the two middle terms.\nTo do this, we can use [ControlledOnBitString](https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.canon/applycontrolledonbitstring) operation to flip the state of the last qubit if the first two qubits are in $\\ket{01}$ or in $\\ket{10}$ states, which gives us:\n$$\\frac{1}{2} \\big(\\ket{000} - {\\color{blue}\\ket{011}} - {\\color{blue}\\ket{101}} - \\ket{110} \\big)$$"
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__ghz_create_entangled_triple_solution",
+                                "code": "namespace Kata {\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "exercise",
+                    "id": "nonlocal_games__ghz_quantum_strategy",
+                    "title": "Quantum Strategy",
+                    "description": {
+                        "type": "text-content",
+                        "content": "In this task, you should implement three functions, one for each player's quantum strategy.\nNote that they are covered by one test, so you must implement all of them to pass the test.\n\n**Inputs:**\n\n1. The input bit for one of each of the players (R, S and T respectively),\n2. That player's qubit of the entangled triple shared between the players.\n\n**Goal:**\nMeasure the qubit in the Z basis if the bit is 0 (FALSE), or the X basis if the bit is 1 (TRUE), and return the result.\nThe state of the qubit after the operation does not matter.\n"
+                    },
+                    "sourceIds": [
+                        "nonlocal_games__ghz_quantum_strategy__Verification.qs",
+                        "KatasLibrary.qs"
+                    ],
+                    "placeholderCode": "namespace Kata {\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        // Implement your solution here...\n\n        return false;\n    }\n}\n",
+                    "explainedSolution": {
+                        "type": "explained-solution",
+                        "items": [
+                            {
+                                "type": "text-content",
+                                "content": "\nIn Q#, you can perform measurements in a specific basis using either the\n[Measure operation](https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.intrinsic/measure)\nor convenient shorthands for measure-and-reset-to-$\\ket{0}$ sequence of operations\n[MResetZ](https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.measurement/mresetz) and\n[MResetX](https://learn.microsoft.com/qsharp/api/qsharp-lang/microsoft.quantum.measurement/mresetx).\n\nAlternatively, you can recall that measuring the qubit in the X basis is equivalent to applying an H gate to it and measuring it in the Z basis."
+                            },
+                            {
+                                "type": "solution",
+                                "id": "nonlocal_games__ghz_quantum_strategy_solution",
+                                "code": "namespace Kata {\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    // alternative implementation\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            H(qubit);\n        }    \n        return M(qubit) == One;\n    }\n}\n"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__ghz_discussion",
+                    "title": "Discussion: Why the GHZ Quantum Strategy has a 100% Win Rate",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\n---------------------------------------------------------------\nRecall the formula for the win condition:\n1. The sum of the answer bits must be even if the question bits are (0,0,0)\n2. The sum of the answer bits must be odd if the question bits are (1,1,0), (1,0,1) or (0,1,1).\n\n> As a reminder, the probability \"wavefunction\" for three qubits is given by the following vector of length 8:\n> $$\\begin{bmatrix}\n\\psi_{000}\\\\\n\\psi_{001}\\\\\n\\psi_{010}\\\\\n\\psi_{011}\\\\\n\\psi_{100}\\\\\n\\psi_{101}\\\\\n\\psi_{110}\\\\\n\\psi_{111}\n\\end{bmatrix}$$\n> $|\\psi_{ijk}|^2$ gives the probability of observing the corresponding basis state $\\ket{ijk}$ upon measuring the qubit trio.\n\nNow, the entangled state $\\ket{\\Phi}$ that Alice, Bob and Charlie have agreed to use is represented as\n\n$$\\begin{bmatrix}\n+1/2\\\\\n 0\\\\\n 0\\\\\n-1/2\\\\\n 0\\\\\n-1/2\\\\\n-1/2\\\\\n 0\n\\end{bmatrix}$$\n\nLet's first consider the case in which **all three players got the 0 bit**.\n\nWhen the players make their measurements, they will collectively get one of the basis states of the original state - 000, 011, 101 or 110.\nThis means they'll report back zero \\\"1\\\" bits between them (with $25\\%$ probability) or two \\\"1\\\" bits between them (with $75\\%$ probability),\neither way satisfying the win condition for the team.\n\nNow, suppose **Alice gets a 0 bit and the others get 1**.\n\nAlice, looking at the 0, takes a Z basis measurement as before, while Bob and Charlie each take X basis measurements.\n(An X basis measurement is also equivalent to performing a Hadamard transform followed by a standard Z basis measurement,\nas the X basis is the $\\ket{+}$ / $\\ket{-}$, and a Hadamard transform rotates the $\\ket{0}$ / $\\ket{1}$ basis to $\\ket{+}$ / $\\ket{-}$.)\nSo Bob and Charlie apply a Hadamard transform to their qubits, which corresponds to the following transformation applied to the whole system state:\n\n$$I \\otimes H \\otimes H = \\begin{bmatrix}\n1/2 & 1/2 & 1/2 & 1/2 & 0 & 0 & 0 & 0\\\\\n1/2 & -1/2 & 1/2 & -1/2 & 0 & 0 & 0 & 0\\\\\n1/2 & 1/2 & -1/2 & -1/2 & 0 & 0 & 0 & 0\\\\\n1/2 & -1/2 & -1/2 & 1/2 & 0 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 0 & 1/2 & 1/2 & 1/2 & 1/2\\\\\n0 & 0 & 0 & 0 & 1/2 & -1/2 & 1/2 & -1/2\\\\\n0 & 0 & 0 & 0 & 1/2 & 1/2 & -1/2 & -1/2\\\\\n0 & 0 & 0 & 0 & 1/2 & -1/2 & -1/2 & 1/2\n\\end{bmatrix}$$\n\nWhen applied to the original entangled state, all the amplitude shifts to the states corresponding to $\\ket{001}$, $\\ket{010}$, $\\ket{100}$, and $\\ket{111}$.\nThe precise configuration of the new entangled state is\n\n$$\\begin{bmatrix}\n 0\\\\\n 1/2\\\\\n 1/2\\\\\n 0\\\\\n-1/2\\\\\n 0\\\\\n 0\\\\\n 1/2\n\\end{bmatrix}$$\n\nNow the players perform their measurements, and an odd number of them will see \\\"1\\\" (thanks to the new entangled state), again satisfying the win condition.\nSimilarly, if **Alice and Charlie get \\\"1\\\" bits and Bob a \\\"0\\\"**, Alice and Charlie will apply Hadamard transforms to their qubits to give the tensor product\n\n$$ H \\otimes I \\otimes H = \\begin{bmatrix}\n1/2 & 1/2  & 0   & 0    & 1/2  & 1/2  & 0    & 0\\\\\n1/2 & -1/2 & 0   & 0    & 1/2  & -1/2 & 0    & 0\\\\\n0   & 0    & 1/2 & 1/2  & 0    & 0    & 1/2  & 1/2\\\\\n0   & 0    & 1/2 & -1/2 & 0    & 0    & 1/2  & -1/2\\\\\n1/2 & 1/2  & 0   & 0    & -1/2 & -1/2 & 0    & 0\\\\\n1/2 & -1/2 & 0   & 0    & -1/2 & 1/2  & 0    & 0\\\\\n0   & 0    & 1/2 & 1/2  & 0    & 0    & -1/2 & -1/2\\\\\n0   & 0    & 1/2 & -1/2 & 0    & 0    & -1/2 & 1/2\n\\end{bmatrix}$$\n\nThe resulting state vector before the measurement will be the same as in the previous case, except that the $\\ket{010}$ state\nends up with the negative amplitude instead of $\\ket{100}$. Again the players report back an odd number of true bits between them and the team wins.\n\nFinally if Charlie got the \\\"0\\\" bit and Alice and Bob both got \\\"1\\\", the latter two will apply Hadamard transform for the tensor product\n\n$$ H \\otimes H \\otimes I = \\begin{bmatrix}\n1/2 & 0 & 1/2 & 0 & 1/2 & 0 & 1/2 & 0\\\\\n0 & 1/2 & 0 & 1/2 & 0 & 1/2 & 0 & 1/2\\\\\n1/2 & 0 & -1/2 & 0 & 1/2 & 0 & -1/2 & 0\\\\\n0 & 1/2 & 0 & -1/2 & 0 & 1/2 & 0 & -1/2\\\\\n1/2 & 0 & 1/2 & 0 & -1/2 & 0 & -1/2 & 0\\\\\n0 & 1/2 & 0 & 1/2 & 0 & -1/2 & 0 & -1/2\\\\\n1/2 & 0 & -1/2 & 0 & -1/2 & 0 & 1/2 & 0\\\\\n0 & 1/2 & 0 & -1/2 & 0 & -1/2 & 0 & 1/2\n\\end{bmatrix}$$\n\nOperating with this on the original entangled state yields $(\\ket{100} + \\ket{010} - \\ket{001} + \\ket{111})/2$ and \nonce more the team will report back an odd number of true bits between them and win."
+                        }
+                    ]
+                },
+                {
+                    "type": "lesson",
+                    "id": "nonlocal_games__ghz_e2e",
+                    "title": "Running GHZ Game End to End",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nPutting together the building blocks we've implemented into a strategy is very simple:\n\n1. Allocate three qubits and prepare our entangled state on them (using `CreateEntangledTriple`).\n2. Send one of the qubits to each of the players (this step is \\\"virtual\\\", not directly reflected in Q# code, other than making sure that the strategies each act on their qubit only).\n3. Have the players perform their measurements on their respective qubits using corresponding elements of the `strategies` array.\n4. Reset qubits to $\\ket{0}$ before they are released.\n5. Return their measurement results.\n\nIn the example below you can compare winning percentage of classical and quantum games.\n\n>You may play with the code and check if there is a difference in results when\n>1. The referee picks non-random bits. How can the referee minimize player's win probability?\n>2. Players get the [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state).\n> How to change the quantum strategies to get $100\\%$ win rate?"
+                        },
+                        {
+                            "type": "example",
+                            "id": "nonlocal_games__ghz_e2edemo",
+                            "code": "namespace Quantum.Kata.GHZGame {\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Convert;\n\n    function WinCondition (rst : Bool[], abc : Bool[]) : Bool {\n        return (rst[0] or rst[1] or rst[2]) == (abc[0] != abc[1] != abc[2]);\n    }\n\n    function AliceClassical (r : Bool) : Bool {\n        return true;\n    }\n\n    function BobClassical (s : Bool) : Bool {\n        return true;\n    }\n\n    function CharlieClassical (t : Bool) : Bool {\n        return true;\n    }\n\n    operation CreateEntangledTriple (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    operation AliceQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation BobQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation CharlieQuantum (bit : Bool, qubit : Qubit) : Bool {\n        if bit {\n            return MResetX(qubit) == One;\n        }\n        return MResetZ(qubit) == One;\n    }\n\n    operation getRandomRefereeBits () : Bool[] {\n        let bits = [[false, false, false],\n                    [true, true, false],\n                    [false, true, true],\n                    [true, false, true]];\n        return bits[DrawRandomInt(0, 3)];\n    }\n\n    @EntryPoint()\n    operation GHZ_GameDemo () : Unit {\n        use (aliceQubit, bobQubit, charlieQubit) = (Qubit(), Qubit(), Qubit());\n        mutable classicalWins = 0;\n        mutable quantumWins = 0;\n        let iterations = 1000;\n        for _ in 1 .. iterations {\n            CreateEntangledTriple([aliceQubit, bobQubit, charlieQubit]);\n            let inputs = getRandomRefereeBits();\n            let coutputs = [AliceClassical(inputs[0]), BobClassical(inputs[1]), CharlieClassical(inputs[2])];\n            if WinCondition(inputs, coutputs) {\n                set classicalWins += 1;\n            }\n            let qoutputs = [AliceQuantum(inputs[0], aliceQubit), BobQuantum(inputs[1], bobQubit), CharlieQuantum(inputs[2], charlieQubit)];\n            if WinCondition(inputs, qoutputs) {\n                set quantumWins += 1;\n            }\n            ResetAll([aliceQubit, bobQubit, charlieQubit]);\n        }\n        Message($\"Percentage of classical wins is {100.0*IntAsDouble(classicalWins)/IntAsDouble(iterations)}%\");\n        Message($\"Percentage of quantum wins is {100.0*IntAsDouble(quantumWins)/IntAsDouble(iterations)}%\");\n    }\n}\n"
+                        }
+                    ]
+                },
                 {
                     "type": "lesson",
                     "id": "nonlocal_games__conclusion",
@@ -9808,6 +9891,14 @@ export default {
         {
             "id": "nonlocal_games__ghz_classical_game__Verification.qs",
             "code": "namespace Kata.Verification {\n\n    // All possible starting bits (r, s and t) that the referee can give\n    // to Alice, Bob and Charlie.\n    function RefereeBits () : Bool[][] {\n        return [[false, false, false],\n                [true, true, false],\n                [false, true, true],\n                [true, false, true]];\n    }\n\n    operation TestStrategy (input : Bool, mode : Int) : Bool {\n        return mode == 0 ? false | mode == 1 ? true | mode == 2 ? input | not input;\n    }\n\n    operation PlayClassicalGHZ_Reference (strategies : (Bool => Bool)[], inputs : Bool[]) : Bool[] {\n        let r = inputs[0];\n        let s = inputs[1];\n        let t = inputs[2];\n        let a = strategies[0](r);\n        let b = strategies[1](s);\n        let c = strategies[2](t);\n        return [a, b, c];\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let inputs = RefereeBits();\n        for rst in inputs {\n            // To test the interaction, run it on deterministic strategies (not necessarily good ones)\n            // This logic helps to detect errors in user PlayClassicalGHZ implementation like\n            // using the wrong sequence of output bits or not using the strategies at all. \n            for mode_1 in 0 .. 3 {\n                for mode_2 in 0 .. 3 {\n                    for mode_3 in 0 .. 3 {\n                        let strategies = [TestStrategy(_, mode_1), TestStrategy(_, mode_2), TestStrategy(_, mode_3)];\n                        let actual = Kata.PlayClassicalGHZ(strategies, rst);\n                        let expected = PlayClassicalGHZ_Reference(strategies, rst);\n                        if actual != expected {\n                            Message($\"Expected {expected}, got {actual} for {rst}\");\n                            return false;\n                        }\n                    }\n                }\n            }\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__ghz_create_entangled_triple__Verification.qs",
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Katas;\n\n    operation CreateEntangledTriple_Reference (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckOperationsEquivalenceOnZeroStateWithFeedback(Kata.CreateEntangledTriple, CreateEntangledTriple_Reference, 3)\n    }\n}\n"
+        },
+        {
+            "id": "nonlocal_games__ghz_quantum_strategy__Verification.qs",
+            "code": "namespace Kata.Verification {\n\n    function WinCondition_Reference (rst : Bool[], abc : Bool[]) : Bool {\n        return (rst[0] or rst[1] or rst[2]) == (abc[0] != abc[1] != abc[2]);\n    }\n\n    function RefereeBits () : Bool[][] {\n        return [[false, false, false],\n                [true, true, false],\n                [false, true, true],\n                [true, false, true]];\n    }\n\n    operation CreateEntangledTriple_Reference (qs : Qubit[]) : Unit is Adj {\n        X(qs[0]);\n        X(qs[1]);\n        H(qs[0]);\n        H(qs[1]);\n        Controlled Z([qs[0]], qs[1]);\n        ApplyControlledOnBitString([false, true], X, [qs[0], qs[1]], qs[2]);\n        ApplyControlledOnBitString([true, false], X, [qs[0], qs[1]], qs[2]);\n    }\n\n    operation PlayQuantumGHZ_Reference (strategies : ((Bool, Qubit) => Bool)[], inputs : Bool[], qubits : Qubit[]) : Bool[] {\n        let r = inputs[0];\n        let s = inputs[1];\n        let t = inputs[2];\n        let a = strategies[0](r, qubits[0]);\n        let b = strategies[1](s, qubits[1]);\n        let c = strategies[2](t, qubits[2]);\n        return [a, b, c];\n    }\n\n    @EntryPoint()\n    operation CheckSolution () : Bool {\n        use qs = Qubit[3];\n        let inputs = RefereeBits();\n        let strategies = [Kata.AliceQuantum, Kata.BobQuantum, Kata.CharlieQuantum];\n\n        let iterations = 1000;\n        mutable wins = 0;\n        for _ in 1 .. iterations {\n            for bits in inputs {\n                CreateEntangledTriple_Reference(qs);\n                let abc = PlayQuantumGHZ_Reference(strategies, bits, qs);\n                if WinCondition_Reference(bits, abc) {\n                    set wins = wins + 1;\n                }\n\t\tResetAll(qs);\n            }\n        }\n        if wins < iterations*Length(inputs) {\n            Message($\"Players' quantum strategies get {wins} wins out of {iterations*Length(inputs)} runs, which is not optimal\");\n            return false;\n        }\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         }
     ]
 };

package/docs/Microsoft.Quantum.Core/Length.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length exported item
 description: "Q# Length exported item: This is an exported item. The actual definition is found here: [Std.Core.Length](xref:Qdk.Std.Core.Length)"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

package/docs/Microsoft.Quantum.Core/Repeated.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Repeated
 title: Repeated exported item
 description: "Q# Repeated exported item: This is an exported item. The actual definition is found here: [Std.Core.Repeated](xref:Qdk.Std.Core.Repeated)"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

package/docs/Microsoft.Quantum.Core/index.md

@@ -4,7 +4,7 @@ title: Microsoft.Quantum.Core namespace
 description: Table of contents for the Q# Microsoft.Quantum.Core namespace
 author: {AUTHOR}
 ms.author: {MS_AUTHOR}
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: landing-page
 ---
 

package/docs/Std.Arithmetic/AddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.AddLE
 title: AddLE operation
 description: "Q# AddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualL
 title: ApplyIfEqualL operation
 description: "Q# ApplyIfEqualL operation: Computes `if (c == x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is equal to the little-endian qubit register `x`"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualLE
 title: ApplyIfEqualLE operation
 description: "Q# ApplyIfEqualLE operation: Computes `if x == y { action(target) }`, that is, applies `action` to `target` if register `x` is equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfGreaterL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterL
 title: ApplyIfGreaterL operation
 description: "Q# ApplyIfGreaterL operation: Computes `if (c > x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater than the little-endian qubit register `x`"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfGreaterLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterLE
 title: ApplyIfGreaterLE operation
 description: "Q# ApplyIfGreaterLE operation: Computes `if x > y { action(target) }`, that is, applies `action` to `target` if register `x` is greater than the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualL
 title: ApplyIfGreaterOrEqualL operation
 description: "Q# ApplyIfGreaterOrEqualL operation: Computes `if (c >= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater or equal to the little-endian qubit register `x`"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualLE
 title: ApplyIfGreaterOrEqualLE operation
 description: "Q# ApplyIfGreaterOrEqualLE operation: Computes `if x >= y { action(target) }`, that is, applies `action` to `target` if register `x` is greater or equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfLessL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessL
 title: ApplyIfLessL operation
 description: "Q# ApplyIfLessL operation: Computes `if (c < x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less than the little-endian qubit register `x`"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfLessLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessLE
 title: ApplyIfLessLE operation
 description: "Q# ApplyIfLessLE operation: Computes `if x < y { action(target) }`, that is, applies `action` to `target` if register `x` is less than the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfLessOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualL
 title: ApplyIfLessOrEqualL operation
 description: "Q# ApplyIfLessOrEqualL operation: Computes `if (c <= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less or equal to the little-endian qubit register `x`"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ApplyIfLessOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualLE
 title: ApplyIfLessOrEqualLE operation
 description: "Q# ApplyIfLessOrEqualLE operation: Computes `if x <= y { action(target) }`, that is, applies `action` to `target` if register `x` is less or equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/FourierTDIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.FourierTDIncByLE
 title: FourierTDIncByLE operation
 description: "Q# FourierTDIncByLE operation: Increments a little-endian register ys by a little-endian register xs using Quantum Fourier Transform."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByI.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByI
 title: IncByI operation
 description: "Q# IncByI operation: Increments a little-endian register ys by an integer number c"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByIUsingIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByIUsingIncByLE
 title: IncByIUsingIncByLE operation
 description: "Q# IncByIUsingIncByLE operation: Increments a little-endian register ys by an Int number c using provided adder."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByL
 title: IncByL operation
 description: "Q# IncByL operation: Increments a little-endian register ys by a BigInt number c"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLE
 title: IncByLE operation
 description: "Q# IncByLE operation: Increments a little-endian register ys by a little-endian register xs"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByLEUsingAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLEUsingAddLE
 title: IncByLEUsingAddLE operation
 description: "Q# IncByLEUsingAddLE operation: Generic operation to turn two out-place adders into one in-place adder"
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/IncByLUsingIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLUsingIncByLE
 title: IncByLUsingIncByLE operation
 description: "Q# IncByLUsingIncByLE operation: Increments a little-endian register ys by a BigInt number c using provided adder."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/LookAheadDKRSAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.LookAheadDKRSAddLE
 title: LookAheadDKRSAddLE operation
 description: "Q# LookAheadDKRSAddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys using the carry-lookahead algorithm."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/MAJ.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.MAJ
 title: MAJ operation
 description: "Q# MAJ operation: This applies the in-place majority operation to 3 qubits."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/ReflectAboutInteger.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ReflectAboutInteger
 title: ReflectAboutInteger operation
 description: "Q# ReflectAboutInteger operation: Reflects a quantum register about a given classical integer."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/RippleCarryCGAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.RippleCarryCGAddLE
 title: RippleCarryCGAddLE operation
 description: "Q# RippleCarryCGAddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys using the ripple-carry algorithm."
-ms.date: 12/31/2024
+ms.date: 01/20/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__