qsharp-lang 1.4.1-dev → 1.4.3-dev

package/dist/samples.generated.js

@@ -17,7 +17,7 @@ export default [
     {
         "title": "Bell States",
         "shots": 100,
-        "code": "/// # Sample\n/// Bell States\n///\n/// # Description\n/// Bell states or EPR pairs are specific quantum states of two qubits\n/// that represent the simplest (and maximal) examples of quantum entanglement.\n///\n/// This Q# program implements the four different Bell states.\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    operation PreparePhiPlus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 + |11〉)\n    }\n\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    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    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    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"
     },
     {
         "title": "Teleportation",
@@ -52,12 +52,12 @@ export default [
     {
         "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 = ForEach(MResetZ, 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    operation 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    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    operation 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 = ForEach(MResetZ, 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    operation 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    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    operation EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsInt, _, _);\n    }\n}\n"
     },
     {
         "title": "Grover's search",
@@ -67,12 +67,12 @@ export default [
     {
         "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 ForEach(MResetZ, 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    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"
     },
     {
         "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            Fact(\n                hiddenShift == shift,\n                $\"Found shift {hiddenShift}, but expected {shift}.\"\n            );\n            Message($\"Found {shift} successfully!\");\n            set hiddenShifts += [hiddenShift];\n        }\n\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 ForEach(MResetZ, 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    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            Fact(\n                hiddenShift == shift,\n                $\"Found shift {hiddenShift}, but expected {shift}.\"\n            );\n            Message($\"Found {shift} successfully!\");\n            set hiddenShifts += [hiddenShift];\n        }\n\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",

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.DrawMany
 title: DrawMany operation
-ms.date: 05/06/2024 12:00:00 AM
+ms.date: 05/15/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ForEach
 title: ForEach operation
-ms.date: 05/06/2024 12:00:00 AM
+ms.date: 05/15/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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