qsharp-lang 1.14.2-dev → 1.14.3-dev

package/dist/katas-content.generated.js

@@ -995,7 +995,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>Complex numbers have a parameter called the phase. If a complex number $z = x + iy$ is written in polar form $z = re^{i\\theta}$, its phase is $\\theta$, where $\\theta = atan2(y, x)$.</p>\n<blockquote>\n<p><code>atan2</code> is a useful function available in most programming languages. It takes two arguments and returns an angle $\\theta$\nbetween $-\\pi$ and $\\pi$ that has $\\cos \\theta = x$ and $\\sin \\theta = y$. Unlike using $\\tan^{-1}(\\frac{y}{x})$, <code>atan2</code> computes\nthe correct quadrant for the angle, since it preserves information about the signs of both sine and cosine of the angle.</p>\n</blockquote>\n<p>The probability amplitudes $\\alpha$ and $\\beta$ are complex numbers, therefore $\\alpha$ and $\\beta$ have a phase. For example, consider a qubit in state $\\frac{1 + i}{2}\\ket{0} + \\frac{1 - i}{2}\\ket{1}$. If you do the math, you see that the phase of $\\ket{0}$ is $atan2(\\frac12, \\frac12) = \\frac{\\pi}{4}$, and the phase of $\\ket{1}$ is $atan2(\\frac12, -\\frac12) = -\\frac{\\pi}{4}$. The difference between these two phases is known as <strong>relative phase</strong>.</p>\n<p>Multiplying the state of the entire system by $e^{i\\theta}$ doesn't affect the relative phase: $\\alpha\\ket{0} + \\beta\\ket{1}$ has the same relative phase as $e^{i\\theta}\\big(\\alpha\\ket{0} + \\beta\\ket{1}\\big)$. In the second expression, $\\theta$ is known as the system's <strong>global phase</strong>.</p>\n<p>The state of a qubit (or, more generally, the state of a quantum system) is defined by its relative phase - global phase arises as a consequence of using linear algebra to represent qubits, and has no physical meaning. That is, applying a phase to the entire state of a system (multiplying the entire vector by $e^{i\\theta}$ for any real $\\theta$) doesn't actually affect the state of the system. Because of this, global phase is sometimes known as <strong>unobservable phase</strong> or <strong>hidden phase</strong>.</p>\n"
+                            "content": "<p>Complex numbers have a parameter called the phase. If a complex number $z = x + iy$ is written in polar form $z = re^{i\\theta}$, its phase is $\\theta$, where $\\theta = atan2(y, x)$.</p>\n<blockquote>\n<p><code>atan2</code> is a useful function available in most programming languages. It takes two arguments and returns an angle $\\theta$\nbetween $-\\pi$ and $\\pi$ that has $\\cos \\theta = x$ and $\\sin \\theta = y$. Unlike using $\\tan^{-1}(\\frac{y}{x})$, <code>atan2</code> computes\nthe correct quadrant for the angle, since it preserves information about the signs of both sine and cosine of the angle.</p>\n</blockquote>\n<p>The probability amplitudes $\\alpha$ and $\\beta$ are complex numbers, therefore $\\alpha$ and $\\beta$ have a phase. For example, consider a qubit in state $\\frac{1 + i}{2}\\ket{0} + \\frac{1 - i}{2}\\ket{1}$. If you do the math, you see that the phase of $\\ket{0}$ amplitude is $atan2(\\frac12, \\frac12) = \\frac{\\pi}{4}$, and the phase of $\\ket{1}$ amplitude is $atan2(-\\frac12, \\frac12) = -\\frac{\\pi}{4}$. The difference between these two phases is known as <strong>relative phase</strong>.</p>\n<p>Multiplying the state of the entire system by $e^{i\\theta}$ doesn't affect the relative phase: $\\alpha\\ket{0} + \\beta\\ket{1}$ has the same relative phase as $e^{i\\theta}\\big(\\alpha\\ket{0} + \\beta\\ket{1}\\big)$. In the second expression, $\\theta$ is known as the system's <strong>global phase</strong>.</p>\n<p>The state of a qubit (or, more generally, the state of a quantum system) is defined by its relative phase - global phase arises as a consequence of using linear algebra to represent qubits, and has no physical meaning. That is, applying a phase to the entire state of a system (multiplying the entire vector by $e^{i\\theta}$ for any real $\\theta$) doesn't actually affect the state of the system. Because of this, global phase is sometimes known as <strong>unobservable phase</strong> or <strong>hidden phase</strong>.</p>\n"
                         }
                     ]
                 },

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

@@ -995,7 +995,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nComplex numbers have a parameter called the phase. If a complex number $z = x + iy$ is written in polar form $z = re^{i\\theta}$, its phase is $\\theta$, where $\\theta = atan2(y, x)$.\n\n> `atan2` is a useful function available in most programming languages. It takes two arguments and returns an angle $\\theta$\n> between $-\\pi$ and $\\pi$ that has $\\cos \\theta = x$ and $\\sin \\theta = y$. Unlike using $\\tan^{-1}(\\frac{y}{x})$, `atan2` computes\n> the correct quadrant for the angle, since it preserves information about the signs of both sine and cosine of the angle.\n\nThe probability amplitudes $\\alpha$ and $\\beta$ are complex numbers, therefore $\\alpha$ and $\\beta$ have a phase. For example, consider a qubit in state $\\frac{1 + i}{2}\\ket{0} + \\frac{1 - i}{2}\\ket{1}$. If you do the math, you see that the phase of $\\ket{0}$ is $atan2(\\frac12, \\frac12) = \\frac{\\pi}{4}$, and the phase of $\\ket{1}$ is $atan2(\\frac12, -\\frac12) = -\\frac{\\pi}{4}$. The difference between these two phases is known as **relative phase**.\n\nMultiplying the state of the entire system by $e^{i\\theta}$ doesn't affect the relative phase: $\\alpha\\ket{0} + \\beta\\ket{1}$ has the same relative phase as $e^{i\\theta}\\big(\\alpha\\ket{0} + \\beta\\ket{1}\\big)$. In the second expression, $\\theta$ is known as the system's **global phase**.\n\nThe state of a qubit (or, more generally, the state of a quantum system) is defined by its relative phase - global phase arises as a consequence of using linear algebra to represent qubits, and has no physical meaning. That is, applying a phase to the entire state of a system (multiplying the entire vector by $e^{i\\theta}$ for any real $\\theta$) doesn't actually affect the state of the system. Because of this, global phase is sometimes known as **unobservable phase** or **hidden phase**."
+                            "content": "\nComplex numbers have a parameter called the phase. If a complex number $z = x + iy$ is written in polar form $z = re^{i\\theta}$, its phase is $\\theta$, where $\\theta = atan2(y, x)$.\n\n> `atan2` is a useful function available in most programming languages. It takes two arguments and returns an angle $\\theta$\n> between $-\\pi$ and $\\pi$ that has $\\cos \\theta = x$ and $\\sin \\theta = y$. Unlike using $\\tan^{-1}(\\frac{y}{x})$, `atan2` computes\n> the correct quadrant for the angle, since it preserves information about the signs of both sine and cosine of the angle.\n\nThe probability amplitudes $\\alpha$ and $\\beta$ are complex numbers, therefore $\\alpha$ and $\\beta$ have a phase. For example, consider a qubit in state $\\frac{1 + i}{2}\\ket{0} + \\frac{1 - i}{2}\\ket{1}$. If you do the math, you see that the phase of $\\ket{0}$ amplitude is $atan2(\\frac12, \\frac12) = \\frac{\\pi}{4}$, and the phase of $\\ket{1}$ amplitude is $atan2(-\\frac12, \\frac12) = -\\frac{\\pi}{4}$. The difference between these two phases is known as **relative phase**.\n\nMultiplying the state of the entire system by $e^{i\\theta}$ doesn't affect the relative phase: $\\alpha\\ket{0} + \\beta\\ket{1}$ has the same relative phase as $e^{i\\theta}\\big(\\alpha\\ket{0} + \\beta\\ket{1}\\big)$. In the second expression, $\\theta$ is known as the system's **global phase**.\n\nThe state of a qubit (or, more generally, the state of a quantum system) is defined by its relative phase - global phase arises as a consequence of using linear algebra to represent qubits, and has no physical meaning. That is, applying a phase to the entire state of a system (multiplying the entire vector by $e^{i\\theta}$ for any real $\\theta$) doesn't actually affect the state of the system. Because of this, global phase is sometimes known as **unobservable phase** or **hidden phase**."
                         }
                     ]
                 },

package/dist/samples.generated.js

