qsharp-lang 1.8.1-dev → 1.8.2-dev

package/dist/language-service/worker-browser.d.ts

@@ -1 +1 @@
-export declare const messageHandler: (e: MessageEvent<any>) => void;
+export declare const messageHandler: (e: MessageEvent) => void;

package/dist/samples.generated.js

@@ -2,7 +2,7 @@ export default [
     {
         "title": "Minimal",
         "shots": 100,
-        "code": "/// # Sample\n/// Getting started\n///\n/// # Description\n/// This is a minimal Q# program that can be used to start writing Q# code.\noperation Main() : Unit {\n    // TODO: Write your Q# code here.\n}\n"
+        "code": "// # Sample\n// Getting started\n//\n// # Description\n// This is a minimal Q# program that can be used to start writing Q# code.\n\noperation Main() : Unit {\n    // TODO: Write your Q# code here.\n}\n"
     },
     {
         "title": "Superposition",
@@ -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 = 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"
+        "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"
     },
     {
         "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    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    function EncodeIntegerAsParityOperation(bitStringAsInt : Int) : (Qubit[], Qubit) => Unit {\n        return ApplyParityOperation(bitStringAsInt, _, _);\n    }\n}\n"
     },
     {
         "title": "Grover's search",

package/dist/workers/common.js

@@ -54,7 +54,6 @@ export function createProxyInternal(postMessage, terminator, methods) {
         if (curr)
             return;
         while ((curr = queue.shift())) {
-            // eslint-disable-line no-cond-assign
             if (curr.cancellationToken?.isCancellationRequested) {
                 curr.reject("cancelled");
                 continue;
@@ -262,7 +261,7 @@ export function initService(postMessage, serviceProtocol, wasm, qscLogLevel) {
             // Test if this is the case.
             structuredClone(args);
         }
-        catch (e) {
+        catch {
             // Uncloneable object.
             // Use String(args) instead of ${args} to handle all possible values
             // without throwing. See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion

package/dist/workers/node.js

@@ -15,7 +15,7 @@ import { createProxyInternal, initService, } from "./common.js";
 export function createWorker(protocol) {
     if (isMainThread)
         throw "Worker script should be loaded in a Worker thread only";
-    const port = parentPort; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    const port = parentPort;
     const postMessage = port.postMessage.bind(port);
     const invokeService = initService(postMessage, protocol, wasm, // Need to cast due to difference in web and node wasm types
     workerData && typeof workerData.qscLogLevel === "number"

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

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.All
 title: All function
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/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: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

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

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

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

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

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

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

package/docs/Microsoft.Quantum.Canon/ApplyCNOTChain.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Canon.ApplyCNOTChain
 title: ApplyCNOTChain operation
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Canon

package/docs/Microsoft.Quantum.Canon/ApplyControlledOnBitString.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Canon.ApplyControlledOnBitString
 title: ApplyControlledOnBitString operation
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Canon

package/docs/Microsoft.Quantum.Canon/ApplyControlledOnInt.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Canon.ApplyControlledOnInt
 title: ApplyControlledOnInt operation
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Canon

package/docs/Microsoft.Quantum.Canon/ApplyP.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Canon.ApplyP
 title: ApplyP operation
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Canon

package/docs/Microsoft.Quantum.Canon/ApplyPauli.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Canon.ApplyPauli
 title: ApplyPauli operation
-ms.date: 08/21/2024 12:00:00 AM
+ms.date: 09/10/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Canon