qsharp-lang 1.0.25-dev → 1.0.26-rc

package/dist/samples.generated.js

@@ -62,7 +62,7 @@ export default [
     {
         "title": "Grover's search",
         "shots": 100,
-        "code": "/// # Sample\n/// Grover's search algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Diagnostics;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        let nQubits = 5;\n\n        // Grover's algorithm relies on performing a \"Grover iteration\" an\n        // optimal number of times to maximize the probability of finding the\n        // value we are searching for.\n        // You can set the number iterations to a value lower than optimal to\n        // intentionally reduce precision.\n        let iterations = CalculateOptimalIterations(nQubits);\n        Message($\"Number of iterations: {iterations}\");\n\n        // Use Grover's algorithm to find a particular marked state.\n        let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);\n        return results;\n    }\n\n    /// # Summary\n    /// Implements Grover's algorithm, which searches all possible inputs to an\n    /// operation to find a particular marked state.\n    operation GroverSearch(\n        nQubits : Int,\n        iterations : Int,\n        phaseOracle : Qubit[] => Unit) : Result[] {\n\n        use qubits = Qubit[nQubits];\n\n        // Initialize a uniform superposition over all possible inputs.\n        PrepareUniform(qubits);\n\n        // The search itself consists of repeatedly reflecting about the marked\n        // state and our start state, which we can write out in Q# as a for loop.\n        for _ in 1..iterations {\n            phaseOracle(qubits);\n            ReflectAboutUniform(qubits);\n        }\n\n        // Measure and return the answer.\n        return MResetEachZ(qubits);\n    }\n\n    /// # Summary\n    /// Returns the optimal number of Grover iterations needed to find a marked\n    /// item, given the number of qubits in a register.\n    function CalculateOptimalIterations(nQubits : Int) : Int {\n        let nItems = 1 <<< nQubits; // 2^nQubits\n        let angle = ArcSin(1. / Sqrt(IntAsDouble(nItems)));\n        let iterations = Round(0.25 * PI() / angle - 0.5);\n        return iterations;\n    }\n\n    /// # Summary\n    /// Reflects about the basis state marked by alternating zeros and ones.\n    /// This operation defines what input we are trying to find in the search.\n    operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n        Message(\"Reflecting about marked state...\");\n        use outputQubit = Qubit();\n        within {\n            // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n            // toggling it results in a (-1) phase.\n            X(outputQubit);\n            H(outputQubit);\n            // Flip the outputQubit for marked states.\n            // Here, we get the state with alternating 0s and 1s by using the X\n            // operation on every other qubit.\n            for q in inputQubits[...2...] {\n                X(q);\n            }\n        } apply {\n            Controlled X(inputQubits, outputQubit);\n        }\n    }\n\n    /// # Summary\n    /// Given a register in the all-zeros state, prepares a uniform\n    /// superposition over all basis states.\n    operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n        for q in inputQubits {\n            H(q);\n        }\n    }\n\n    /// # Summary\n    /// Reflects about the all-ones state.\n    operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n        Controlled Z(Most(inputQubits), Tail(inputQubits));\n    }\n\n    /// # Summary\n    /// Reflects about the uniform superposition state.\n    operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n        within {\n            // Transform the uniform superposition to all-zero.\n            Adjoint PrepareUniform(inputQubits);\n            // Transform the all-zero state to all-ones\n            for q in inputQubits {\n                X(q);\n            }\n        } apply {\n            // Now that we've transformed the uniform superposition to the\n            // all-ones state, reflect about the all-ones state, then let the\n            // within/apply block transform us back.\n            ReflectAboutAllOnes(inputQubits);\n        }\n    }\n}\n"
+        "code": "/// # Sample\n/// Grover's search algorithm\n///\n/// # Description\n/// Grover's search algorithm is a quantum algorithm that finds with high\n/// probability the unique input to a black box function that produces a\n/// particular output value.\n///\n/// This Q# program implements the Grover's search algorithm.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Measurement;\n    open Microsoft.Quantum.Diagnostics;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        let nQubits = 5;\n\n        // Grover's algorithm relies on performing a \"Grover iteration\" an\n        // optimal number of times to maximize the probability of finding the\n        // value we are searching for.\n        // You can set the number iterations to a value lower than optimal to\n        // intentionally reduce precision.\n        let iterations = CalculateOptimalIterations(nQubits);\n        Message($\"Number of iterations: {iterations}\");\n\n        // Use Grover's algorithm to find a particular marked state.\n        let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);\n        return results;\n    }\n\n    /// # Summary\n    /// Implements Grover's algorithm, which searches all possible inputs to an\n    /// operation to find a particular marked state.\n    operation GroverSearch(\n        nQubits : Int,\n        iterations : Int,\n        phaseOracle : Qubit[] => Unit) : Result[] {\n\n        use qubits = Qubit[nQubits];\n\n        // Initialize a uniform superposition over all possible inputs.\n        PrepareUniform(qubits);\n\n        // The search itself consists of repeatedly reflecting about the marked\n        // state and our start state, which we can write out in Q# as a for loop.\n        for _ in 1..iterations {\n            phaseOracle(qubits);\n            ReflectAboutUniform(qubits);\n        }\n\n        // Measure and return the answer.\n        return MResetEachZ(qubits);\n    }\n\n    /// # Summary\n    /// Returns the optimal number of Grover iterations needed to find a marked\n    /// item, given the number of qubits in a register.\n    function CalculateOptimalIterations(nQubits : Int) : Int {\n        if nQubits > 63 {\n            fail \"This sample supports at most 63 qubits.\";\n        }\n        let nItems = 1 <<< nQubits; // 2^nQubits\n        let angle = ArcSin(1. / Sqrt(IntAsDouble(nItems)));\n        let iterations = Round(0.25 * PI() / angle - 0.5);\n        return iterations;\n    }\n\n    /// # Summary\n    /// Reflects about the basis state marked by alternating zeros and ones.\n    /// This operation defines what input we are trying to find in the search.\n    operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {\n        Message(\"Reflecting about marked state...\");\n        use outputQubit = Qubit();\n        within {\n            // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that\n            // toggling it results in a (-1) phase.\n            X(outputQubit);\n            H(outputQubit);\n            // Flip the outputQubit for marked states.\n            // Here, we get the state with alternating 0s and 1s by using the X\n            // operation on every other qubit.\n            for q in inputQubits[...2...] {\n                X(q);\n            }\n        } apply {\n            Controlled X(inputQubits, outputQubit);\n        }\n    }\n\n    /// # Summary\n    /// Given a register in the all-zeros state, prepares a uniform\n    /// superposition over all basis states.\n    operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {\n        for q in inputQubits {\n            H(q);\n        }\n    }\n\n    /// # Summary\n    /// Reflects about the all-ones state.\n    operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {\n        Controlled Z(Most(inputQubits), Tail(inputQubits));\n    }\n\n    /// # Summary\n    /// Reflects about the uniform superposition state.\n    operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n        within {\n            // Transform the uniform superposition to all-zero.\n            Adjoint PrepareUniform(inputQubits);\n            // Transform the all-zero state to all-ones\n            for q in inputQubits {\n                X(q);\n            }\n        } apply {\n            // Now that we've transformed the uniform superposition to the\n            // all-ones state, reflect about the all-ones state, then let the\n            // within/apply block transform us back.\n            ReflectAboutAllOnes(inputQubits);\n        }\n    }\n}\n"
     },
     {
         "title": "Hidden Shift",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qsharp-lang",
   "description": "qsharp language package for quantum development",
-  "version": "1.0.25-dev",
+  "version": "1.0.26-rc",
   "license": "MIT",
   "engines": {
     "node": ">=16.17.0"