qsharp-lang 1.0.26-rc → 1.0.27-dev

package/dist/samples.generated.js

@@ -42,7 +42,7 @@ export default [
     {
         "title": "Deutsch-Jozsa",
         "shots": 1,
-        "code": "/// # Sample\n/// Deutsch–Jozsa algorithm\n///\n/// # Description\n/// Deutsch–Jozsa is a quantum algorithm that determines whether a given Boolean\n/// function 𝑓 is constant (0 on all inputs or 1 on all inputs) or balanced\n/// (1 for exactly half of the input domain and 0 for the other half).\n///\n/// This Q# program implements the Deutsch–Jozsa algorithm.\nnamespace Sample {\n\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : (Result[], Result[]) {\n        // A Boolean function is a function that maps bitstrings to a bit:\n        //     𝑓 : {0, 1}^n → {0, 1}.\n\n        // We say that 𝑓 is constant if 𝑓(𝑥⃗) = 𝑓(𝑦⃗) for all bitstrings 𝑥⃗ and\n        // 𝑦⃗, and that 𝑓 is balanced if 𝑓 evaluates to true for exactly half of\n        // its inputs.\n\n        // If we are given a function 𝑓 as a quantum operation 𝑈 |𝑥〉|𝑦〉 =\n        // |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, and are promised that 𝑓 is either constant or is\n        // balanced, then the Deutsch–Jozsa algorithm decides between these\n        // cases with a single application of 𝑈.\n\n        // Here, we demonstrate the use of the Deutsch-Jozsa algorithm by\n        // determining the type (constant or balanced) of a couple of functions.\n        let balancedResults = DeutschJozsa(SimpleBalancedBoolF, 5);\n        let constantResults = DeutschJozsa(SimpleConstantBoolF, 5);\n        return (balancedResults, constantResults);\n    }\n\n    /// # Summary\n    /// This operation implements the DeutschJozsa algorithm.\n    /// It returns the query register measurement results. If all the measurement\n    /// results are `Zero`, the function is constant. If at least one measurement\n    /// result is `One`, the function is balanced.\n    /// It is assumed that the function is either constant or balanced.\n    ///\n    /// # Input\n    /// ## Uf\n    /// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, where 𝑓 is a\n    /// Boolean function, 𝑥 is an 𝑛 bit register and 𝑦 is a single qubit.\n    /// ## n\n    /// The number of bits in the input register |𝑥〉.\n    ///\n    /// # Output\n    /// An array of measurement results for the query reguster.\n    /// All `Zero` measurement results indicate that the function is constant.\n    /// At least one `One` measurement result in the array indicates that the\n    /// function is balanced.\n    ///\n    /// # See Also\n    /// - For details see Section 1.4.3 of Nielsen & Chuang.\n    ///\n    /// # References\n    /// - [ *Michael A. Nielsen , Isaac L. Chuang*,\n    ///     Quantum Computation and Quantum Information ]\n    /// (http://doi.org/10.1017/CBO9780511976667)\n    operation DeutschJozsa(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n        // We allocate n + 1 clean qubits. Note that the function `Uf` is defined\n        // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n        use queryRegister = Qubit[n];\n        use target = Qubit();\n\n        // The last qubit needs to be flipped so that the function will actually\n        // be computed into the phase when Uf is applied.\n        X(target);\n\n        // Now, a Hadamard transform is applied to each of the qubits.\n        H(target);\n        // We use a within-apply block to ensure that the Hadamard transform is\n        // correctly inverted on the |𝑥〉 register.\n        within {\n            for q in queryRegister {\n                H(q);\n            }\n        } apply {\n            // We apply Uf to the n+1 qubits, computing |𝑥, 𝑦〉 ↦ |𝑥, 𝑦 ⊕ 𝑓(𝑥)〉.\n            Uf(queryRegister, target);\n        }\n\n        // Measure the query register and reset all qubits so they can be safely\n        // deallocated.\n        let results = MeasureEachZ(queryRegister);\n        ResetAll(queryRegister);\n        Reset(target);\n        return results;\n    }\n\n    // Simple constant Boolean function\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n        CX(args[0], target);\n    }\n}\n\n"
+        "code": "/// # Sample\n/// Deutsch–Jozsa algorithm\n///\n/// # Description\n/// Deutsch–Jozsa is a quantum algorithm that determines whether a given Boolean\n/// function 𝑓 is constant (0 on all inputs or 1 on all inputs) or balanced\n/// (1 for exactly half of the input domain and 0 for the other half).\n///\n/// This Q# program implements the Deutsch–Jozsa algorithm.\nnamespace Sample {\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : (Result[], Result[]) {\n        // A Boolean function is a function that maps bitstrings to a bit:\n        //     𝑓 : {0, 1}^n → {0, 1}.\n\n        // We say that 𝑓 is constant if 𝑓(𝑥⃗) = 𝑓(𝑦⃗) for all bitstrings 𝑥⃗ and\n        // 𝑦⃗, and that 𝑓 is balanced if 𝑓 evaluates to true for exactly half of\n        // its inputs.\n\n        // If we are given a function 𝑓 as a quantum operation 𝑈 |𝑥〉|𝑦〉 =\n        // |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, and are promised that 𝑓 is either constant or is\n        // balanced, then the Deutsch–Jozsa algorithm decides between these\n        // cases with a single application of 𝑈.\n\n        // Here, we demonstrate the use of the Deutsch-Jozsa algorithm by\n        // determining the type (constant or balanced) of a couple of functions.\n        let balancedResults = DeutschJozsa(SimpleBalancedBoolF, 5);\n        let constantResults = DeutschJozsa(SimpleConstantBoolF, 5);\n        return (balancedResults, constantResults);\n    }\n\n    /// # Summary\n    /// This operation implements the DeutschJozsa algorithm.\n    /// It returns the query register measurement results. If all the measurement\n    /// results are `Zero`, the function is constant. If at least one measurement\n    /// result is `One`, the function is balanced.\n    /// It is assumed that the function is either constant or balanced.\n    ///\n    /// # Input\n    /// ## Uf\n    /// A quantum operation that implements |𝑥〉|𝑦〉 ↦ |𝑥〉|𝑦 ⊕ 𝑓(𝑥)〉, where 𝑓 is a\n    /// Boolean function, 𝑥 is an 𝑛 bit register and 𝑦 is a single qubit.\n    /// ## n\n    /// The number of bits in the input register |𝑥〉.\n    ///\n    /// # Output\n    /// An array of measurement results for the query reguster.\n    /// All `Zero` measurement results indicate that the function is constant.\n    /// At least one `One` measurement result in the array indicates that the\n    /// function is balanced.\n    ///\n    /// # See Also\n    /// - For details see Section 1.4.3 of Nielsen & Chuang.\n    ///\n    /// # References\n    /// - [ *Michael A. Nielsen , Isaac L. Chuang*,\n    ///     Quantum Computation and Quantum Information ]\n    /// (http://doi.org/10.1017/CBO9780511976667)\n    operation DeutschJozsa(Uf : ((Qubit[], Qubit) => Unit), n : Int) : Result[] {\n        // We allocate n + 1 clean qubits. Note that the function `Uf` is defined\n        // on inputs of the form (x, y), where x has n bits and y has 1 bit.\n        use queryRegister = Qubit[n];\n        use target = Qubit();\n\n        // The last qubit needs to be flipped so that the function will actually\n        // be computed into the phase when Uf is applied.\n        X(target);\n\n        // Now, a Hadamard transform is applied to each of the qubits.\n        H(target);\n        // We use a within-apply block to ensure that the Hadamard transform is\n        // correctly inverted on the |𝑥〉 register.\n        within {\n            for q in queryRegister {\n                H(q);\n            }\n        } apply {\n            // We apply Uf to the n+1 qubits, computing |𝑥, 𝑦〉 ↦ |𝑥, 𝑦 ⊕ 𝑓(𝑥)〉.\n            Uf(queryRegister, target);\n        }\n\n        // Measure the query register and reset all qubits so they can be safely\n        // deallocated.\n        let results = MeasureEachZ(queryRegister);\n        ResetAll(queryRegister);\n        Reset(target);\n        return results;\n    }\n\n    // Simple constant Boolean function\n    operation SimpleConstantBoolF(args : Qubit[], target : Qubit) : Unit {\n        X(target);\n    }\n\n    // Simple balanced Boolean function\n    operation SimpleBalancedBoolF(args : Qubit[], target : Qubit) : Unit {\n        CX(args[0], target);\n    }\n}\n\n"
     },
     {
         "title": "Deutsch-Jozsa (Advanced)",

package/package.json

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

package/ux/qsharp-ux.css

@@ -35,7 +35,7 @@ modern-normalize (see https://mattbrictson.com/blog/css-normalize-and-reset for
   );
   --qs-tr-nth-color: var(
     --vscode-list-hoverBackground,
-    var(--jp-layout-color1, #f2f2f2)
+    var(--jp-layout-color1, var(--colab-secondary-surface-color, #f2f2f2))
   );
   --nav-background: #bed1f4;
   --nav-hover-background: #b3bede;
@@ -325,6 +325,7 @@ html {
 
 .histogram {
   max-height: calc(100vh - 40px);
+  max-width: 600px;
   border: 1px solid var(--border-color);
   background-color: var(--vscode-sideBar-background, white);
 }

package/ux/spaceChart.tsx

@@ -60,7 +60,7 @@ export function SpaceChart(props: { estimatesData: ReData }) {
       >
         <path
           d={getPieSegment(250, 185, 180, 0, breakAngle, 120)}
-          fill="var(--vscode-charts-yellow, yellow)"
+          fill="var(--vscode-charts-orange, orange)"
           stroke="white"
         ></path>
         <path
@@ -79,7 +79,7 @@ export function SpaceChart(props: { estimatesData: ReData }) {
           y="400"
           width="25"
           height="25"
-          fill="var(--vscode-charts-yellow, yellow)"
+          fill="var(--vscode-charts-orange, orange)"
           stroke="white"
           stroke-width="1"
         />