qsharp-lang 1.8.2-dev → 1.8.4-dev

package/dist/samples.generated.js

@@ -12,17 +12,17 @@ export default [
     {
         "title": "Entanglement",
         "shots": 100,
-        "code": "/// # Sample\n/// Entanglement\n///\n/// # Description\n/// Qubits are said to be entangled when the state of each one of them cannot be\n/// described independently from the state of the others.\n///\n/// This Q# program entangles two qubits.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n\n    @EntryPoint()\n    operation EntangleQubits() : (Result, Result) {\n        // Allocate the two qubits that will be entangled.\n        use (q1, q2) = (Qubit(), Qubit());\n\n        // Set the first qubit in superposition by calling the `H` operation,\n        // which applies a Hadamard transformation to the qubit.\n        // Then, entangle the two qubits using the `CNOT` operation.\n        H(q1);\n        CNOT(q1, q2);\n\n        // Show the entangled state using the `DumpMachine` function.\n        DumpMachine();\n\n        // Measurements of entangled qubits are always correlated.\n        let (m1, m2) = (M(q1), M(q2));\n        Reset(q1);\n        Reset(q2);\n        return (m1, m2);\n    }\n}"
+        "code": "/// # Sample\n/// Entanglement\n///\n/// # Description\n/// Qubits are said to be entangled when the state of each one of them cannot be\n/// described independently from the state of the others.\n///\n/// This Q# program entangles two qubits.\nnamespace Sample {\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation EntangleQubits() : (Result, Result) {\n        // Allocate the two qubits that will be entangled.\n        use (q1, q2) = (Qubit(), Qubit());\n\n        // Set the first qubit in superposition by calling the `H` operation,\n        // which applies a Hadamard transformation to the qubit.\n        // Then, entangle the two qubits using the `CNOT` operation.\n        H(q1);\n        CNOT(q1, q2);\n\n        // Show the entangled state using the `DumpMachine` function.\n        DumpMachine();\n\n        // Measurements of entangled qubits are always correlated.\n        let (m1, m2) = (M(q1), M(q2));\n        Reset(q1);\n        Reset(q2);\n        return (m1, m2);\n    }\n}"
     },
     {
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation BellStates() : (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.\n    operation 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.\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    import Std.Diagnostics.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation BellStates() : (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.\n    operation 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.\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation 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.\n    operation 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 |+⟩.\n    operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |−⟩.\n    operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\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.\nnamespace Sample {\n    import Std.Diagnostics.*;\n    import Std.Intrinsic.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation 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.\n    operation 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 |+⟩.\n    operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |−⟩.\n    operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\n}\n"
     },
     {
         "title": "Random Bit",
@@ -32,69 +32,69 @@ export default [
     {
         "title": "Random Number Generator",
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Intrinsic;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Generate 5-bit random number.\n        let nBits = 5;\n        return GenerateNRandomBits(nBits);\n    }\n\n    /// # Summary\n    /// Generates N random bits.\n    operation GenerateNRandomBits(nBits : Int) : Result[] {\n        // Allocate N qubits.\n        use register = Qubit[nBits];\n\n        // Set the qubits into superposition of 0 and 1 using the Hadamard\n        // operation `H`.\n        for qubit in register {\n            H(qubit);\n        }\n\n        // At this point each has 50% chance of being measured in the |0〉 state\n        // and 50% chance of being measured in the |1〉 state.\n        // Measure each qubit and reset them all so they can be safely\n        // deallocated.\n        let results = MResetEachZ(register);\n        return results;\n    }\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.\nnamespace Sample {\n    import Std.Measurement.*;\n    import Std.Intrinsic.*;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Generate 5-bit random number.\n        let nBits = 5;\n        return GenerateNRandomBits(nBits);\n    }\n\n    /// # Summary\n    /// Generates N random bits.\n    operation GenerateNRandomBits(nBits : Int) : Result[] {\n        // Allocate N qubits.\n        use register = Qubit[nBits];\n\n        // Set the qubits into superposition of 0 and 1 using the Hadamard\n        // operation `H`.\n        for qubit in register {\n            H(qubit);\n        }\n\n        // At this point each has 50% chance of being measured in the |0〉 state\n        // and 50% chance of being measured in the |1〉 state.\n        // Measure each qubit and reset them all so they can be safely\n        // deallocated.\n        let results = MResetEachZ(register);\n        return results;\n    }\n}\n"
     },
     {
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Math;\n\n    @EntryPoint()\n    operation 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`.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    import Std.Convert.*;\n    import Std.Intrinsic.*;\n    import Std.Math.*;\n\n    @EntryPoint()\n    operation 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`.\n    operation 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.\n    operation 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}\n"
     },
     {
         "title": "Deutsch-Jozsa",
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : (Result[], Result[]) {\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 a couple of functions.\n        let balancedResults = DeutschJozsa(SimpleBalancedBoolF, 5);\n        let constantResults = DeutschJozsa(SimpleConstantBoolF, 5);\n        return (balancedResults, constantResults);\n    }\n\n    /// # Summary\n    /// This operation implements the DeutschJozsa algorithm.\n    /// It returns the query register measurement results. If all the measurement\n    /// results are `Zero`, the function is constant. If at least one measurement\n    /// result is `One`, the function is balanced.\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    /// An array of measurement results for the query register.\n    /// All `Zero` measurement results indicate that the function is constant.\n    /// At least one `One` measurement result in the array indicates that the\n    /// 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)\n    operation DeutschJozsa(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        // 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        // Measure the query register and reset all qubits so they can be safely\n        // deallocated.\n        let results = MResetEachZ(queryRegister);\n        Reset(target);\n        return results;\n    }\n\n    // Simple constant Boolean function\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n        CX(args[0], target);\n    }\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.\nnamespace Sample {\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation Main() : (Result[], Result[]) {\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 a couple of functions.\n        let balancedResults = DeutschJozsa(SimpleBalancedBoolF, 5);\n        let constantResults = DeutschJozsa(SimpleConstantBoolF, 5);\n        return (balancedResults, constantResults);\n    }\n\n    /// # Summary\n    /// This operation implements the DeutschJozsa algorithm.\n    /// It returns the query register measurement results. If all the measurement\n    /// results are `Zero`, the function is constant. If at least one measurement\n    /// result is `One`, the function is balanced.\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    /// An array of measurement results for the query register.\n    /// All `Zero` measurement results indicate that the function is constant.\n    /// At least one `One` measurement result in the array indicates that the\n    /// 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)\n    operation DeutschJozsa(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        // 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        // Measure the query register and reset all qubits so they can be safely\n        // deallocated.\n        let results = MResetEachZ(queryRegister);\n        Reset(target);\n        return results;\n    }\n\n    // Simple constant Boolean function\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n        CX(args[0], target);\n    }\n}\n\n"
     },
     {
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation 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)\n    operation 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\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation 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)\n    operation 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\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation 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.\n    operation 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.\n    operation 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}\n"
     },
     {
         "title": "Bernstein–Vazirani",
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Consider a function 𝑓(𝑥⃗) on bitstrings 𝑥⃗ = (𝑥₀, …, 𝑥ₙ₋₁) of the form\n        //     𝑓(𝑥⃗) ≔ Σᵢ 𝑥ᵢ 𝑟ᵢ\n        // where 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁) is an unknown bit string that determines the\n        // parity of 𝑓.\n\n        // The Bernstein–Vazirani algorithm allows determining 𝑟 given a\n        // quantum operation that implements\n        //     |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n\n        // This entry point function of this program, `Main`, shows how to use\n        // the `BernsteinVazirani` operation to determine the value of bitstring\n        // 𝑟.\n        let secretBitString = SecretBitStringAsBoolArray();\n        let parityOperation = EncodeBitStringAsParityOperation(secretBitString);\n        let decodedBitString = BernsteinVazirani(\n            parityOperation,\n            Length(secretBitString)\n        );\n\n        return decodedBitString;\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)\n    operation BernsteinVazirani(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n        // We allocate n + 1 clean qubits. Note that the function parameter 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 a relative phase is\n        // introduced when we apply a Hadamard gate later on and we can use\n        // phase kickback 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 the last one. We could also\n            // transform the last qubit, 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 bit string 𝑟⃗ = (r₀, …, rₙ₋₁), represented as an array of Booleans,\n    /// this operation applies a unitary 𝑈 that acts on 𝑛 + 1 qubits as:\n    ///     𝑈 |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉\n    /// where 𝑓(𝑥) = Σᵢ 𝑥ᵢ 𝑟ᵢ mod 2.\n    ///\n    /// # Input\n    /// ## bitStringAsBoolArray\n    /// A bit string 𝑟⃗, represented as an array of Booleans, used to define the\n    /// function 𝑓.\n    /// ## xRegister\n    /// Represents the |𝑥〉 register that 𝑈 acts on.\n    /// ## yQubit\n    /// Represents the |𝑦〉 qubit that 𝑈 acts on.\n    operation ApplyParityOperation(\n        bitStringAsBoolArray : Bool[],\n        xRegister : Qubit[],\n        yQubit : Qubit\n    ) : Unit {\n        // `xRegister` muts have enough qubits to represent the integer.\n        let requiredBits = Length(bitStringAsBoolArray);\n        let availableQubits = Length(xRegister);\n        Fact(\n            availableQubits >= requiredBits,\n            $\"The bitstring has {requiredBits} bits but the quantum register \" + $\"only has {availableQubits} qubits\"\n        );\n\n        // Apply the quantum operations that encode the bit string.\n        for (index, bit) in Enumerated(bitStringAsBoolArray) {\n            if bit {\n                CNOT(xRegister[index], yQubit);\n            }\n        }\n    }\n\n    /// # Summary\n    /// This is a higher-order operation which returns an operation (Qubit[], Qubit) => () of the form\n    /// U_f |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n    /// We define 𝑓 by providing the bit string 𝑟⃗ as an integer.\n    function EncodeBitStringAsParityOperation(bitStringAsBoolArray : Bool[]) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsBoolArray, _, _);\n    }\n\n    /// # Summary\n    /// Returns a particular bit string as an array of Booleans.\n    function SecretBitStringAsBoolArray() : Bool[] {\n        return [true, false, true, false, true];\n    }\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.\nnamespace Sample {\n    import Std.Arrays.*;\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Consider a function 𝑓(𝑥⃗) on bitstrings 𝑥⃗ = (𝑥₀, …, 𝑥ₙ₋₁) of the form\n        //     𝑓(𝑥⃗) ≔ Σᵢ 𝑥ᵢ 𝑟ᵢ\n        // where 𝑟⃗ = (𝑟₀, …, 𝑟ₙ₋₁) is an unknown bit string that determines the\n        // parity of 𝑓.\n\n        // The Bernstein–Vazirani algorithm allows determining 𝑟 given a\n        // quantum operation that implements\n        //     |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n\n        // This entry point function of this program, `Main`, shows how to use\n        // the `BernsteinVazirani` operation to determine the value of bitstring\n        // 𝑟.\n        let secretBitString = SecretBitStringAsBoolArray();\n        let parityOperation = EncodeBitStringAsParityOperation(secretBitString);\n        let decodedBitString = BernsteinVazirani(\n            parityOperation,\n            Length(secretBitString)\n        );\n\n        return decodedBitString;\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)\n    operation BernsteinVazirani(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n        // We allocate n + 1 clean qubits. Note that the function parameter 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 a relative phase is\n        // introduced when we apply a Hadamard gate later on and we can use\n        // phase kickback 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 the last one. We could also\n            // transform the last qubit, 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 bit string 𝑟⃗ = (r₀, …, rₙ₋₁), represented as an array of Booleans,\n    /// this operation applies a unitary 𝑈 that acts on 𝑛 + 1 qubits as:\n    ///     𝑈 |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉\n    /// where 𝑓(𝑥) = Σᵢ 𝑥ᵢ 𝑟ᵢ mod 2.\n    ///\n    /// # Input\n    /// ## bitStringAsBoolArray\n    /// A bit string 𝑟⃗, represented as an array of Booleans, used to define the\n    /// function 𝑓.\n    /// ## xRegister\n    /// Represents the |𝑥〉 register that 𝑈 acts on.\n    /// ## yQubit\n    /// Represents the |𝑦〉 qubit that 𝑈 acts on.\n    operation ApplyParityOperation(\n        bitStringAsBoolArray : Bool[],\n        xRegister : Qubit[],\n        yQubit : Qubit\n    ) : Unit {\n        // `xRegister` muts have enough qubits to represent the integer.\n        let requiredBits = Length(bitStringAsBoolArray);\n        let availableQubits = Length(xRegister);\n        Fact(\n            availableQubits >= requiredBits,\n            $\"The bitstring has {requiredBits} bits but the quantum register \" + $\"only has {availableQubits} qubits\"\n        );\n\n        // Apply the quantum operations that encode the bit string.\n        for (index, bit) in Enumerated(bitStringAsBoolArray) {\n            if bit {\n                CNOT(xRegister[index], yQubit);\n            }\n        }\n    }\n\n    /// # Summary\n    /// This is a higher-order operation which returns an operation (Qubit[], Qubit) => () of the form\n    /// U_f |𝑥〉|𝑦〉 = |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉.\n    /// We define 𝑓 by providing the bit string 𝑟⃗ as an integer.\n    function EncodeBitStringAsParityOperation(bitStringAsBoolArray : Bool[]) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsBoolArray, _, _);\n    }\n\n    /// # Summary\n    /// Returns a particular bit string as an array of Booleans.\n    function SecretBitStringAsBoolArray() : Bool[] {\n        return [true, false, true, false, true];\n    }\n}\n"
     },
     {
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation 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)\n    operation 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.\n    operation 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.\n    function EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsInt, _, _);\n    }\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.\nnamespace Sample {\n    import Std.Arrays.*;\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation 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)\n    operation 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.\n    operation 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.\n    function EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsInt, _, _);\n    }\n}\n"
     },
     {
         "title": "Grover's search",
         "shots": 100,
-        "code": "/// # Sample\n/// Grover's search algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Diagnostics;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        let nQubits = 5;\n\n        // Grover's algorithm relies on performing a \"Grover iteration\" an\n        // optimal number of times to maximize the probability of finding the\n        // value we are searching for.\n        // You can set the number iterations to a value lower than optimal to\n        // intentionally reduce precision.\n        let iterations = CalculateOptimalIterations(nQubits);\n        Message($\"Number of iterations: {iterations}\");\n\n        // Use Grover's algorithm to find a particular marked state.\n        let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);\n        return results;\n    }\n\n    /// # Summary\n    /// Implements Grover's algorithm, which searches all possible inputs to an\n    /// operation to find a particular marked state.\n    operation GroverSearch(\n        nQubits : Int,\n        iterations : Int,\n        phaseOracle : Qubit[] => Unit\n    ) : Result[] {\n\n        use qubits = Qubit[nQubits];\n\n        // Initialize a uniform superposition over all possible inputs.\n        PrepareUniform(qubits);\n\n        // The search itself consists of repeatedly reflecting about the marked\n        // state and our start state, which we can write out in Q# as a for loop.\n        for _ in 1..iterations {\n            phaseOracle(qubits);\n            ReflectAboutUniform(qubits);\n        }\n\n        // Measure and return the answer.\n        return MResetEachZ(qubits);\n    }\n\n    /// # Summary\n    /// Returns the optimal number of Grover iterations needed to find a marked\n    /// item, given the number of qubits in a register.\n    function CalculateOptimalIterations(nQubits : Int) : Int {\n        if nQubits > 126 {\n            fail \"This sample supports at most 126 qubits.\";\n        }\n\n        let nItems = 2.0^IntAsDouble(nQubits);\n        let angle = ArcSin(1. / Sqrt(nItems));\n        let iterations = Round(0.25 * PI() / angle - 0.5);\n        iterations\n    }\n\n    /// # Summary\n    /// Reflects about the basis state marked by alternating zeros and ones.\n    /// This operation defines what input we are trying to find in the search.\n    operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n        Message(\"Reflecting about marked state...\");\n        use outputQubit = Qubit();\n        within {\n            // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n            // toggling it results in a (-1) phase.\n            X(outputQubit);\n            H(outputQubit);\n            // Flip the outputQubit for marked states.\n            // Here, we get the state with alternating 0s and 1s by using the X\n            // operation on every other qubit.\n            for q in inputQubits[...2...] {\n                X(q);\n            }\n        } apply {\n            Controlled X(inputQubits, outputQubit);\n        }\n    }\n\n    /// # Summary\n    /// Given a register in the all-zeros state, prepares a uniform\n    /// superposition over all basis states.\n    operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n        for q in inputQubits {\n            H(q);\n        }\n    }\n\n    /// # Summary\n    /// Reflects about the all-ones state.\n    operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n        Controlled Z(Most(inputQubits), Tail(inputQubits));\n    }\n\n    /// # Summary\n    /// Reflects about the uniform superposition state.\n    operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n        within {\n            // Transform the uniform superposition to all-zero.\n            Adjoint PrepareUniform(inputQubits);\n            // Transform the all-zero state to all-ones\n            for q in inputQubits {\n                X(q);\n            }\n        } apply {\n            // Now that we've transformed the uniform superposition to the\n            // all-ones state, reflect about the all-ones state, then let the\n            // within/apply block transform us back.\n            ReflectAboutAllOnes(inputQubits);\n        }\n    }\n}\n"
+        "code": "/// # Sample\n/// Grover's search algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm.\nnamespace Sample {\n    import Std.Convert.*;\n    import Std.Math.*;\n    import Std.Arrays.*;\n    import Std.Measurement.*;\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        let nQubits = 5;\n\n        // Grover's algorithm relies on performing a \"Grover iteration\" an\n        // optimal number of times to maximize the probability of finding the\n        // value we are searching for.\n        // You can set the number iterations to a value lower than optimal to\n        // intentionally reduce precision.\n        let iterations = CalculateOptimalIterations(nQubits);\n        Message($\"Number of iterations: {iterations}\");\n\n        // Use Grover's algorithm to find a particular marked state.\n        let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);\n        return results;\n    }\n\n    /// # Summary\n    /// Implements Grover's algorithm, which searches all possible inputs to an\n    /// operation to find a particular marked state.\n    operation GroverSearch(\n        nQubits : Int,\n        iterations : Int,\n        phaseOracle : Qubit[] => Unit\n    ) : Result[] {\n\n        use qubits = Qubit[nQubits];\n\n        // Initialize a uniform superposition over all possible inputs.\n        PrepareUniform(qubits);\n\n        // The search itself consists of repeatedly reflecting about the marked\n        // state and our start state, which we can write out in Q# as a for loop.\n        for _ in 1..iterations {\n            phaseOracle(qubits);\n            ReflectAboutUniform(qubits);\n        }\n\n        // Measure and return the answer.\n        return MResetEachZ(qubits);\n    }\n\n    /// # Summary\n    /// Returns the optimal number of Grover iterations needed to find a marked\n    /// item, given the number of qubits in a register.\n    function CalculateOptimalIterations(nQubits : Int) : Int {\n        if nQubits > 126 {\n            fail \"This sample supports at most 126 qubits.\";\n        }\n\n        let nItems = 2.0^IntAsDouble(nQubits);\n        let angle = ArcSin(1. / Sqrt(nItems));\n        let iterations = Round(0.25 * PI() / angle - 0.5);\n        iterations\n    }\n\n    /// # Summary\n    /// Reflects about the basis state marked by alternating zeros and ones.\n    /// This operation defines what input we are trying to find in the search.\n    operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n        Message(\"Reflecting about marked state...\");\n        use outputQubit = Qubit();\n        within {\n            // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n            // toggling it results in a (-1) phase.\n            X(outputQubit);\n            H(outputQubit);\n            // Flip the outputQubit for marked states.\n            // Here, we get the state with alternating 0s and 1s by using the X\n            // operation on every other qubit.\n            for q in inputQubits[...2...] {\n                X(q);\n            }\n        } apply {\n            Controlled X(inputQubits, outputQubit);\n        }\n    }\n\n    /// # Summary\n    /// Given a register in the all-zeros state, prepares a uniform\n    /// superposition over all basis states.\n    operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n        for q in inputQubits {\n            H(q);\n        }\n    }\n\n    /// # Summary\n    /// Reflects about the all-ones state.\n    operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n        Controlled Z(Most(inputQubits), Tail(inputQubits));\n    }\n\n    /// # Summary\n    /// Reflects about the uniform superposition state.\n    operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n        within {\n            // Transform the uniform superposition to all-zero.\n            Adjoint PrepareUniform(inputQubits);\n            // Transform the all-zero state to all-ones\n            for q in inputQubits {\n                X(q);\n            }\n        } apply {\n            // Now that we've transformed the uniform superposition to the\n            // all-ones state, reflect about the all-ones state, then let the\n            // within/apply block transform us back.\n            ReflectAboutAllOnes(inputQubits);\n        }\n    }\n}\n"
     },
     {
         "title": "Hidden Shift",
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : Result[] {\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 encoded in the following array of\n        // Booleans.\n        let shiftAsBoolArray = [true, false, false, false, false, true];\n        let shiftAsInt = BoolArrayAsInt(shiftAsBoolArray);\n        let hiddenShiftBitString = FindHiddenShift(\n            BentFunction,\n            register => ShiftedBentFunction(shiftAsInt, register),\n            Length(shiftAsBoolArray)\n        );\n\n        return hiddenShiftBitString;\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)\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    import Std.Arrays.*;\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation Main() : Result[] {\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 encoded in the following array of\n        // Booleans.\n        let shiftAsBoolArray = [true, false, false, false, false, true];\n        let shiftAsInt = BoolArrayAsInt(shiftAsBoolArray);\n        let hiddenShiftBitString = FindHiddenShift(\n            BentFunction,\n            register => ShiftedBentFunction(shiftAsInt, register),\n            Length(shiftAsBoolArray)\n        );\n\n        return hiddenShiftBitString;\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)\n    operation 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.\n    operation 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.\n    operation 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}\n"
     },
     {
         "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.\nnamespace Sample {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation 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)\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    import Std.Arrays.*;\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Measurement.*;\n\n    @EntryPoint()\n    operation 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)\n    operation 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.\n    operation 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.\n    operation 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}\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.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.Arrays;\n\n    @EntryPoint()\n    operation Main() : (Int, Int) {\n        let n = 143; // 11*13;\n        // You can try these other examples for a lengthier computation.\n        // let n = 16837; // = 113*149\n        // let n = 22499; // = 149*151\n\n        // Use Shor's algorithm to factor a semiprime integer.\n        let (a, b) = FactorSemiprimeInteger(n);\n        Message($\"Found factorization {n} = {a} * {b}\");\n        return (a, b);\n    }\n\n    /// # Summary\n    /// Uses Shor's algorithm to factor an input number.\n    ///\n    /// # Input\n    /// ## number\n    /// A semiprime integer to be factored.\n    ///\n    /// # Output\n    /// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\n    operation 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`.\n    function 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.\n    function 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`\n    operation 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.\n    operation 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`.\n    internal 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\n    internal 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\n    internal 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}\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.\nnamespace Sample {\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Random.*;\n    import Std.Math.*;\n    import Microsoft.Quantum.Unstable.Arithmetic.*;\n    import Std.Arrays.*;\n\n    @EntryPoint()\n    operation Main() : (Int, Int) {\n        let n = 143; // 11*13;\n        // You can try these other examples for a lengthier computation.\n        // let n = 16837; // = 113*149\n        // let n = 22499; // = 149*151\n\n        // Use Shor's algorithm to factor a semiprime integer.\n        let (a, b) = FactorSemiprimeInteger(n);\n        Message($\"Found factorization {n} = {a} * {b}\");\n        return (a, b);\n    }\n\n    /// # Summary\n    /// Uses Shor's algorithm to factor an input number.\n    ///\n    /// # Input\n    /// ## number\n    /// A semiprime integer to be factored.\n    ///\n    /// # Output\n    /// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\n    operation 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`.\n    function 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.\n    function 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`\n    operation 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.\n    operation 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`.\n    internal 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\n    internal 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\n    internal 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}\n"
     },
     {
         "title": "Dynamics (Resource Estimation)",
         "shots": 1,
-        "code": "/// # Sample\n/// Quantum Dynamics\n///\n/// # Description\n/// This example demonstrates quantum dynamics in a style tailored for\n/// resource estimation. The sample is specifically the simulation\n/// of an Ising model Hamiltonian on an N1xN2 2D lattice using a\n/// fourth-order Trotter Suzuki product formula, assuming\n/// a 2D qubit architecture with nearest-neighbor connectivity.\n/// The is an example of a program that is not amenable to simulating\n/// classically, but can be run through resource estimation to determine\n/// what size of quantum system would be needed to solve the problem.\nnamespace QuantumDynamics {\n\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n\n\n    @EntryPoint()\n    operation Main() : Unit {\n        // n : Int, m : Int, t: Double, u : Double, tstep : Double\n\n        let n = 10;\n        let m = 10;\n\n        let J = 1.0;\n        let g = 1.0;\n\n        let totTime = 30.0;\n        let dt = 0.9;\n\n        IsingModel2DSim(n, m, J, g, totTime, dt);\n    }\n\n    /// # Summary\n    /// The function below creates a sequence containing the rotation angles that will be applied with the two operators used in the expansion of the Trotter-Suzuki formula.\n    /// # Input\n    /// ## p (Double) : Constant used for fourth-order formulas\n    ///\n    /// ## dt (Double) : Time-step used to compute rotation angles\n    ///\n    /// ## J (Double) : coefficient for 2-qubit interactions\n    ///\n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// # Output\n    /// ## values (Double[]) : The list of rotation angles to be applies in sequence with the corresponding operators\n    ///\n    function SetAngleSequence(p : Double, dt : Double, J : Double, g : Double) : Double[] {\n\n        let len1 = 3;\n        let len2 = 3;\n        let valLength = 2 * len1 + len2 + 1;\n        mutable values = [0.0, size = valLength];\n\n        let val1 = J * p * dt;\n        let val2 = -g * p * dt;\n        let val3 = J * (1.0 - 3.0 * p) * dt / 2.0;\n        let val4 = g * (1.0 - 4.0 * p) * dt / 2.0;\n\n        for i in 0..len1 {\n\n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            } else {\n                set values w/= i <- val2;\n            }\n\n        }\n\n        for i in len1 + 1..len1 + len2 {\n            if (i % 2 == 0) {\n                set values w/= i <- val3;\n            } else {\n                set values w/= i <- val4;\n            }\n        }\n\n        for i in len1 + len2 + 1..valLength - 1 {\n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            } else {\n                set values w/= i <- val2;\n            }\n        }\n        return values;\n    }\n\n    /// # Summary\n    /// Applies e^-iX(theta) on all qubits in the 2D lattice as part of simulating the transverse field in the Ising model\n    /// # Input\n    /// ## n (Int) : Lattice size for an n x n lattice\n    ///\n    /// ## qArr (Qubit[][]) : Array of qubits representing the lattice\n    ///\n    /// ## theta (Double) : The angle/time-step for which the unitary simulation is done.\n    ///\n    operation ApplyAllX(n : Int, qArr : Qubit[][], theta : Double) : Unit {\n        // This applies `Rx` with an angle of `2.0 * theta` to all qubits in `qs`\n        // using partial application\n        for row in 0..n - 1 {\n            ApplyToEach(Rx(2.0 * theta, _), qArr[row]);\n        }\n    }\n\n    /// # Summary\n    /// Applies e^-iP(theta) where P = Z o Z as part of the repulsion terms.\n    /// # Input\n    /// ## n, m (Int, Int) : Lattice sizes for an n x m lattice\n    ///\n    /// ## qArr (Qubit[]) : Array of qubits representing the lattice\n    ///\n    /// ## theta (Double) : The angle/time-step for which unitary simulation is done.\n    ///\n    /// ## dir (Bool) : Direction is true for vertical direction.\n    ///\n    /// ## grp (Bool) : Group is true for odd starting indices\n    ///\n    operation ApplyDoubleZ(n : Int, m : Int, qArr : Qubit[][], theta : Double, dir : Bool, grp : Bool) : Unit {\n        let start = grp ? 1 | 0;    // Choose either odd or even indices based on group number\n        let P_op = [PauliZ, PauliZ];\n        let c_end = dir ? m - 1 | m - 2;\n        let r_end = dir ? m - 2 | m - 1;\n\n        for row in 0..r_end {\n            for col in start..2..c_end {\n                // Iterate through even or odd columns based on `grp`\n\n                let row2 = dir ? row + 1 | row;\n                let col2 = dir ? col | col + 1;\n\n                Exp(P_op, theta, [qArr[row][col], qArr[row2][col2]]);\n            }\n        }\n    }\n\n    /// # Summary\n    /// The main function that takes in various parameters and calls the operations needed to simulate fourth order Trotterizatiuon of the Ising Hamiltonian for a given time-step\n    /// # Input\n    /// ## N1, N2 (Int, Int) : Lattice sizes for an N1 x N2 lattice\n    ///\n    /// ## J (Double) : coefficient for 2-qubit interactions\n    ///\n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// ## totTime (Double) : The total time-step for which unitary simulation is done.\n    ///\n    /// ## dt (Double) : The time the simulation is done for each timestep\n    ///\n    operation IsingModel2DSim(N1 : Int, N2 : Int, J : Double, g : Double, totTime : Double, dt : Double) : Unit {\n\n        use qs = Qubit[N1 * N2];\n        let qubitArray = Chunks(N2, qs); // qubits are re-arranged to be in an N1 x N2 array\n\n        let p = 1.0 / (4.0 - 4.0^(1.0 / 3.0));\n        let t = Ceiling(totTime / dt);\n\n        let seqLen = 10 * t + 1;\n\n        let angSeq = SetAngleSequence(p, dt, J, g);\n\n        for i in 0..seqLen - 1 {\n            let theta = (i == 0 or i == seqLen - 1) ? J * p * dt / 2.0 | angSeq[i % 10];\n\n            // for even indexes\n            if i % 2 == 0 {\n                ApplyAllX(N1, qubitArray, theta);\n            } else {\n                // iterate through all possible combinations for `dir` and `grp`.\n                for (dir, grp) in [(true, true), (true, false), (false, true), (false, false)] {\n                    ApplyDoubleZ(N1, N2, qubitArray, theta, dir, grp);\n                }\n            }\n        }\n    }\n\n}\n",
+        "code": "/// # Sample\n/// Quantum Dynamics\n///\n/// # Description\n/// This example demonstrates quantum dynamics in a style tailored for\n/// resource estimation. The sample is specifically the simulation\n/// of an Ising model Hamiltonian on an N1xN2 2D lattice using a\n/// fourth-order Trotter Suzuki product formula, assuming\n/// a 2D qubit architecture with nearest-neighbor connectivity.\n/// The is an example of a program that is not amenable to simulating\n/// classically, but can be run through resource estimation to determine\n/// what size of quantum system would be needed to solve the problem.\nnamespace QuantumDynamics {\n\n    import Std.Math.*;\n    import Std.Arrays.*;\n\n\n    @EntryPoint()\n    operation Main() : Unit {\n        // n : Int, m : Int, t: Double, u : Double, tstep : Double\n\n        let n = 10;\n        let m = 10;\n\n        let J = 1.0;\n        let g = 1.0;\n\n        let totTime = 30.0;\n        let dt = 0.9;\n\n        IsingModel2DSim(n, m, J, g, totTime, dt);\n    }\n\n    /// # Summary\n    /// The function below creates a sequence containing the rotation angles that will be applied with the two operators used in the expansion of the Trotter-Suzuki formula.\n    /// # Input\n    /// ## p (Double) : Constant used for fourth-order formulas\n    ///\n    /// ## dt (Double) : Time-step used to compute rotation angles\n    ///\n    /// ## J (Double) : coefficient for 2-qubit interactions\n    ///\n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// # Output\n    /// ## values (Double[]) : The list of rotation angles to be applies in sequence with the corresponding operators\n    ///\n    function SetAngleSequence(p : Double, dt : Double, J : Double, g : Double) : Double[] {\n\n        let len1 = 3;\n        let len2 = 3;\n        let valLength = 2 * len1 + len2 + 1;\n        mutable values = [0.0, size = valLength];\n\n        let val1 = J * p * dt;\n        let val2 = -g * p * dt;\n        let val3 = J * (1.0 - 3.0 * p) * dt / 2.0;\n        let val4 = g * (1.0 - 4.0 * p) * dt / 2.0;\n\n        for i in 0..len1 {\n\n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            } else {\n                set values w/= i <- val2;\n            }\n\n        }\n\n        for i in len1 + 1..len1 + len2 {\n            if (i % 2 == 0) {\n                set values w/= i <- val3;\n            } else {\n                set values w/= i <- val4;\n            }\n        }\n\n        for i in len1 + len2 + 1..valLength - 1 {\n            if (i % 2 == 0) {\n                set values w/= i <- val1;\n            } else {\n                set values w/= i <- val2;\n            }\n        }\n        return values;\n    }\n\n    /// # Summary\n    /// Applies e^-iX(theta) on all qubits in the 2D lattice as part of simulating the transverse field in the Ising model\n    /// # Input\n    /// ## n (Int) : Lattice size for an n x n lattice\n    ///\n    /// ## qArr (Qubit[][]) : Array of qubits representing the lattice\n    ///\n    /// ## theta (Double) : The angle/time-step for which the unitary simulation is done.\n    ///\n    operation ApplyAllX(n : Int, qArr : Qubit[][], theta : Double) : Unit {\n        // This applies `Rx` with an angle of `2.0 * theta` to all qubits in `qs`\n        // using partial application\n        for row in 0..n - 1 {\n            ApplyToEach(Rx(2.0 * theta, _), qArr[row]);\n        }\n    }\n\n    /// # Summary\n    /// Applies e^-iP(theta) where P = Z o Z as part of the repulsion terms.\n    /// # Input\n    /// ## n, m (Int, Int) : Lattice sizes for an n x m lattice\n    ///\n    /// ## qArr (Qubit[]) : Array of qubits representing the lattice\n    ///\n    /// ## theta (Double) : The angle/time-step for which unitary simulation is done.\n    ///\n    /// ## dir (Bool) : Direction is true for vertical direction.\n    ///\n    /// ## grp (Bool) : Group is true for odd starting indices\n    ///\n    operation ApplyDoubleZ(n : Int, m : Int, qArr : Qubit[][], theta : Double, dir : Bool, grp : Bool) : Unit {\n        let start = grp ? 1 | 0;    // Choose either odd or even indices based on group number\n        let P_op = [PauliZ, PauliZ];\n        let c_end = dir ? m - 1 | m - 2;\n        let r_end = dir ? m - 2 | m - 1;\n\n        for row in 0..r_end {\n            for col in start..2..c_end {\n                // Iterate through even or odd columns based on `grp`\n\n                let row2 = dir ? row + 1 | row;\n                let col2 = dir ? col | col + 1;\n\n                Exp(P_op, theta, [qArr[row][col], qArr[row2][col2]]);\n            }\n        }\n    }\n\n    /// # Summary\n    /// The main function that takes in various parameters and calls the operations needed to simulate fourth order Trotterizatiuon of the Ising Hamiltonian for a given time-step\n    /// # Input\n    /// ## N1, N2 (Int, Int) : Lattice sizes for an N1 x N2 lattice\n    ///\n    /// ## J (Double) : coefficient for 2-qubit interactions\n    ///\n    /// ## g (Double) : coefficient for transverse field\n    ///\n    /// ## totTime (Double) : The total time-step for which unitary simulation is done.\n    ///\n    /// ## dt (Double) : The time the simulation is done for each timestep\n    ///\n    operation IsingModel2DSim(N1 : Int, N2 : Int, J : Double, g : Double, totTime : Double, dt : Double) : Unit {\n\n        use qs = Qubit[N1 * N2];\n        let qubitArray = Chunks(N2, qs); // qubits are re-arranged to be in an N1 x N2 array\n\n        let p = 1.0 / (4.0 - 4.0^(1.0 / 3.0));\n        let t = Ceiling(totTime / dt);\n\n        let seqLen = 10 * t + 1;\n\n        let angSeq = SetAngleSequence(p, dt, J, g);\n\n        for i in 0..seqLen - 1 {\n            let theta = (i == 0 or i == seqLen - 1) ? J * p * dt / 2.0 | angSeq[i % 10];\n\n            // for even indexes\n            if i % 2 == 0 {\n                ApplyAllX(N1, qubitArray, theta);\n            } else {\n                // iterate through all possible combinations for `dir` and `grp`.\n                for (dir, grp) in [(true, true), (true, false), (false, true), (false, false)] {\n                    ApplyDoubleZ(N1, N2, qubitArray, theta, dir, grp);\n                }\n            }\n        }\n    }\n\n}\n",
         "omitFromTests": true
     },
     {
         "title": "Precalculated (Resource Estimation)",
         "shots": 1,
-        "code": "/// # Sample\n/// Using pre-calculated logical counts for resource estimation\n///\n/// # Description\n/// This sample demonstrates how to use the `AccountForEstimates` function to\n/// estimate the resources required to run a factoring program from pre-calculated\n/// logical counts. The logical counts used in this sample are the ones obtained\n/// for a 2048-bit integer factoring application based on the implementation\n/// described in [[Quantum 5, 433 (2021)](https://quantum-journal.org/papers/q-2021-04-15-433/)].\n/// Our implementation incorporates all techniques described in the paper, except for\n/// carry runways.\nnamespace PrecalculatedEstimates {\n    open Microsoft.Quantum.ResourceEstimation;\n\n    @EntryPoint()\n    operation FactoringFromLogicalCounts() : Unit {\n        use qubits = Qubit[12581];\n\n        AccountForEstimates(\n            [TCount(12), RotationCount(12), RotationDepth(12), CczCount(3731607428), MeasurementCount(1078154040)],\n            PSSPCLayout(),\n            qubits\n        );\n    }\n\n}\n",
+        "code": "/// # Sample\n/// Using pre-calculated logical counts for resource estimation\n///\n/// # Description\n/// This sample demonstrates how to use the `AccountForEstimates` function to\n/// estimate the resources required to run a factoring program from pre-calculated\n/// logical counts. The logical counts used in this sample are the ones obtained\n/// for a 2048-bit integer factoring application based on the implementation\n/// described in [[Quantum 5, 433 (2021)](https://quantum-journal.org/papers/q-2021-04-15-433/)].\n/// Our implementation incorporates all techniques described in the paper, except for\n/// carry runways.\nnamespace PrecalculatedEstimates {\n    import Std.ResourceEstimation.*;\n\n    @EntryPoint()\n    operation FactoringFromLogicalCounts() : Unit {\n        use qubits = Qubit[12581];\n\n        AccountForEstimates(\n            [TCount(12), RotationCount(12), RotationDepth(12), CczCount(3731607428), MeasurementCount(1078154040)],\n            PSSPCLayout(),\n            qubits\n        );\n    }\n\n}\n",
         "omitFromTests": true
     },
     {
         "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.\nnamespace Shors {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Canon;\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.ResourceEstimation;\n\n    @EntryPoint()\n    operation RunProgram() : 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.\n    operation 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 Microsoft.Quantum.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`.\n    internal 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\n    internal 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\n    internal 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}\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.\nnamespace Shors {\n    import Std.Arrays.*;\n    import Std.Canon.*;\n    import Std.Convert.*;\n    import Std.Diagnostics.*;\n    import Std.Intrinsic.*;\n    import Std.Math.*;\n    import Std.Measurement.*;\n    import Microsoft.Quantum.Unstable.Arithmetic.*;\n    import Std.ResourceEstimation.*;\n\n    @EntryPoint()\n    operation RunProgram() : 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.\n    operation 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 Microsoft.Quantum.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`.\n    internal 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\n    internal 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\n    internal 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}\n",
         "omitFromTests": true
     }
 ];

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Core.IsRangeEmpty
 title: IsRangeEmpty function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Core.RangeEnd
 title: RangeEnd function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Core