qsharp-lang 1.12.2-dev → 1.12.4-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/dist/samples.generated.js

@@ -77,7 +77,7 @@ export default [
     {
         "title": "Shor",
         "shots": 1,
-        "code": "/// # Sample\n/// Shor's Algorithm\n///\n/// # Description\n/// Shor's algorithm is a quantum algorithm for finding the prime factors of an\n/// integer.\n///\n/// This Q# program implements Shor's algorithm.\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Random.*;\nimport Std.Math.*;\nimport Std.Arithmetic.*;\nimport Std.Arrays.*;\n\noperation Main() : (Int, Int) {\n    let n = 143; // 11*13;\n    // You can try these other examples for a lengthier computation.\n    // let n = 16837; // = 113*149\n    // let n = 22499; // = 149*151\n\n    // Use Shor's algorithm to factor a semiprime integer.\n    let (a, b) = FactorSemiprimeInteger(n);\n    Message($\"Found factorization {n} = {a} * {b}\");\n    return (a, b);\n}\n\n/// # Summary\n/// Uses Shor's algorithm to factor an input number.\n///\n/// # Input\n/// ## number\n/// A semiprime integer to be factored.\n///\n/// # Output\n/// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\noperation FactorSemiprimeInteger(number : Int) : (Int, Int) {\n    // First check the most trivial case (the provided number is even).\n    if number % 2 == 0 {\n        Message(\"An even number has been given; 2 is a factor.\");\n        return (number / 2, 2);\n    }\n    // These mutables will keep track of whether we found the factors, and\n    // if so, what they are. The default value for the factors is (1,1).\n    mutable foundFactors = false;\n    mutable factors = (1, 1);\n    mutable attempt = 1;\n    repeat {\n        Message($\"*** Factorizing {number}, attempt {attempt}.\");\n        // Try to guess a number co-prime to `number` by getting a random\n        // integer in the interval [1, number-1]\n        let generator = DrawRandomInt(1, number - 1);\n\n        // Check if the random integer is indeed co-prime.\n        // If true use Quantum algorithm for Period finding.\n        if GreatestCommonDivisorI(generator, number) == 1 {\n            Message($\"Estimating period of {generator}.\");\n\n            // Call Quantum Period finding algorithm for\n            // `generator` mod `number`.\n            let period = EstimatePeriod(generator, number);\n\n            // Set the flag and factors values if the continued\n            // fractions classical algorithm succeeds.\n            set (foundFactors, factors) = MaybeFactorsFromPeriod(number, generator, period);\n        }\n        // In this case, we guessed a divisor by accident.\n        else {\n            // Find divisor.\n            let gcd = GreatestCommonDivisorI(number, generator);\n            Message($\"We have guessed a divisor {gcd} by accident. \" + \"No quantum computation was done.\");\n\n            // Set the flag `foundFactors` to true, indicating that we\n            // succeeded in finding factors.\n            set foundFactors = true;\n            set factors = (gcd, number / gcd);\n        }\n        set attempt = attempt + 1;\n        if (attempt > 100) {\n            fail \"Failed to find factors: too many attempts!\";\n        }\n    } until foundFactors\n    fixup {\n        Message(\"The estimated period did not yield a valid factor. \" + \"Trying again.\");\n    }\n\n    // Return the factorization\n    return factors;\n}\n\n/// # Summary\n/// Tries to find the factors of `modulus` given a `period` and `generator`.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## period\n/// The estimated period (multiplicative order) of the generator mod\n/// `modulus`.\n///\n/// # Output\n/// A tuple of a flag indicating whether factors were found successfully,\n/// and a pair of integers representing the factors that were found.\n/// Note that the second output is only meaningful when the first output is\n/// `true`.\nfunction MaybeFactorsFromPeriod(\n    modulus : Int,\n    generator : Int,\n    period : Int\n) : (Bool, (Int, Int)) {\n\n    // Period finding reduces to factoring only if period is even\n    if period % 2 == 0 {\n        // Compute `generator` ^ `period/2` mod `number`.\n        let halfPower = ExpModI(generator, period / 2, modulus);\n\n        // If we are unlucky, halfPower is just -1 mod N, which is a trivial\n        // case and not useful for factoring.\n        if halfPower != modulus - 1 {\n            // When the halfPower is not -1 mod N, halfPower-1 or\n            // halfPower+1 share non-trivial divisor with `number`. Find it.\n            let factor = MaxI(\n                GreatestCommonDivisorI(halfPower - 1, modulus),\n                GreatestCommonDivisorI(halfPower + 1, modulus)\n            );\n\n            // Add a flag that we found the factors, and return only if computed\n            // non-trivial factors (not like 1:n or n:1)\n            if (factor != 1) and (factor != modulus) {\n                Message($\"Found factor={factor}\");\n                return (true, (factor, modulus / factor));\n            }\n        }\n        // Return a flag indicating we hit a trivial case and didn't get\n        // any factors.\n        Message($\"Found trivial factors.\");\n        return (false, (1, 1));\n    } else {\n        // When period is odd we have to pick another generator to estimate\n        // period of and start over.\n        Message($\"Estimated period {period} was odd, trying again.\");\n        return (false, (1, 1));\n    }\n}\n\n/// # Summary\n/// Find the period of a number from an input frequency.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## frequencyEstimate\n/// The frequency that we want to convert to a period.\n/// ## bitsPrecision\n/// Number of bits of precision with which we need to estimate s/r to\n/// recover period r using continued fractions algorithm.\n/// ## currentDivisor\n/// The divisor of the generator period found so far.\n///\n/// # Output\n/// The period as calculated from the estimated frequency via the continued\n/// fractions algorithm.\nfunction PeriodFromFrequency(\n    modulus : Int,\n    frequencyEstimate : Int,\n    bitsPrecision : Int,\n    currentDivisor : Int\n) : Int {\n    // Now we use the ContinuedFractionConvergentI function to recover s/r\n    // from dyadic fraction k/2^bitsPrecision.\n    let (numerator, period) = ContinuedFractionConvergentI(\n        (frequencyEstimate, 2^bitsPrecision),\n        modulus\n    );\n\n    // ContinuedFractionConvergentI does not guarantee the signs of the\n    // numerator and denominator. Here we make sure that both are positive\n    // using AbsI.\n    let (numeratorAbs, periodAbs) = (AbsI(numerator), AbsI(period));\n\n    // Compute and return the newly found divisor.\n    let period = (periodAbs * currentDivisor) / GreatestCommonDivisorI(currentDivisor, periodAbs);\n    Message($\"Found period={period}\");\n    return period;\n}\n\n/// # Summary\n/// Finds a multiplicative order of the generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n///\n/// # Output\n/// The period (multiplicative order) of the generator mod `modulus`\noperation EstimatePeriod(generator : Int, modulus : Int) : Int {\n    // Here we check that the inputs to the EstimatePeriod operation are\n    // valid.\n    Fact(\n        GreatestCommonDivisorI(generator, modulus) == 1,\n        \"`generator` and `modulus` must be co-prime\"\n    );\n\n    // Number of bits in the modulus with respect to which we are estimating\n    // the period.\n    let bitsize = BitSizeI(modulus);\n\n    // The EstimatePeriod operation estimates the period r by finding an\n    // approximation k/2^(bits precision) to a fraction s/r, where s is some\n    // integer. Note that if s and r have common divisors we will end up\n    // recovering a divisor of r and not r itself.\n\n    // Number of bits of precision with which we need to estimate s/r to\n    // recover period r, using continued fractions algorithm.\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Current estimate for the frequency of the form s/r.\n    let frequencyEstimate = EstimateFrequency(generator, modulus, bitsize);\n    if frequencyEstimate != 0 {\n        return PeriodFromFrequency(\n            modulus,\n            frequencyEstimate,\n            bitsPrecision,\n            1\n        );\n    } else {\n        Message(\"The estimated frequency was 0, trying again.\");\n        return 1;\n    }\n}\n\n/// # Summary\n/// Estimates the frequency of a generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision approximating s/r.\noperation EstimateFrequency(generator : Int, modulus : Int, bitsize : Int) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n    Message($\"Estimating frequency with bitsPrecision={bitsPrecision}.\");\n\n    // Allocate qubits for the superposition of eigenstates of the oracle\n    // that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of the\n    // eigenstates we are estimating the phases of.\n    // We are interpreting the register as encoding an unsigned integer in\n    // little-endian format.\n    ApplyXorInPlace(1, eigenstateRegister);\n\n    // Use phase estimation with a semiclassical Fourier transform to\n    // estimate the frequency.\n    use c = Qubit();\n    for idx in bitsPrecision - 1..-1..0 {\n        H(c);\n        Controlled ApplyOrderFindingOracle(\n            [c],\n            (generator, modulus, 1 <<< idx, eigenstateRegister)\n        );\n        R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        H(c);\n        if M(c) == One {\n            X(c); // Reset\n            set frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using ResetAll.\n    ResetAll(eigenstateRegister);\n    Message($\"Estimated frequency={frequencyEstimate}\");\n    return frequencyEstimate;\n}\n\n/// # Summary\n/// Interprets `target` as encoding unsigned little-endian integer k\n/// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n/// p is `power`, g is `generator` and N is `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## power\n/// Power of `generator` by which `target` is multiplied.\n/// ## target\n/// Register interpreted as little-endian which is multiplied by\n/// given power of the generator. The multiplication is performed modulo\n/// `modulus`.\ninternal operation ApplyOrderFindingOracle(\n    generator : Int,\n    modulus : Int,\n    power : Int,\n    target : Qubit[]\n) : Unit is Adj + Ctl {\n    // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n    // also use `ExpModI` to compute a by which x must be multiplied. Also\n    // note that we interpret target as unsigned integer in little-endian\n    // format.\n    ModularMultiplyByConstant(\n        modulus,\n        ExpModI(generator, power, modulus),\n        target\n    );\n}\n\n/// # Summary\n/// Performs modular in-place multiplication by a classical constant.\n///\n/// # Description\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(c*x) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular multiplication\n/// ## c\n/// Constant by which to multiply |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    use qs = Qubit[Length(y)];\n    for idx in IndexRange(y) {\n        let shiftedC = (c <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, shiftedC, qs)\n        );\n    }\n    for idx in IndexRange(y) {\n        SWAP(y[idx], qs[idx]);\n    }\n    let invC = InverseModI(c, modulus);\n    for idx in IndexRange(y) {\n        let shiftedC = (invC <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, modulus - shiftedC, qs)\n        );\n    }\n}\n\n/// # Summary\n/// Performs modular in-place addition of a classical constant into a\n/// quantum register.\n///\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(x+c) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular addition\n/// ## c\n/// Constant to add to |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    body (...) {\n        Controlled ModularAddConstant([], (modulus, c, y));\n    }\n    controlled (ctrls, ...) {\n        // We apply a custom strategy to control this operation instead of\n        // letting the compiler create the controlled variant for us in\n        // which the `Controlled` functor would be distributed over each\n        // operation in the body.\n        //\n        // Here we can use some scratch memory to save ensure that at most\n        // one control qubit is used for costly operations such as\n        // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n        if Length(ctrls) >= 2 {\n            use control = Qubit();\n            within {\n                Controlled X(ctrls, control);\n            } apply {\n                Controlled ModularAddConstant([control], (modulus, c, y));\n            }\n        } else {\n            use carry = Qubit();\n            Controlled IncByI(ctrls, (c, y + [carry]));\n            Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n            Controlled IncByI([carry], (modulus, y));\n            Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n        }\n    }\n}\n"
+        "code": "/// # Sample\n/// Shor's Algorithm\n///\n/// # Description\n/// Shor's algorithm is a quantum algorithm for finding the prime factors of an\n/// integer.\n///\n/// This Q# program implements Shor's algorithm.\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Random.*;\nimport Std.Math.*;\nimport Std.Arithmetic.*;\nimport Std.Arrays.*;\n\noperation Main() : (Int, Int) {\n    let n = 187; // 11*17;\n    // You can try these other examples for a lengthier computation.\n    // let n = 16837; // = 113*149\n    // let n = 22499; // = 149*151\n\n    // Use Shor's algorithm to factor a semiprime integer.\n    let (a, b) = FactorSemiprimeInteger(n);\n    Message($\"Found factorization {n} = {a} * {b}\");\n    return (a, b);\n}\n\n/// # Summary\n/// Uses Shor's algorithm to factor an input number.\n///\n/// # Input\n/// ## number\n/// A semiprime integer to be factored.\n///\n/// # Output\n/// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\noperation FactorSemiprimeInteger(number : Int) : (Int, Int) {\n    // First check the most trivial case (the provided number is even).\n    if number % 2 == 0 {\n        Message(\"An even number has been given; 2 is a factor.\");\n        return (number / 2, 2);\n    }\n    // These mutables will keep track of whether we found the factors, and\n    // if so, what they are. The default value for the factors is (1,1).\n    mutable foundFactors = false;\n    mutable factors = (1, 1);\n    mutable attempt = 1;\n    repeat {\n        Message($\"*** Factorizing {number}, attempt {attempt}.\");\n        // Try to guess a number co-prime to `number` by getting a random\n        // integer in the interval [1, number-1]\n        let generator = DrawRandomInt(1, number - 1);\n\n        // Check if the random integer is indeed co-prime.\n        // If true use Quantum algorithm for Period finding.\n        if GreatestCommonDivisorI(generator, number) == 1 {\n            Message($\"Estimating period of {generator}.\");\n\n            // Call Quantum Period finding algorithm for\n            // `generator` mod `number`.\n            let period = EstimatePeriod(generator, number);\n\n            // Set the flag and factors values if the continued\n            // fractions classical algorithm succeeds.\n            set (foundFactors, factors) = MaybeFactorsFromPeriod(number, generator, period);\n        }\n        // In this case, we guessed a divisor by accident.\n        else {\n            // Find divisor.\n            let gcd = GreatestCommonDivisorI(number, generator);\n            Message($\"We have guessed a divisor {gcd} by accident. \" + \"No quantum computation was done.\");\n\n            // Set the flag `foundFactors` to true, indicating that we\n            // succeeded in finding factors.\n            set foundFactors = true;\n            set factors = (gcd, number / gcd);\n        }\n        set attempt = attempt + 1;\n        if (attempt > 100) {\n            fail \"Failed to find factors: too many attempts!\";\n        }\n    } until foundFactors\n    fixup {\n        Message(\"The estimated period did not yield a valid factor. \" + \"Trying again.\");\n    }\n\n    // Return the factorization\n    return factors;\n}\n\n/// # Summary\n/// Tries to find the factors of `modulus` given a `period` and `generator`.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## period\n/// The estimated period (multiplicative order) of the generator mod\n/// `modulus`.\n///\n/// # Output\n/// A tuple of a flag indicating whether factors were found successfully,\n/// and a pair of integers representing the factors that were found.\n/// Note that the second output is only meaningful when the first output is\n/// `true`.\nfunction MaybeFactorsFromPeriod(\n    modulus : Int,\n    generator : Int,\n    period : Int\n) : (Bool, (Int, Int)) {\n\n    // Period finding reduces to factoring only if period is even\n    if period % 2 == 0 {\n        // Compute `generator` ^ `period/2` mod `number`.\n        let halfPower = ExpModI(generator, period / 2, modulus);\n\n        // If we are unlucky, halfPower is just -1 mod N, which is a trivial\n        // case and not useful for factoring.\n        if halfPower != modulus - 1 {\n            // When the halfPower is not -1 mod N, halfPower-1 or\n            // halfPower+1 share non-trivial divisor with `number`. Find it.\n            let factor = MaxI(\n                GreatestCommonDivisorI(halfPower - 1, modulus),\n                GreatestCommonDivisorI(halfPower + 1, modulus)\n            );\n\n            // Add a flag that we found the factors, and return only if computed\n            // non-trivial factors (not like 1:n or n:1)\n            if (factor != 1) and (factor != modulus) {\n                Message($\"Found factor={factor}\");\n                return (true, (factor, modulus / factor));\n            }\n        }\n        // Return a flag indicating we hit a trivial case and didn't get\n        // any factors.\n        Message($\"Found trivial factors.\");\n        return (false, (1, 1));\n    } else {\n        // When period is odd we have to pick another generator to estimate\n        // period of and start over.\n        Message($\"Estimated period {period} was odd, trying again.\");\n        return (false, (1, 1));\n    }\n}\n\n/// # Summary\n/// Find the period of a number from an input frequency.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## frequencyEstimate\n/// The frequency that we want to convert to a period.\n/// ## bitsPrecision\n/// Number of bits of precision with which we need to estimate s/r to\n/// recover period r using continued fractions algorithm.\n/// ## currentDivisor\n/// The divisor of the generator period found so far.\n///\n/// # Output\n/// The period as calculated from the estimated frequency via the continued\n/// fractions algorithm.\nfunction PeriodFromFrequency(\n    modulus : Int,\n    frequencyEstimate : Int,\n    bitsPrecision : Int,\n    currentDivisor : Int\n) : Int {\n    // Now we use the ContinuedFractionConvergentI function to recover s/r\n    // from dyadic fraction k/2^bitsPrecision.\n    let (numerator, period) = ContinuedFractionConvergentI(\n        (frequencyEstimate, 2^bitsPrecision),\n        modulus\n    );\n\n    // ContinuedFractionConvergentI does not guarantee the signs of the\n    // numerator and denominator. Here we make sure that both are positive\n    // using AbsI.\n    let (numeratorAbs, periodAbs) = (AbsI(numerator), AbsI(period));\n\n    // Compute and return the newly found divisor.\n    let period = (periodAbs * currentDivisor) / GreatestCommonDivisorI(currentDivisor, periodAbs);\n    Message($\"Found period={period}\");\n    return period;\n}\n\n/// # Summary\n/// Finds a multiplicative order of the generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n///\n/// # Output\n/// The period (multiplicative order) of the generator mod `modulus`\noperation EstimatePeriod(generator : Int, modulus : Int) : Int {\n    // Here we check that the inputs to the EstimatePeriod operation are\n    // valid.\n    Fact(\n        GreatestCommonDivisorI(generator, modulus) == 1,\n        \"`generator` and `modulus` must be co-prime\"\n    );\n\n    // Number of bits in the modulus with respect to which we are estimating\n    // the period.\n    let bitsize = BitSizeI(modulus);\n\n    // The EstimatePeriod operation estimates the period r by finding an\n    // approximation k/2^(bits precision) to a fraction s/r, where s is some\n    // integer. Note that if s and r have common divisors we will end up\n    // recovering a divisor of r and not r itself.\n\n    // Number of bits of precision with which we need to estimate s/r to\n    // recover period r, using continued fractions algorithm.\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Current estimate for the frequency of the form s/r.\n    let frequencyEstimate = EstimateFrequency(generator, modulus, bitsize);\n    if frequencyEstimate != 0 {\n        return PeriodFromFrequency(\n            modulus,\n            frequencyEstimate,\n            bitsPrecision,\n            1\n        );\n    } else {\n        Message(\"The estimated frequency was 0, trying again.\");\n        return 1;\n    }\n}\n\n/// # Summary\n/// Estimates the frequency of a generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision approximating s/r.\noperation EstimateFrequency(generator : Int, modulus : Int, bitsize : Int) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n    Message($\"Estimating frequency with bitsPrecision={bitsPrecision}.\");\n\n    // Allocate qubits for the superposition of eigenstates of the oracle\n    // that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of the\n    // eigenstates we are estimating the phases of.\n    // We are interpreting the register as encoding an unsigned integer in\n    // little-endian format.\n    ApplyXorInPlace(1, eigenstateRegister);\n\n    // Use phase estimation with a semiclassical Fourier transform to\n    // estimate the frequency.\n    use c = Qubit();\n    for idx in bitsPrecision - 1..-1..0 {\n        H(c);\n        Controlled ApplyOrderFindingOracle(\n            [c],\n            (generator, modulus, 1 <<< idx, eigenstateRegister)\n        );\n        R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        H(c);\n        if M(c) == One {\n            X(c); // Reset\n            set frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using ResetAll.\n    ResetAll(eigenstateRegister);\n    Message($\"Estimated frequency={frequencyEstimate}\");\n    return frequencyEstimate;\n}\n\n/// # Summary\n/// Interprets `target` as encoding unsigned little-endian integer k\n/// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n/// p is `power`, g is `generator` and N is `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## power\n/// Power of `generator` by which `target` is multiplied.\n/// ## target\n/// Register interpreted as little-endian which is multiplied by\n/// given power of the generator. The multiplication is performed modulo\n/// `modulus`.\ninternal operation ApplyOrderFindingOracle(\n    generator : Int,\n    modulus : Int,\n    power : Int,\n    target : Qubit[]\n) : Unit is Adj + Ctl {\n    // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n    // also use `ExpModI` to compute a by which x must be multiplied. Also\n    // note that we interpret target as unsigned integer in little-endian\n    // format.\n    ModularMultiplyByConstant(\n        modulus,\n        ExpModI(generator, power, modulus),\n        target\n    );\n}\n\n/// # Summary\n/// Performs modular in-place multiplication by a classical constant.\n///\n/// # Description\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(c*x) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular multiplication\n/// ## c\n/// Constant by which to multiply |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    use qs = Qubit[Length(y)];\n    for idx in IndexRange(y) {\n        let shiftedC = (c <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, shiftedC, qs)\n        );\n    }\n    for idx in IndexRange(y) {\n        SWAP(y[idx], qs[idx]);\n    }\n    let invC = InverseModI(c, modulus);\n    for idx in IndexRange(y) {\n        let shiftedC = (invC <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, modulus - shiftedC, qs)\n        );\n    }\n}\n\n/// # Summary\n/// Performs modular in-place addition of a classical constant into a\n/// quantum register.\n///\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(x+c) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular addition\n/// ## c\n/// Constant to add to |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    body (...) {\n        Controlled ModularAddConstant([], (modulus, c, y));\n    }\n    controlled (ctrls, ...) {\n        // We apply a custom strategy to control this operation instead of\n        // letting the compiler create the controlled variant for us in\n        // which the `Controlled` functor would be distributed over each\n        // operation in the body.\n        //\n        // Here we can use some scratch memory to save ensure that at most\n        // one control qubit is used for costly operations such as\n        // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n        if Length(ctrls) >= 2 {\n            use control = Qubit();\n            within {\n                Controlled X(ctrls, control);\n            } apply {\n                Controlled ModularAddConstant([control], (modulus, c, y));\n            }\n        } else {\n            use carry = Qubit();\n            Controlled IncByI(ctrls, (c, y + [carry]));\n            Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n            Controlled IncByI([carry], (modulus, y));\n            Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n        }\n    }\n}\n"
     },
     {
         "title": "Three Qubit Repetition Code",

package/dist/workers/browser.js

@@ -22,7 +22,7 @@ export function createWorker(serviceProtocol) {
         switch (data.type) {
             case "init":
                 {
-                    wasm.initSync(data.wasmModule);
+                    wasm.initSync({ module: data.wasmModule });
                     invokeService = initService(self.postMessage.bind(self), serviceProtocol, wasm, data.qscLogLevel);
                 }
                 break;

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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/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/25/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__