@@ -17,12 +17,12 @@ export default [
     {
         "title": "Bell States",
         "shots": 100,
-        "code": "/// # Sample\n/// Bell States\n///\n/// # Description\n/// Bell states or EPR pairs are specific quantum states of two qubits\n/// that represent the simplest (and maximal) examples of quantum entanglement.\n///\n/// This Q# program implements the four different Bell states.\nimport Std.Diagnostics.*;\n\noperation Main() : (Result, Result)[] {\n    // This array contains a label and a preparation operation for each one\n    // of the four Bell states.\n    let bellStateTuples = [\n        (\"|Φ+〉\", PreparePhiPlus),\n        (\"|Φ-〉\", PreparePhiMinus),\n        (\"|Ψ+〉\", PreparePsiPlus),\n        (\"|Ψ-〉\", PreparePsiMinus)\n    ];\n\n    // Prepare all Bell states, show them using the `DumpMachine` operation\n    // and measure the Bell state qubits.\n    mutable measurements = [];\n    for (label, prepare) in bellStateTuples {\n        // Allocate the two qubits that will be used to create a Bell state.\n        use register = Qubit[2];\n        prepare(register);\n        Message($\"Bell state {label}:\");\n        DumpMachine();\n        set measurements += [(MResetZ(register[0]), MResetZ(register[1]))];\n    }\n    return measurements;\n}\n\n/// # Summary\n/// Prepares |Φ+⟩ = (|00⟩+|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 + |11〉)\n}\n\n/// # Summary\n/// Prepares |Φ−⟩ = (|00⟩-|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiMinus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    Z(register[0]);                 // |-0〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 - |11〉)\n}\n\n/// # Summary\n/// Prepares |Ψ+⟩ = (|01⟩+|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePsiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    X(register[1]);                 // |+1〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 + |10〉)\n}\n\n/// # Summary\n/// Prepares |Ψ−⟩ = (|01⟩-|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePsiMinus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    Z(register[0]);                 // |-0〉\n    X(register[1]);                 // |-1〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 - |10〉)\n}\n"
+        "code": "/// # Sample\n/// Bell States\n///\n/// # Description\n/// Bell states or EPR pairs are specific quantum states of two qubits\n/// that represent the simplest (and maximal) examples of quantum entanglement.\n///\n/// This Q# program implements the four different Bell states.\nimport Std.Diagnostics.*;\n\noperation Main() : (Result, Result)[] {\n    // This array contains a label and a preparation operation for each one\n    // of the four Bell states.\n    let bellStateTuples = [\n        (\"|Φ+〉\", PreparePhiPlus),\n        (\"|Φ-〉\", PreparePhiMinus),\n        (\"|Ψ+〉\", PreparePsiPlus),\n        (\"|Ψ-〉\", PreparePsiMinus)\n    ];\n\n    // Prepare all Bell states, show them using the `DumpMachine` operation\n    // and measure the Bell state qubits.\n    mutable measurements = [];\n    for (label, prepare) in bellStateTuples {\n        // Allocate the two qubits that will be used to create a Bell state.\n        use register = Qubit[2];\n        prepare(register);\n        Message($\"Bell state {label}:\");\n        DumpMachine();\n        measurements += [(MResetZ(register[0]), MResetZ(register[1]))];\n    }\n    return measurements;\n}\n\n/// # Summary\n/// Prepares |Φ+⟩ = (|00⟩+|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 + |11〉)\n}\n\n/// # Summary\n/// Prepares |Φ−⟩ = (|00⟩-|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiMinus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    Z(register[0]);                 // |-0〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 - |11〉)\n}\n\n/// # Summary\n/// Prepares |Ψ+⟩ = (|01⟩+|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePsiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    X(register[1]);                 // |+1〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 + |10〉)\n}\n\n/// # Summary\n/// Prepares |Ψ−⟩ = (|01⟩-|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePsiMinus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    Z(register[0]);                 // |-0〉\n    X(register[1]);                 // |-1〉\n    CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 - |10〉)\n}\n"
     },
     {
         "title": "Teleportation",
         "shots": 1,
-        "code": "/// # Sample\n/// Quantum Teleportation\n///\n/// # Description\n/// Quantum teleportation provides a way of moving a quantum state from one\n/// location to another without having to move physical particle(s) along with\n/// it. This is done with the help of previously shared quantum entanglement\n/// between the sending and the receiving locations, and classical\n/// communication.\n///\n/// This Q# program implements quantum teleportation.\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Measurement.*;\n\noperation Main() : Result[] {\n    // Use the `Teleport` operation to send different quantum states.\n    let stateInitializerBasisTuples = [\n        (\"|0〉\", I, PauliZ),\n        (\"|1〉\", X, PauliZ),\n        (\"|+〉\", SetToPlus, PauliX),\n        (\"|-〉\", SetToMinus, PauliX)\n    ];\n\n    mutable results = [];\n    for (state, initializer, basis) in stateInitializerBasisTuples {\n        // Allocate the message and target qubits.\n        use (message, target) = (Qubit(), Qubit());\n\n        // Initialize the message and show its state using the `DumpMachine`\n        // function.\n        initializer(message);\n        Message($\"Teleporting state {state}\");\n        DumpRegister([message]);\n\n        // Teleport the message and show the quantum state after\n        // teleportation.\n        Teleport(message, target);\n        Message($\"Received state {state}\");\n        DumpRegister([target]);\n\n        // Measure target in the corresponding basis and reset the qubits to\n        // continue teleporting more messages.\n        let result = Measure([basis], [target]);\n        set results += [result];\n        ResetAll([message, target]);\n    }\n\n    return results;\n}\n\n/// # Summary\n/// Sends the state of one qubit to a target qubit by using teleportation.\n///\n/// Notice that after calling Teleport, the state of `message` is collapsed.\n///\n/// # Input\n/// ## message\n/// A qubit whose state we wish to send.\n/// ## target\n/// A qubit initially in the |0〉 state that we want to send\n/// the state of message to.\noperation Teleport(message : Qubit, target : Qubit) : Unit {\n    // Allocate an auxiliary qubit.\n    use auxiliary = Qubit();\n\n    // Create some entanglement that we can use to send our message.\n    H(auxiliary);\n    CNOT(auxiliary, target);\n\n    // Encode the message into the entangled pair.\n    CNOT(message, auxiliary);\n    H(message);\n\n    // Measure the qubits to extract the classical data we need to decode\n    // the message by applying the corrections on the target qubit\n    // accordingly.\n    if M(auxiliary) == One {\n        X(target);\n    }\n\n    if M(message) == One {\n        Z(target);\n    }\n\n    // Reset auxiliary qubit before releasing.\n    Reset(auxiliary);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |+⟩.\noperation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n    H(q);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |−⟩.\noperation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n    X(q);\n    H(q);\n}\n"
+        "code": "/// # Sample\n/// Quantum Teleportation\n///\n/// # Description\n/// Quantum teleportation provides a way of moving a quantum state from one\n/// location to another without having to move physical particle(s) along with\n/// it. This is done with the help of previously shared quantum entanglement\n/// between the sending and the receiving locations, and classical\n/// communication.\n///\n/// This Q# program implements quantum teleportation.\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Measurement.*;\n\noperation Main() : Result[] {\n    // Use the `Teleport` operation to send different quantum states.\n    let stateInitializerBasisTuples = [\n        (\"|0〉\", I, PauliZ),\n        (\"|1〉\", X, PauliZ),\n        (\"|+〉\", SetToPlus, PauliX),\n        (\"|-〉\", SetToMinus, PauliX)\n    ];\n\n    mutable results = [];\n    for (state, initializer, basis) in stateInitializerBasisTuples {\n        // Allocate the message and target qubits.\n        use (message, target) = (Qubit(), Qubit());\n\n        // Initialize the message and show its state using the `DumpMachine`\n        // function.\n        initializer(message);\n        Message($\"Teleporting state {state}\");\n        DumpRegister([message]);\n\n        // Teleport the message and show the quantum state after\n        // teleportation.\n        Teleport(message, target);\n        Message($\"Received state {state}\");\n        DumpRegister([target]);\n\n        // Measure target in the corresponding basis and reset the qubits to\n        // continue teleporting more messages.\n        let result = Measure([basis], [target]);\n        results += [result];\n        ResetAll([message, target]);\n    }\n\n    return results;\n}\n\n/// # Summary\n/// Sends the state of one qubit to a target qubit by using teleportation.\n///\n/// Notice that after calling Teleport, the state of `message` is collapsed.\n///\n/// # Input\n/// ## message\n/// A qubit whose state we wish to send.\n/// ## target\n/// A qubit initially in the |0〉 state that we want to send\n/// the state of message to.\noperation Teleport(message : Qubit, target : Qubit) : Unit {\n    // Allocate an auxiliary qubit.\n    use auxiliary = Qubit();\n\n    // Create some entanglement that we can use to send our message.\n    H(auxiliary);\n    CNOT(auxiliary, target);\n\n    // Encode the message into the entangled pair.\n    CNOT(message, auxiliary);\n    H(message);\n\n    // Measure the qubits to extract the classical data we need to decode\n    // the message by applying the corrections on the target qubit\n    // accordingly.\n    if M(auxiliary) == One {\n        X(target);\n    }\n\n    if M(message) == One {\n        Z(target);\n    }\n\n    // Reset auxiliary qubit before releasing.\n    Reset(auxiliary);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |+⟩.\noperation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n    H(q);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |−⟩.\noperation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n    X(q);\n    H(q);\n}\n"
     },
     {
         "title": "Random Bit",
@@ -37,7 +37,7 @@ export default [
     {
         "title": "Random Number Generator (Advanced)",
         "shots": 1000,
-        "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nimport Std.Convert.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\n\noperation Main() : Int {\n    let max = 100;\n    Message($\"Sampling a random number between 0 and {max}:\");\n\n    // Generate random number in the 0..max range.\n    return GenerateRandomNumberInRange(max);\n}\n\n/// # Summary\n/// Generates a random number between 0 and `max`.\noperation GenerateRandomNumberInRange(max : Int) : Int {\n    // Determine the number of bits needed to represent `max` and store it\n    // in the `nBits` variable. Then generate `nBits` random bits which will\n    // represent the generated random number.\n    mutable bits = [];\n    let nBits = BitSizeI(max);\n    for idxBit in 1..nBits {\n        set bits += [GenerateRandomBit()];\n    }\n    let sample = ResultArrayAsInt(bits);\n\n    // Return random number if it is within the requested range.\n    // Generate it again if it is outside the range.\n    return sample > max ? GenerateRandomNumberInRange(max) | sample;\n}\n\n/// # Summary\n/// Generates a random bit.\noperation GenerateRandomBit() : Result {\n    // Allocate a qubit.\n    use q = Qubit();\n\n    // Set the qubit into superposition of 0 and 1 using the Hadamard\n    // operation `H`.\n    H(q);\n\n    // At this point the qubit `q` has 50% chance of being measured in the\n    // |0〉 state and 50% chance of being measured in the |1〉 state.\n    // Measure the qubit value using the `M` operation, and store the\n    // measurement value in the `result` variable.\n    let result = M(q);\n\n    // Reset qubit to the |0〉 state.\n    // Qubits must be in the |0〉 state by the time they are released.\n    Reset(q);\n\n    // Return the result of the measurement.\n    return result;\n\n    // Note that Qubit `q` is automatically released at the end of the block.\n}\n"
+        "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nimport Std.Convert.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\n\noperation Main() : Int {\n    let max = 100;\n    Message($\"Sampling a random number between 0 and {max}:\");\n\n    // Generate random number in the 0..max range.\n    return GenerateRandomNumberInRange(max);\n}\n\n/// # Summary\n/// Generates a random number between 0 and `max`.\noperation GenerateRandomNumberInRange(max : Int) : Int {\n    // Determine the number of bits needed to represent `max` and store it\n    // in the `nBits` variable. Then generate `nBits` random bits which will\n    // represent the generated random number.\n    mutable bits = [];\n    let nBits = BitSizeI(max);\n    for idxBit in 1..nBits {\n        bits += [GenerateRandomBit()];\n    }\n    let sample = ResultArrayAsInt(bits);\n\n    // Return random number if it is within the requested range.\n    // Generate it again if it is outside the range.\n    return sample > max ? GenerateRandomNumberInRange(max) | sample;\n}\n\n/// # Summary\n/// Generates a random bit.\noperation GenerateRandomBit() : Result {\n    // Allocate a qubit.\n    use q = Qubit();\n\n    // Set the qubit into superposition of 0 and 1 using the Hadamard\n    // operation `H`.\n    H(q);\n\n    // At this point the qubit `q` has 50% chance of being measured in the\n    // |0〉 state and 50% chance of being measured in the |1〉 state.\n    // Measure the qubit value using the `M` operation, and store the\n    // measurement value in the `result` variable.\n    let result = M(q);\n\n    // Reset qubit to the |0〉 state.\n    // Qubits must be in the |0〉 state by the time they are released.\n    Reset(q);\n\n    // Return the result of the measurement.\n    return result;\n\n    // Note that Qubit `q` is automatically released at the end of the block.\n}\n"
     },
     {
         "title": "Deutsch-Jozsa",
@@ -47,7 +47,7 @@ export default [
     {
         "title": "Deutsch-Jozsa (Advanced)",
         "shots": 1,
-        "code": "/// # Sample\n/// Deutsch–Jozsa Algorithm\n///\n/// # Description\n/// Deutsch–Jozsa is a quantum algorithm that determines whether a given Boolean\n/// function 𝑓 is constant (0 on all inputs or 1 on all inputs) or balanced\n/// (1 for exactly half of the input domain and 0 for the other half).\n///\n/// This Q# program implements the Deutsch–Jozsa algorithm.\nimport Std.Diagnostics.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\n\noperation Main() : (String, Bool)[] {\n    // A Boolean function is a function that maps bitstrings to a bit:\n    //     𝑓 : {0, 1}^n → {0, 1}.\n\n    // We say that 𝑓 is constant if 𝑓(𝑥⃗) = 𝑓(𝑦⃗) for all bitstrings 𝑥⃗ and\n    // 𝑦⃗, and that 𝑓 is balanced if 𝑓 evaluates to true for exactly half of\n    // its inputs.\n\n    // If we are given a function 𝑓 as a quantum operation 𝑈 |𝑥〉|𝑦〉 =\n    // |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, and are promised that 𝑓 is either constant or is\n    // balanced, then the Deutsch–Jozsa algorithm decides between these\n    // cases with a single application of 𝑈.\n\n    // Here, we demonstrate the use of the Deutsch-Jozsa algorithm by\n    // determining the type (constant or balanced) of various functions.\n    let nameFunctionTypeTuples = [\n        (\"SimpleConstantBoolF\", SimpleConstantBoolF, true),\n        (\"SimpleBalancedBoolF\", SimpleBalancedBoolF, false),\n        (\"ConstantBoolF\", ConstantBoolF, true),\n        (\"BalancedBoolF\", BalancedBoolF, false)\n    ];\n\n    mutable results = [];\n    for (name, fn, shouldBeConstant) in nameFunctionTypeTuples {\n        let isConstant = DeutschJozsa(fn, 5);\n        if (isConstant != shouldBeConstant) {\n            let shouldBeConstantStr = shouldBeConstant ? \"constant\" | \"balanced\";\n            fail $\"{name} should be detected as {shouldBeConstantStr}\";\n        }\n\n        let isConstantStr = isConstant ? \"constant\" | \"balanced\";\n        Message($\"{name} is {isConstantStr}\");\n        set results += [(name, isConstant)];\n    }\n\n    return results;\n}\n\n/// # Summary\n/// This operation implements the DeutschJozsa algorithm.\n/// It returns the Boolean value `true` if the function is constant and\n/// `false` if it is not.\n/// It is assumed that the function is either constant or balanced.\n///\n/// # Input\n/// ## Uf\n/// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, where 𝑓 is a\n/// Boolean function, 𝑥 is an 𝑛 bit register and 𝑦 is a single qubit.\n/// ## n\n/// The number of bits in the input register |𝑥〉.\n///\n/// # Output\n/// A boolean value `true` that indicates that the function is constant and\n/// `false` that indicates that the function is balanced.\n///\n/// # See Also\n/// - For details see Section 1.4.3 of Nielsen & Chuang.\n///\n/// # References\n/// - [ *Michael A. Nielsen , Isaac L. Chuang*,\n///     Quantum Computation and Quantum Information ]\n/// (http://doi.org/10.1017/CBO9780511976667)\noperation DeutschJozsa(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Bool {\n    // We allocate n + 1 clean qubits. Note that the function `Uf` is defined\n    // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n    use queryRegister = Qubit[n];\n    use target = Qubit();\n\n    // The last qubit needs to be flipped so that the function will actually\n    // be computed into the phase when Uf is applied.\n    X(target);\n\n    // Now, a Hadamard transform is applied to each of the qubits.\n    H(target);\n    // We use a within-apply block to ensure that the Hadamard transform is\n    // correctly inverted on the |𝑥〉 register.\n    within {\n        for q in queryRegister {\n            H(q);\n        }\n    } apply {\n        // We apply Uf to the n+1 qubits, computing |𝑥, 𝑦〉 ↦ |𝑥, 𝑦 ⊕ 𝑓(𝑥)〉.\n        Uf(queryRegister, target);\n    }\n\n    // The following for-loop measures all qubits and resets them to the |0〉\n    // state so that they can be safely deallocated at the end of the block.\n    // The loop also sets `result` to `true` if all measurement results are\n    // `Zero`, i.e. if the function is a constant function, and sets\n    // `result` to `false` if not, which according to the assumption on 𝑓\n    // means that it must be balanced.\n    mutable result = true;\n    for q in queryRegister {\n        if MResetZ(q) == One {\n            set result = false;\n        }\n    }\n\n    // Finally, the last qubit, which held the 𝑦-register, is reset.\n    Reset(target);\n    return result;\n}\n\n// Simple constant Boolean function\noperation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n    X(target);\n}\n\n// Simple balanced Boolean function\noperation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n    CX(args[0], target);\n}\n\n// A more complex constant Boolean function.\n// It applies X to every input basis vector.\noperation ConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n    for i in 0..(2^Length(args)) - 1 {\n        ApplyControlledOnInt(i, X, args, target);\n    }\n}\n\n// A more complex balanced Boolean function.\n// It applies X to half of the input basis vectors.\noperation BalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n    for i in 0..2..(2^Length(args)) - 1 {\n        ApplyControlledOnInt(i, X, args, target);\n    }\n}\n"
+        "code": "/// # Sample\n/// Deutsch–Jozsa Algorithm\n///\n/// # Description\n/// Deutsch–Jozsa is a quantum algorithm that determines whether a given Boolean\n/// function 𝑓 is constant (0 on all inputs or 1 on all inputs) or balanced\n/// (1 for exactly half of the input domain and 0 for the other half).\n///\n/// This Q# program implements the Deutsch–Jozsa algorithm.\nimport Std.Diagnostics.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\n\noperation Main() : (String, Bool)[] {\n    // A Boolean function is a function that maps bitstrings to a bit:\n    //     𝑓 : {0, 1}^n → {0, 1}.\n\n    // We say that 𝑓 is constant if 𝑓(𝑥⃗) = 𝑓(𝑦⃗) for all bitstrings 𝑥⃗ and\n    // 𝑦⃗, and that 𝑓 is balanced if 𝑓 evaluates to true for exactly half of\n    // its inputs.\n\n    // If we are given a function 𝑓 as a quantum operation 𝑈 |𝑥〉|𝑦〉 =\n    // |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, and are promised that 𝑓 is either constant or is\n    // balanced, then the Deutsch–Jozsa algorithm decides between these\n    // cases with a single application of 𝑈.\n\n    // Here, we demonstrate the use of the Deutsch-Jozsa algorithm by\n    // determining the type (constant or balanced) of various functions.\n    let nameFunctionTypeTuples = [\n        (\"SimpleConstantBoolF\", SimpleConstantBoolF, true),\n        (\"SimpleBalancedBoolF\", SimpleBalancedBoolF, false),\n        (\"ConstantBoolF\", ConstantBoolF, true),\n        (\"BalancedBoolF\", BalancedBoolF, false)\n    ];\n\n    mutable results = [];\n    for (name, fn, shouldBeConstant) in nameFunctionTypeTuples {\n        let isConstant = DeutschJozsa(fn, 5);\n        if (isConstant != shouldBeConstant) {\n            let shouldBeConstantStr = shouldBeConstant ? \"constant\" | \"balanced\";\n            fail $\"{name} should be detected as {shouldBeConstantStr}\";\n        }\n\n        let isConstantStr = isConstant ? \"constant\" | \"balanced\";\n        Message($\"{name} is {isConstantStr}\");\n        results += [(name, isConstant)];\n    }\n\n    return results;\n}\n\n/// # Summary\n/// This operation implements the DeutschJozsa algorithm.\n/// It returns the Boolean value `true` if the function is constant and\n/// `false` if it is not.\n/// It is assumed that the function is either constant or balanced.\n///\n/// # Input\n/// ## Uf\n/// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, where 𝑓 is a\n/// Boolean function, 𝑥 is an 𝑛 bit register and 𝑦 is a single qubit.\n/// ## n\n/// The number of bits in the input register |𝑥〉.\n///\n/// # Output\n/// A boolean value `true` that indicates that the function is constant and\n/// `false` that indicates that the function is balanced.\n///\n/// # See Also\n/// - For details see Section 1.4.3 of Nielsen & Chuang.\n///\n/// # References\n/// - [ *Michael A. Nielsen , Isaac L. Chuang*,\n///     Quantum Computation and Quantum Information ]\n/// (http://doi.org/10.1017/CBO9780511976667)\noperation DeutschJozsa(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Bool {\n    // We allocate n + 1 clean qubits. Note that the function `Uf` is defined\n    // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n    use queryRegister = Qubit[n];\n    use target = Qubit();\n\n    // The last qubit needs to be flipped so that the function will actually\n    // be computed into the phase when Uf is applied.\n    X(target);\n\n    // Now, a Hadamard transform is applied to each of the qubits.\n    H(target);\n    // We use a within-apply block to ensure that the Hadamard transform is\n    // correctly inverted on the |𝑥〉 register.\n    within {\n        for q in queryRegister {\n            H(q);\n        }\n    } apply {\n        // We apply Uf to the n+1 qubits, computing |𝑥, 𝑦〉 ↦ |𝑥, 𝑦 ⊕ 𝑓(𝑥)〉.\n        Uf(queryRegister, target);\n    }\n\n    // The following for-loop measures all qubits and resets them to the |0〉\n    // state so that they can be safely deallocated at the end of the block.\n    // The loop also sets `result` to `true` if all measurement results are\n    // `Zero`, i.e. if the function is a constant function, and sets\n    // `result` to `false` if not, which according to the assumption on 𝑓\n    // means that it must be balanced.\n    mutable result = true;\n    for q in queryRegister {\n        if MResetZ(q) == One {\n            result = false;\n        }\n    }\n\n    // Finally, the last qubit, which held the 𝑦-register, is reset.\n    Reset(target);\n    return result;\n}\n\n// Simple constant Boolean function\noperation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n    X(target);\n}\n\n// Simple balanced Boolean function\noperation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n    CX(args[0], target);\n}\n\n// A more complex constant Boolean function.\n// It applies X to every input basis vector.\noperation ConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n    for i in 0..(2^Length(args)) - 1 {\n        ApplyControlledOnInt(i, X, args, target);\n    }\n}\n\n// A more complex balanced Boolean function.\n// It applies X to half of the input basis vectors.\noperation BalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n    for i in 0..2..(2^Length(args)) - 1 {\n        ApplyControlledOnInt(i, X, args, target);\n    }\n}\n"
     },
     {
         "title": "Bernstein-Vazirani",
@@ -57,7 +57,7 @@ export default [
     {
         "title": "Bernstein-Vazirani (Advanced)",
         "shots": 1,
-        "code": "/// # Sample\n/// Bernstein-Vazirani Algorithm\n///\n/// # Description\n/// The Bernstein-Vazirani algorithm determines the value of a bit string\n/// encoded in a function.\n///\n/// This Q# program implements the Bernstein-Vazirani algorithm.\nimport Std.Arrays.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\n\noperation Main() : Int[] {\n    // Consider a function 𝑓(𝑥⃗) on bitstrings 𝑥⃗ = (𝑥₀, …, 𝑥ₙ₋₁) of the form\n    //     𝑓(𝑥⃗) ≔ Σᵢ 𝑥ᵢ 𝑟ᵢ\n    // where 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁) is an unknown bitstring that determines the\n    // parity of 𝑓.\n\n    // The Bernstein–Vazirani algorithm allows determining 𝑟 given a\n    // quantum operation that implements\n    //     |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n\n    // The entry point function of this program, `Main`, shows how to use\n    // the `BernsteinVazirani` operation to determine the value of various\n    // integers whose bits describe 𝑟.\n    let nQubits = 10;\n\n    // Use the Bernstein–Vazirani algorithm to determine the bit strings\n    // that various integers represent.\n    let integers = [127, 238, 512];\n    mutable decodedIntegers = [];\n    for integer in integers {\n        // Create an operation that encodes a bit string represented by an\n        // integer as a parity operation.\n        let parityOperation = EncodeIntegerAsParityOperation(integer);\n\n        // Use the parity operation as input to the Bernstein-Vazirani\n        // algorithm to determine the bit string.\n        let decodedBitString = BernsteinVazirani(parityOperation, nQubits);\n        let decodedInteger = ResultArrayAsInt(decodedBitString);\n        Fact(\n            decodedInteger == integer,\n            $\"Decoded integer {decodedInteger}, but expected {integer}.\"\n        );\n\n        Message($\"Successfully decoded bit string as int: {decodedInteger}\");\n        set decodedIntegers += [decodedInteger];\n    }\n\n    return decodedIntegers;\n}\n\n/// # Summary\n/// This operation implements the Bernstein-Vazirani quantum algorithm.\n/// This algorithm computes for a given Boolean function that is promised to\n/// be a parity 𝑓(𝑥₀, …, 𝑥ₙ₋₁) = Σᵢ 𝑟ᵢ 𝑥ᵢ a result in the form of a bit\n/// vector (𝑟₀, …, 𝑟ₙ₋₁) corresponding to the parity function.\n/// Note that it is promised that the function is actually a parity\n/// function.\n///\n/// # Input\n/// ## Uf\n/// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉,\n/// where 𝑓 is a Boolean function that implements a parity Σᵢ 𝑟ᵢ 𝑥ᵢ.\n/// ## n\n/// The number of bits in the input register |𝑥〉.\n///\n/// # Output\n/// An array of type `Result[]` that contains the parity 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁).\n///\n/// # See Also\n/// - For details see Section 1.4.3 of Nielsen & Chuang.\n///\n/// # References\n/// - [ *Ethan Bernstein and Umesh Vazirani*,\n///     SIAM J. Comput., 26(5), 1411–1473, 1997 ]\n///   (https://doi.org/10.1137/S0097539796300921)\noperation BernsteinVazirani(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n    // We allocate n + 1 clean qubits. Note that the function Uf is defined\n    // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n    use queryRegister = Qubit[n];\n    use target = Qubit();\n\n    // The last qubit needs to be flipped so that the function will actually\n    // be computed into the phase when Uf is applied.\n    X(target);\n\n    within {\n        // Now, a Hadamard transform is applied to each of the qubits. As\n        // the last step before the measurement, a Hadamard transform is\n        // applied to all qubits except last one. We could apply the\n        // transform to the last qubit also, but this would not affect the\n        // final outcome.\n        // We use a within-apply block to ensure that the Hadamard transform\n        // is correctly inverted.\n        ApplyToEachA(H, queryRegister);\n    } apply {\n        H(target);\n        // We now apply Uf to the n+1 qubits, computing\n        // |x, y〉 ↦ |x, y ⊕ f(x)〉.\n        Uf(queryRegister, target);\n    }\n\n    // Measure all qubits and reset them to the |0〉 state so that they can\n    // be safely deallocated at the end of the block.\n    let resultArray = MResetEachZ(queryRegister);\n\n    // Finally, the last qubit, which held the y-register, is reset.\n    Reset(target);\n\n    // The result is already contained in resultArray so no further\n    // post-processing is necessary.\n    return resultArray;\n}\n\n/// # Summary\n/// Given an integer that can be represented as a bit string\n/// 𝑟⃗ = (r₀, …, rₙ₋₁), this operation applies a unitary 𝑈 that acts on 𝑛 + 1\n/// qubits as:\n///     𝑈 |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉\n/// where 𝑓(𝑥) = Σᵢ 𝑥ᵢ 𝑟ᵢ mod 2.\n///\n/// # Input\n/// ## bitStringAsInt\n/// An integer that can be represented as a bit string 𝑟⃗ used to define the\n/// function 𝑓.\n/// ## xRegister\n/// Represents the |𝑥〉 register that 𝑈 acts on.\n/// ## yQubit\n/// Represents the |𝑦〉 qubit that 𝑈 acts on.\noperation ApplyParityOperation(\n    bitStringAsInt : Int,\n    xRegister : Qubit[],\n    yQubit : Qubit\n) : Unit {\n    // `xRegister` muts have enough qubits to represent the integer.\n    let requiredBits = BitSizeI(bitStringAsInt);\n    let availableQubits = Length(xRegister);\n    Fact(\n        availableQubits >= requiredBits,\n        $\"Integer value {bitStringAsInt} requires {requiredBits} bits to be represented but the quantum register only has {availableQubits} qubits\"\n    );\n\n    // Apply the quantum operations that encode the bit string.\n    for index in IndexRange(xRegister) {\n        if ((bitStringAsInt &&& 2^index) != 0) {\n            CNOT(xRegister[index], yQubit);\n        }\n    }\n}\n\n/// # Summary\n/// Returns black-box operations (Qubit[], Qubit) => () of the form\n/// U_f |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n/// We define 𝑓 by providing the bit string 𝑟⃗ as an integer.\nfunction EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n    return ApplyParityOperation(bitStringAsInt, _, _);\n}\n"
+        "code": "/// # Sample\n/// Bernstein-Vazirani Algorithm\n///\n/// # Description\n/// The Bernstein-Vazirani algorithm determines the value of a bit string\n/// encoded in a function.\n///\n/// This Q# program implements the Bernstein-Vazirani algorithm.\nimport Std.Arrays.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\n\noperation Main() : Int[] {\n    // Consider a function 𝑓(𝑥⃗) on bitstrings 𝑥⃗ = (𝑥₀, …, 𝑥ₙ₋₁) of the form\n    //     𝑓(𝑥⃗) ≔ Σᵢ 𝑥ᵢ 𝑟ᵢ\n    // where 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁) is an unknown bitstring that determines the\n    // parity of 𝑓.\n\n    // The Bernstein–Vazirani algorithm allows determining 𝑟 given a\n    // quantum operation that implements\n    //     |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n\n    // The entry point function of this program, `Main`, shows how to use\n    // the `BernsteinVazirani` operation to determine the value of various\n    // integers whose bits describe 𝑟.\n    let nQubits = 10;\n\n    // Use the Bernstein–Vazirani algorithm to determine the bit strings\n    // that various integers represent.\n    let integers = [127, 238, 512];\n    mutable decodedIntegers = [];\n    for integer in integers {\n        // Create an operation that encodes a bit string represented by an\n        // integer as a parity operation.\n        let parityOperation = EncodeIntegerAsParityOperation(integer);\n\n        // Use the parity operation as input to the Bernstein-Vazirani\n        // algorithm to determine the bit string.\n        let decodedBitString = BernsteinVazirani(parityOperation, nQubits);\n        let decodedInteger = ResultArrayAsInt(decodedBitString);\n        Fact(\n            decodedInteger == integer,\n            $\"Decoded integer {decodedInteger}, but expected {integer}.\"\n        );\n\n        Message($\"Successfully decoded bit string as int: {decodedInteger}\");\n        decodedIntegers += [decodedInteger];\n    }\n\n    return decodedIntegers;\n}\n\n/// # Summary\n/// This operation implements the Bernstein-Vazirani quantum algorithm.\n/// This algorithm computes for a given Boolean function that is promised to\n/// be a parity 𝑓(𝑥₀, …, 𝑥ₙ₋₁) = Σᵢ 𝑟ᵢ 𝑥ᵢ a result in the form of a bit\n/// vector (𝑟₀, …, 𝑟ₙ₋₁) corresponding to the parity function.\n/// Note that it is promised that the function is actually a parity\n/// function.\n///\n/// # Input\n/// ## Uf\n/// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉,\n/// where 𝑓 is a Boolean function that implements a parity Σᵢ 𝑟ᵢ 𝑥ᵢ.\n/// ## n\n/// The number of bits in the input register |𝑥〉.\n///\n/// # Output\n/// An array of type `Result[]` that contains the parity 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁).\n///\n/// # See Also\n/// - For details see Section 1.4.3 of Nielsen & Chuang.\n///\n/// # References\n/// - [ *Ethan Bernstein and Umesh Vazirani*,\n///     SIAM J. Comput., 26(5), 1411–1473, 1997 ]\n///   (https://doi.org/10.1137/S0097539796300921)\noperation BernsteinVazirani(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n    // We allocate n + 1 clean qubits. Note that the function Uf is defined\n    // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n    use queryRegister = Qubit[n];\n    use target = Qubit();\n\n    // The last qubit needs to be flipped so that the function will actually\n    // be computed into the phase when Uf is applied.\n    X(target);\n\n    within {\n        // Now, a Hadamard transform is applied to each of the qubits. As\n        // the last step before the measurement, a Hadamard transform is\n        // applied to all qubits except last one. We could apply the\n        // transform to the last qubit also, but this would not affect the\n        // final outcome.\n        // We use a within-apply block to ensure that the Hadamard transform\n        // is correctly inverted.\n        ApplyToEachA(H, queryRegister);\n    } apply {\n        H(target);\n        // We now apply Uf to the n+1 qubits, computing\n        // |x, y〉 ↦ |x, y ⊕ f(x)〉.\n        Uf(queryRegister, target);\n    }\n\n    // Measure all qubits and reset them to the |0〉 state so that they can\n    // be safely deallocated at the end of the block.\n    let resultArray = MResetEachZ(queryRegister);\n\n    // Finally, the last qubit, which held the y-register, is reset.\n    Reset(target);\n\n    // The result is already contained in resultArray so no further\n    // post-processing is necessary.\n    return resultArray;\n}\n\n/// # Summary\n/// Given an integer that can be represented as a bit string\n/// 𝑟⃗ = (r₀, …, rₙ₋₁), this operation applies a unitary 𝑈 that acts on 𝑛 + 1\n/// qubits as:\n///     𝑈 |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉\n/// where 𝑓(𝑥) = Σᵢ 𝑥ᵢ 𝑟ᵢ mod 2.\n///\n/// # Input\n/// ## bitStringAsInt\n/// An integer that can be represented as a bit string 𝑟⃗ used to define the\n/// function 𝑓.\n/// ## xRegister\n/// Represents the |𝑥〉 register that 𝑈 acts on.\n/// ## yQubit\n/// Represents the |𝑦〉 qubit that 𝑈 acts on.\noperation ApplyParityOperation(\n    bitStringAsInt : Int,\n    xRegister : Qubit[],\n    yQubit : Qubit\n) : Unit {\n    // `xRegister` muts have enough qubits to represent the integer.\n    let requiredBits = BitSizeI(bitStringAsInt);\n    let availableQubits = Length(xRegister);\n    Fact(\n        availableQubits >= requiredBits,\n        $\"Integer value {bitStringAsInt} requires {requiredBits} bits to be represented but the quantum register only has {availableQubits} qubits\"\n    );\n\n    // Apply the quantum operations that encode the bit string.\n    for index in IndexRange(xRegister) {\n        if ((bitStringAsInt &&& 2^index) != 0) {\n            CNOT(xRegister[index], yQubit);\n        }\n    }\n}\n\n/// # Summary\n/// Returns black-box operations (Qubit[], Qubit) => () of the form\n/// U_f |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n/// We define 𝑓 by providing the bit string 𝑟⃗ as an integer.\nfunction EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n    return ApplyParityOperation(bitStringAsInt, _, _);\n}\n"
     },
     {
         "title": "Grover's Search",
@@ -72,17 +72,17 @@ export default [
     {
         "title": "Hidden Shift (Advanced)",
         "shots": 1,
-        "code": "/// # Sample\n/// Hidden Shift\n///\n/// # Description\n/// There is a family of problems known as hidden shift problems, in which it\n/// is given that two Boolean functions 𝑓 and 𝑔 satisfy the relation\n///     𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠) for all 𝑥\n/// where 𝑠 is a hidden bit string that we would like to find.\n///\n/// This Q# program implements an algorithm to solve the hidden shift problem.\nimport Std.Arrays.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Measurement.*;\n\noperation Main() : Int[] {\n    let nQubits = 10;\n\n    // Consider the case of finding a hidden shift 𝑠 between two Boolean\n    // functions 𝑓(𝑥) and 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠).\n    // This problem can be solved on a quantum computer with one call to\n    // each of 𝑓 and 𝑔 in the special case that both functions are bent;\n    // that is, that they are as far from linear as possible.\n\n    // Here, we find the hidden shift for various pairs of bent functions.\n    let shifts = [170, 512, 999];\n    mutable hiddenShifts = [];\n    for shift in shifts {\n        let hiddenShiftBitString = FindHiddenShift(\n            BentFunction,\n            register => ShiftedBentFunction(shift, register),\n            nQubits\n        );\n        let hiddenShift = ResultArrayAsInt(hiddenShiftBitString);\n        Message($\"Found {shift} successfully!\");\n        set hiddenShifts += [hiddenShift];\n    }\n\n    // Note: returned array should match shifts array\n    return hiddenShifts;\n}\n\n/// # Summary\n/// Implements a correlation-based algorithm to solve the hidden shift\n/// problem for bent functions.\n///\n/// # Description\n/// Implements a solution for the hidden shift problem, which is to identify\n/// an unknown shift 𝑠 of the arguments of two Boolean functions 𝑓 and 𝑔\n/// that are promised to satisfy the relation 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠) for all 𝑥.\n///\n/// 𝑓 and 𝑔 are assumed to be bent functions. A Boolean function is bent if\n/// it is as far from linear as possible. In particular, bent functions have\n/// flat Fourier (Walsh–Hadamard) spectra.\n///\n/// In this case, the Roetteler algorithm (see References, below) uses\n/// black-box oracles for 𝑓^* and 𝑔, where 𝑓^* is the dual bent function to\n/// 𝑓, and computes the hidden shift 𝑠 between 𝑓 and 𝑔.\n///\n/// # Input\n/// ## Ufstar\n/// A quantum operation that implements\n/// $U_f^*: |𝑥〉 ↦ (-1)^{f^*(x)} |𝑥〉$,\n/// where $f^*$ is a Boolean function, 𝑥 is an $n$ bit register\n/// ## Ug\n/// A quantum operation that implements\n/// $U_g:|𝑥〉 ↦ (-1)^{g(x)} |𝑥〉$,\n/// where 𝑔 is a Boolean function that is shifted by unknown\n/// 𝑠 from 𝑓, and 𝑥 is an $n$ bit register.\n/// ## n\n/// The number of bits of the input register |𝑥〉.\n///\n/// # Output\n/// An array of type `Result[]` which encodes the bit representation\n/// of the hidden shift.\n///\n/// # References\n/// - [*Martin Roetteler*,\n///    Proc. SODA 2010, ACM, pp. 448-457, 2010]\n///   (https://doi.org/10.1137/1.9781611973075.37)\noperation FindHiddenShift(\n    Ufstar : (Qubit[] => Unit),\n    Ug : (Qubit[] => Unit),\n    n : Int\n) : Result[] {\n    // We allocate n clean qubits. Note that the function Ufstar and Ug are\n    // unitary operations on n qubits defined via phase encoding.\n    use qubits = Qubit[n];\n\n    // First, a Hadamard transform is applied to each of the qubits.\n    ApplyToEach(H, qubits);\n\n    // We now apply the shifted function Ug to the n qubits, computing\n    // |x〉 -> (-1)^{g(x)} |x〉.\n    Ug(qubits);\n\n    within {\n        // A Hadamard transform is applied to each of the n qubits.\n        ApplyToEachA(H, qubits);\n    } apply {\n        // we now apply the dual function of the unshifted function, i.e.,\n        // Ufstar, to the n qubits, computing |x〉 -> (-1)^{fstar(x)} |x〉.\n        Ufstar(qubits);\n    }\n\n    // Measure the n qubits and reset them to zero so that they can be\n    // safely deallocated at the end of the block.\n    return MResetEachZ(qubits);\n}\n\n/// # Summary\n/// Implements an oracle for a bent function constructed from the inner\n/// product of Boolean functions.\n///\n/// # Description\n/// This operation defines the Boolean function IP(x_0, ..., x_{n-1}) which\n/// is computed into the phase, i.e., a diagonal operator that maps\n/// |x〉 -> (-1)^{IP(x)} |x〉, where x stands for x=(x_0, ..., x_{n-1}) and all\n/// the x_i are binary. The IP function is defined as\n/// IP(y, z) = y_0 z_0 + y_1 z_1 + ... y_{u-1} z_{u-1} where\n/// y = (y_0, ..., y_{u-1}) and z =  (z_0, ..., z_{u-1}) are two bit vectors\n/// of length u. Notice that the function IP is a Boolean function on n = 2u\n/// bits. IP is a special case of bent function. These are functions for\n/// which the Walsh-Hadamard transform is perfectly flat (in absolute\n/// value).\n/// Because of this flatness, the Walsh-Hadamard spectrum of any bent\n/// function defines a +1/-1 function, i.e., gives rise to another Boolean\n/// function, called the dual bent function. Moreover, for the case of the\n/// IP function it can be shown that IP is equal to its own dual bent\n/// function.\n///\n/// # Remarks\n/// Notice that a diagonal operator implementing IP between 2 variables y_0\n/// and z_0 is nothing but the AND function between those variables, i.e.,\n/// in phase encoding it is computed by a Controlled-Z gate.\n/// Extending this to an XOR of the AND of more variables, as required in\n/// the definition of the IP function can then be accomplished by applying\n/// several Controlled-Z gates between the respective inputs.\noperation BentFunction(register : Qubit[]) : Unit {\n    Fact(Length(register) % 2 == 0, \"Length of register must be even.\");\n    let u = Length(register) / 2;\n    let xs = register[0..u - 1];\n    let ys = register[u...];\n    for index in 0..u - 1 {\n        CZ(xs[index], ys[index]);\n    }\n}\n\n/// # Summary\n/// Implements a shifted bend function 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠).\n///\n/// # Description\n/// For the hidden shift problem we need another function g which is related\n/// to IP via g(x) = IP(x + s), i.e., we have to shift the argument of the\n/// IP function by a given shift. Notice that the '+' operation here is the\n/// Boolean addition, i.e., a bit-wise operation. Notice further, that in\n/// general a diagonal operation |x〉 -> (-1)^{f(x)} can be turned into a\n/// shifted version by applying a bit flip to the |x〉 register first, then\n/// applying the diagonal operation, and then undoing the bit flips to the\n/// |x〉 register. We use this principle to define shifted versions of the IP\n/// operation.\noperation ShiftedBentFunction(shift : Int, register : Qubit[]) : Unit {\n    Fact(Length(register) % 2 == 0, \"Length of register must be even.\");\n    let u = Length(register) / 2;\n    within {\n        // Flips the bits in shift.\n        ApplyXorInPlace(shift, register);\n    } apply {\n        // Compute the IP function into the phase.\n        BentFunction(register);\n    }\n}\n"
+        "code": "/// # Sample\n/// Hidden Shift\n///\n/// # Description\n/// There is a family of problems known as hidden shift problems, in which it\n/// is given that two Boolean functions 𝑓 and 𝑔 satisfy the relation\n///     𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠) for all 𝑥\n/// where 𝑠 is a hidden bit string that we would like to find.\n///\n/// This Q# program implements an algorithm to solve the hidden shift problem.\nimport Std.Arrays.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Measurement.*;\n\noperation Main() : Int[] {\n    let nQubits = 10;\n\n    // Consider the case of finding a hidden shift 𝑠 between two Boolean\n    // functions 𝑓(𝑥) and 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠).\n    // This problem can be solved on a quantum computer with one call to\n    // each of 𝑓 and 𝑔 in the special case that both functions are bent;\n    // that is, that they are as far from linear as possible.\n\n    // Here, we find the hidden shift for various pairs of bent functions.\n    let shifts = [170, 512, 999];\n    mutable hiddenShifts = [];\n    for shift in shifts {\n        let hiddenShiftBitString = FindHiddenShift(\n            BentFunction,\n            register => ShiftedBentFunction(shift, register),\n            nQubits\n        );\n        let hiddenShift = ResultArrayAsInt(hiddenShiftBitString);\n        Message($\"Found {shift} successfully!\");\n        hiddenShifts += [hiddenShift];\n    }\n\n    // Note: returned array should match shifts array\n    return hiddenShifts;\n}\n\n/// # Summary\n/// Implements a correlation-based algorithm to solve the hidden shift\n/// problem for bent functions.\n///\n/// # Description\n/// Implements a solution for the hidden shift problem, which is to identify\n/// an unknown shift 𝑠 of the arguments of two Boolean functions 𝑓 and 𝑔\n/// that are promised to satisfy the relation 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠) for all 𝑥.\n///\n/// 𝑓 and 𝑔 are assumed to be bent functions. A Boolean function is bent if\n/// it is as far from linear as possible. In particular, bent functions have\n/// flat Fourier (Walsh–Hadamard) spectra.\n///\n/// In this case, the Roetteler algorithm (see References, below) uses\n/// black-box oracles for 𝑓^* and 𝑔, where 𝑓^* is the dual bent function to\n/// 𝑓, and computes the hidden shift 𝑠 between 𝑓 and 𝑔.\n///\n/// # Input\n/// ## Ufstar\n/// A quantum operation that implements\n/// $U_f^*: |𝑥〉 ↦ (-1)^{f^*(x)} |𝑥〉$,\n/// where $f^*$ is a Boolean function, 𝑥 is an $n$ bit register\n/// ## Ug\n/// A quantum operation that implements\n/// $U_g:|𝑥〉 ↦ (-1)^{g(x)} |𝑥〉$,\n/// where 𝑔 is a Boolean function that is shifted by unknown\n/// 𝑠 from 𝑓, and 𝑥 is an $n$ bit register.\n/// ## n\n/// The number of bits of the input register |𝑥〉.\n///\n/// # Output\n/// An array of type `Result[]` which encodes the bit representation\n/// of the hidden shift.\n///\n/// # References\n/// - [*Martin Roetteler*,\n///    Proc. SODA 2010, ACM, pp. 448-457, 2010]\n///   (https://doi.org/10.1137/1.9781611973075.37)\noperation FindHiddenShift(\n    Ufstar : (Qubit[] => Unit),\n    Ug : (Qubit[] => Unit),\n    n : Int\n) : Result[] {\n    // We allocate n clean qubits. Note that the function Ufstar and Ug are\n    // unitary operations on n qubits defined via phase encoding.\n    use qubits = Qubit[n];\n\n    // First, a Hadamard transform is applied to each of the qubits.\n    ApplyToEach(H, qubits);\n\n    // We now apply the shifted function Ug to the n qubits, computing\n    // |x〉 -> (-1)^{g(x)} |x〉.\n    Ug(qubits);\n\n    within {\n        // A Hadamard transform is applied to each of the n qubits.\n        ApplyToEachA(H, qubits);\n    } apply {\n        // we now apply the dual function of the unshifted function, i.e.,\n        // Ufstar, to the n qubits, computing |x〉 -> (-1)^{fstar(x)} |x〉.\n        Ufstar(qubits);\n    }\n\n    // Measure the n qubits and reset them to zero so that they can be\n    // safely deallocated at the end of the block.\n    return MResetEachZ(qubits);\n}\n\n/// # Summary\n/// Implements an oracle for a bent function constructed from the inner\n/// product of Boolean functions.\n///\n/// # Description\n/// This operation defines the Boolean function IP(x_0, ..., x_{n-1}) which\n/// is computed into the phase, i.e., a diagonal operator that maps\n/// |x〉 -> (-1)^{IP(x)} |x〉, where x stands for x=(x_0, ..., x_{n-1}) and all\n/// the x_i are binary. The IP function is defined as\n/// IP(y, z) = y_0 z_0 + y_1 z_1 + ... y_{u-1} z_{u-1} where\n/// y = (y_0, ..., y_{u-1}) and z =  (z_0, ..., z_{u-1}) are two bit vectors\n/// of length u. Notice that the function IP is a Boolean function on n = 2u\n/// bits. IP is a special case of bent function. These are functions for\n/// which the Walsh-Hadamard transform is perfectly flat (in absolute\n/// value).\n/// Because of this flatness, the Walsh-Hadamard spectrum of any bent\n/// function defines a +1/-1 function, i.e., gives rise to another Boolean\n/// function, called the dual bent function. Moreover, for the case of the\n/// IP function it can be shown that IP is equal to its own dual bent\n/// function.\n///\n/// # Remarks\n/// Notice that a diagonal operator implementing IP between 2 variables y_0\n/// and z_0 is nothing but the AND function between those variables, i.e.,\n/// in phase encoding it is computed by a Controlled-Z gate.\n/// Extending this to an XOR of the AND of more variables, as required in\n/// the definition of the IP function can then be accomplished by applying\n/// several Controlled-Z gates between the respective inputs.\noperation BentFunction(register : Qubit[]) : Unit {\n    Fact(Length(register) % 2 == 0, \"Length of register must be even.\");\n    let u = Length(register) / 2;\n    let xs = register[0..u - 1];\n    let ys = register[u...];\n    for index in 0..u - 1 {\n        CZ(xs[index], ys[index]);\n    }\n}\n\n/// # Summary\n/// Implements a shifted bend function 𝑔(𝑥) = 𝑓(𝑥 ⊕ 𝑠).\n///\n/// # Description\n/// For the hidden shift problem we need another function g which is related\n/// to IP via g(x) = IP(x + s), i.e., we have to shift the argument of the\n/// IP function by a given shift. Notice that the '+' operation here is the\n/// Boolean addition, i.e., a bit-wise operation. Notice further, that in\n/// general a diagonal operation |x〉 -> (-1)^{f(x)} can be turned into a\n/// shifted version by applying a bit flip to the |x〉 register first, then\n/// applying the diagonal operation, and then undoing the bit flips to the\n/// |x〉 register. We use this principle to define shifted versions of the IP\n/// operation.\noperation ShiftedBentFunction(shift : Int, register : Qubit[]) : Unit {\n    Fact(Length(register) % 2 == 0, \"Length of register must be even.\");\n    let u = Length(register) / 2;\n    within {\n        // Flips the bits in shift.\n        ApplyXorInPlace(shift, register);\n    } apply {\n        // Compute the IP function into the phase.\n        BentFunction(register);\n    }\n}\n"
     },
     {
         "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 = 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"
+        "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            (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            foundFactors = true;\n            factors = (gcd, number / gcd);\n        }\n        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            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",
         "shots": 1,
-        "code": "// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport Std.Math.*;\nimport Std.Diagnostics.*;\n\noperation Main() : (Bool, Int) {\n    // A qubit register that will be used for encoding.\n    use encodedRegister = Qubit[3];\n\n    // Initialize the first qubit in the register to a |-〉 state.\n    H(encodedRegister[0]);\n    Z(encodedRegister[0]);\n\n    // Apply several unitary operations to the encoded qubits\n    // performing bit flip detection and correction between each application.\n    mutable bitFlipCount = 0;\n    within {\n        // The 3 qubit register is used as a repetition code.\n        Encode(encodedRegister);\n    } apply {\n        let iterations = 5;\n        for _ in 1..iterations {\n            // Apply a unitary operation to the encoded register that should\n            // effectively perform an identity operation but may be noisy\n            // on the quantum hardware and introduce errors.\n            ApplyRotationalIdentity(encodedRegister);\n\n            // Measure the bit flip error syndrome, revert the bit flip if needed,\n            // and increase the count if a bit flip occurred.\n            let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister);\n            let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);\n            if (bitFlipReverted) {\n                set bitFlipCount += 1;\n            }\n        }\n    }\n\n    // Transform the qubit to the |1〉 state and measure it in the computational basis.\n    H(encodedRegister[0]);\n    let result = MResetZ(encodedRegister[0]) == One;\n    // Note that the qubit at index 0 is already reset by MResetZ operation.\n    // There's no need to reset it again. Also, MResetZ operation is\n    // preferable to the measurement, which is followed by Reset as MResetZ\n    // may be directly implemented by the hardware.\n    ResetAll(encodedRegister[1...]);\n\n    // The output of the program is a boolean-integer tuple where the boolean\n    // represents whether the qubit measurement result was the expected one\n    // and the integer represents the number of times bit flips occurred\n    // throughout the program.\n    return (result, bitFlipCount);\n}\n\n/// # Summary\n/// Apply four 𝜋/2 rotations about the x-axis to all qubits in the `register`.\n///\n/// # Description\n/// This operation implements an identity operation using rotations about the x-axis.\n/// The Rx operation has a period of 2𝜋. Using it to apply four 𝜋/2 rotations\n/// about the x-axis, effectively leaves the qubit register in its original state.\n/// However it is likely to be very noisy on a quantum hardware.\noperation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj {\n    let theta = PI() * 0.5;\n    for i in 1..4 {\n        for qubit in register {\n            Rx(theta, qubit);\n        }\n    }\n}\n\n/// # Summary\n/// Reverts bit flips in the `register` based on `parity01` and `parity12`.\noperation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool {\n    mutable result = true;\n    if parity01 == One {\n        if parity12 == One {\n            X(register[1]);\n        } else {\n            X(register[0]);\n        }\n    } else {\n        if parity12 == One {\n            X(register[2]);\n        } else {\n            set result = false;\n        }\n    }\n    return result;\n}\n\noperation Encode(register : Qubit[]) : Unit is Adj {\n    CNOT(register[0], register[1]);\n    CNOT(register[0], register[2]);\n}\n\n/// # Summary\n/// Measures the bit flip syndrome by checking the parities between\n/// qubits 0 and 1, and between qubits 1 and 2.\noperation MeasureBitFlipSyndrome(encodedRegister : Qubit[]) : (Result, Result) {\n    Fact(Length(encodedRegister) == 3, \"Encoded register must be of length 3.\");\n    use auxiliaryRegister = Qubit[2];\n\n    CNOT(encodedRegister[0], auxiliaryRegister[0]);\n    CNOT(encodedRegister[1], auxiliaryRegister[0]);\n    CNOT(encodedRegister[1], auxiliaryRegister[1]);\n    CNOT(encodedRegister[2], auxiliaryRegister[1]);\n\n    let parity01 = MResetZ(auxiliaryRegister[0]);\n    let parity12 = MResetZ(auxiliaryRegister[1]);\n    return (parity01, parity12);\n}\n"
+        "code": "// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport Std.Math.*;\nimport Std.Diagnostics.*;\n\noperation Main() : (Bool, Int) {\n    // A qubit register that will be used for encoding.\n    use encodedRegister = Qubit[3];\n\n    // Initialize the first qubit in the register to a |-〉 state.\n    H(encodedRegister[0]);\n    Z(encodedRegister[0]);\n\n    // Apply several unitary operations to the encoded qubits\n    // performing bit flip detection and correction between each application.\n    mutable bitFlipCount = 0;\n    within {\n        // The 3 qubit register is used as a repetition code.\n        Encode(encodedRegister);\n    } apply {\n        let iterations = 5;\n        for _ in 1..iterations {\n            // Apply a unitary operation to the encoded register that should\n            // effectively perform an identity operation but may be noisy\n            // on the quantum hardware and introduce errors.\n            ApplyRotationalIdentity(encodedRegister);\n\n            // Measure the bit flip error syndrome, revert the bit flip if needed,\n            // and increase the count if a bit flip occurred.\n            let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister);\n            let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);\n            if (bitFlipReverted) {\n                bitFlipCount += 1;\n            }\n        }\n    }\n\n    // Transform the qubit to the |1〉 state and measure it in the computational basis.\n    H(encodedRegister[0]);\n    let result = MResetZ(encodedRegister[0]) == One;\n    // Note that the qubit at index 0 is already reset by MResetZ operation.\n    // There's no need to reset it again. Also, MResetZ operation is\n    // preferable to the measurement, which is followed by Reset as MResetZ\n    // may be directly implemented by the hardware.\n    ResetAll(encodedRegister[1...]);\n\n    // The output of the program is a boolean-integer tuple where the boolean\n    // represents whether the qubit measurement result was the expected one\n    // and the integer represents the number of times bit flips occurred\n    // throughout the program.\n    return (result, bitFlipCount);\n}\n\n/// # Summary\n/// Apply four 𝜋/2 rotations about the x-axis to all qubits in the `register`.\n///\n/// # Description\n/// This operation implements an identity operation using rotations about the x-axis.\n/// The Rx operation has a period of 2𝜋. Using it to apply four 𝜋/2 rotations\n/// about the x-axis, effectively leaves the qubit register in its original state.\n/// However it is likely to be very noisy on a quantum hardware.\noperation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj {\n    let theta = PI() * 0.5;\n    for i in 1..4 {\n        for qubit in register {\n            Rx(theta, qubit);\n        }\n    }\n}\n\n/// # Summary\n/// Reverts bit flips in the `register` based on `parity01` and `parity12`.\noperation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool {\n    mutable result = true;\n    if parity01 == One {\n        if parity12 == One {\n            X(register[1]);\n        } else {\n            X(register[0]);\n        }\n    } else {\n        if parity12 == One {\n            X(register[2]);\n        } else {\n            result = false;\n        }\n    }\n    return result;\n}\n\noperation Encode(register : Qubit[]) : Unit is Adj {\n    CNOT(register[0], register[1]);\n    CNOT(register[0], register[2]);\n}\n\n/// # Summary\n/// Measures the bit flip syndrome by checking the parities between\n/// qubits 0 and 1, and between qubits 1 and 2.\noperation MeasureBitFlipSyndrome(encodedRegister : Qubit[]) : (Result, Result) {\n    Fact(Length(encodedRegister) == 3, \"Encoded register must be of length 3.\");\n    use auxiliaryRegister = Qubit[2];\n\n    CNOT(encodedRegister[0], auxiliaryRegister[0]);\n    CNOT(encodedRegister[1], auxiliaryRegister[0]);\n    CNOT(encodedRegister[1], auxiliaryRegister[1]);\n    CNOT(encodedRegister[2], auxiliaryRegister[1]);\n\n    let parity01 = MResetZ(auxiliaryRegister[0]);\n    let parity12 = MResetZ(auxiliaryRegister[1]);\n    return (parity01, parity12);\n}\n"
     },
     {
         "title": "Dynamics (Resource Estimation)",
@@ -99,7 +99,7 @@ export default [
     {
         "title": "Shor (Resource Estimation)",
         "shots": 1,
-        "code": "/// # Sample\n/// Estimating Frequency for Shor's algorithm\n///\n/// # Description\n/// In this sample we concentrate on costing the `EstimateFrequency`\n/// operation, which is the core quantum operation in Shor's algorithm, and\n/// we omit the classical pre- and post-processing. This makes it ideal for\n/// use with the Azure Quantum Resource Estimator.\nimport Std.Arrays.*;\nimport Std.Canon.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\nimport Std.Arithmetic.*;\nimport Std.ResourceEstimation.*;\n\noperation Main() : Unit {\n    let bitsize = 31;\n\n    // When chooseing parameters for `EstimateFrequency`, make sure that\n    // generator and modules are not co-prime\n    let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);\n}\n\n/// # Summary\n/// Estimates the frequency of a generator\n/// in the residue ring Z mod `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/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision\n/// approximating s/r.\noperation EstimateFrequency(\n    generator : Int,\n    modulus : Int,\n    bitsize : Int\n) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Allocate qubits for the superposition of eigenstates of\n    // the oracle that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of\n    // the eigenstates we are estimating the phases of.\n    // We first interpret the register as encoding an unsigned integer\n    // in little endian encoding.\n    ApplyXorInPlace(1, eigenstateRegister);\n    let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);\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        within {\n            H(c);\n        } apply {\n            // `BeginEstimateCaching` and `EndEstimateCaching` are the operations\n            // exposed by Azure Quantum Resource Estimator. These will instruct\n            // resource counting such that the if-block will be executed\n            // only once, its resources will be cached, and appended in\n            // every other iteration.\n            if BeginEstimateCaching(\"ControlledOracle\", SingleVariant()) {\n                Controlled oracle([c], (1 <<< idx, eigenstateRegister));\n                EndEstimateCaching();\n            }\n            R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        }\n        if MResetZ(c) == One {\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 Std.Intrinsic.ResetAll.\n    ResetAll(eigenstateRegister);\n\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/// Estimating Frequency for Shor's algorithm\n///\n/// # Description\n/// In this sample we concentrate on costing the `EstimateFrequency`\n/// operation, which is the core quantum operation in Shor's algorithm, and\n/// we omit the classical pre- and post-processing. This makes it ideal for\n/// use with the Azure Quantum Resource Estimator.\nimport Std.Arrays.*;\nimport Std.Canon.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\nimport Std.Arithmetic.*;\nimport Std.ResourceEstimation.*;\n\noperation Main() : Unit {\n    let bitsize = 31;\n\n    // When chooseing parameters for `EstimateFrequency`, make sure that\n    // generator and modules are not co-prime\n    let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);\n}\n\n/// # Summary\n/// Estimates the frequency of a generator\n/// in the residue ring Z mod `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/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision\n/// approximating s/r.\noperation EstimateFrequency(\n    generator : Int,\n    modulus : Int,\n    bitsize : Int\n) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Allocate qubits for the superposition of eigenstates of\n    // the oracle that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of\n    // the eigenstates we are estimating the phases of.\n    // We first interpret the register as encoding an unsigned integer\n    // in little endian encoding.\n    ApplyXorInPlace(1, eigenstateRegister);\n    let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);\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        within {\n            H(c);\n        } apply {\n            // `BeginEstimateCaching` and `EndEstimateCaching` are the operations\n            // exposed by Azure Quantum Resource Estimator. These will instruct\n            // resource counting such that the if-block will be executed\n            // only once, its resources will be cached, and appended in\n            // every other iteration.\n            if BeginEstimateCaching(\"ControlledOracle\", SingleVariant()) {\n                Controlled oracle([c], (1 <<< idx, eigenstateRegister));\n                EndEstimateCaching();\n            }\n            R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        }\n        if MResetZ(c) == One {\n            frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using Std.Intrinsic.ResetAll.\n    ResetAll(eigenstateRegister);\n\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",
         "omitFromTests": true
     }
 ];

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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/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: 03/06/2025
+ms.date: 03/19/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__