From af5aca6051c53e6e78d1afafe25b0ab8fe423b28 Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Wed, 7 Sep 2022 13:05:32 -0500 Subject: [PATCH 1/6] Add numerical integration with QAE AQ sample --- binder-index.md | 8 + .../QuantumAmplitudeEstimation.ipynb | 1148 +++++++++++++++++ .../qae-numerical-integration/README.md | 40 + 3 files changed, 1196 insertions(+) create mode 100644 samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb create mode 100644 samples/azure-quantum/qae-numerical-integration/README.md diff --git a/binder-index.md b/binder-index.md index 06b87df6042c..73bd5fd54953 100644 --- a/binder-index.md +++ b/binder-index.md @@ -251,6 +251,14 @@ These are noted in the README.md files for each sample, along with complete inst Q# standalone + + + Numerical Integration with QAE + + + Q# + python + + Characterization: Bayesian Phase Estimation diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb new file mode 100644 index 000000000000..5a826bae3b3b --- /dev/null +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -0,0 +1,1148 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numerical Integration with Quantum Amplitude Estimation\n", + "\n", + "In this sample we will be integrating functions numerically using Quantum Amplitude Estimation (QAE).\n", + "\n", + "This sample is based on the work [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) by Vazquez and Woerner.\n", + "\n", + "In this sample we intend to cover techniques of visualizing results and seeing noise on hardware in action.\n", + "\n", + "The basics of QAE are that we are given an operator $A$ with the following properties\n", + "\n", + "$$A\\ket{0}_{n+1} = \\sqrt{1-a}\\ket{\\psi_0}_n\\ket{0} + \\sqrt{a}\\ket{\\psi_1}_n\\ket{1}$$\n", + "\n", + "From this we construct the operators:\n", + "\n", + "- $S_{\\psi_0}, S_{\\psi_1}$, which are reflections across $\\psi_0$ and $\\psi_1$ respectively\n", + "- $Q=A S_{\\psi_0} A^\\dagger S_{\\psi_1}$ as the full operator\n", + "\n", + "Amplitude estimation will then try to estimate $a$.\n", + "For this we construct a circuit where we apply $A$ followed by $k$ applications of $Q$ and in the end measure the last qubit:\n", + "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ \n", + "\n", + "After running the circuit multiple times we estimate $a$ to be the probability of getting result $1$.\n", + "\n", + "Our results improve if we build an $A$ that has the same $a$ but more qubits or by increasing the number of iterations $k$.\n", + "Increasing $n$ comes at the cost of needing more qubits, whereas $k$ comes at the cost of higher circuit depth.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import qsharp" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "import random\n", + "from scipy import optimize\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we are implementing a circuit for the numerical integral\n", + "\n", + "$$\\int_{x=0}^y{\\sin^2(\\pi x)dx} = \\frac{2\\pi y - \\sin(2 \\pi y)}{4\\pi}$$\n", + "\n", + "Details on this circuit can be found in the paper [arXiv:2005.07711](https://arxiv.org/abs/2005.07711).\n", + "\n", + "The fundamental idea is that we \n", + "* Discretize the interval $[0,2\\pi{}]$ into points $[x_0, \\ldots, x_{2^n}]$ that are spaced uniformly, where $n+1$ is the number of qubits for the circuit\n", + "* Put the quantum program in the state of the function at the discrete points\n", + "* Estimate the amplitudes at those given points\n", + "* Calculate the Riemann integral using these values\n", + "\n", + "The reason amplitude estimation is effective on quantum computer has quadratic speedup over classical computer when estimating amplitudes as this algorithm fundamentally builds on Grover's search.\n", + "\n", + "For a circuit with $n+1$ qubits, we have one target qubit and $n$ control qubits.\n", + "\n", + "Our algorithm has two main components:\n", + "\n", + "- State preparation $A$: We prepare state using controlled Y rotations on a target qubit. For $i \\in [1,2^n]$, we control Y-axis rotation with angles $\\theta_i = 2\\pi(x_i - x_0)$ on the control qubits being in state $\\ket{i}_n$. \n", + "Additionally, we control the rotation $2\\pi x_0$ on the control qubits being $\\ket{0}_n$. \n", + "The paper optimizes this to only have $n+1$ thetas, where $R_Y(\\theta_0)$ is uncontrolled and $R_Y(\\theta_i), i > 0$ is controlled on the $(n - i)^\\text{th}$ control wire.\n", + "Due to the uniform spacing, we see $$\\exists \\Delta, x_i = x_0 + i * \\Delta$$\n", + "Therefore it follows that the optimized version is equivalent to the version that is controlled on $\\ket{i}_n, i \\in [0, 2^n]$.\n", + "\n", + "- Iteration operator $Q$: The iteration operator $Q$ is given as follows $$Q=A S_0 A^\\dagger S_1$$ where \n", + "$$S_0 = I_{n + 1} - 2 \\ket{0}\\bra{0}_{n+1}, S_1 = I_n \\otimes Z$$\n", + "\n", + "The final algorithm will than be given by\n", + "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "\n", + "open Microsoft.Quantum.Math;\n", + "open Microsoft.Quantum.Arithmetic;\n", + "open Microsoft.Quantum.Convert;\n", + "open Microsoft.Quantum.Arrays;\n", + "open Microsoft.Quantum.Diagnostics;\n", + "open Microsoft.Quantum.Measurement;\n", + "\n", + "operation A(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", + " ApplyToEachCA(H, ctls);\n", + " Ry(theta[0], target);\n", + " for i in IndexRange(ctls) {\n", + " Controlled (Ry(theta[i + 1], _)) ([ctls[Length(ctls) - 1 - i]], target);\n", + " }\n", + "}\n", + "\n", + "operation Q(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", + " Z(target);\n", + " within {\n", + " Adjoint A(ctls, target, theta);\n", + " ApplyToEachCA(X, ctls + [target]);\n", + " } apply {\n", + " Controlled Z (ctls, target);\n", + " }\n", + "}\n", + "\n", + "operation RunQAE(theta : Double[], k : Int) : Result {\n", + " use ctls = Qubit[Length(theta) - 1];\n", + " use target = Qubit();\n", + " A(ctls, target, theta);\n", + " RepeatCA(Q, k, (ctls, target, theta));\n", + " let res = MResetZ(target);\n", + " ResetAll(ctls);\n", + " return res;\n", + "}\n", + "\n", + "operation CountOneResults<'TInput> (op : ('TInput => Result), n : Int , input : 'TInput) : Int {\n", + " mutable res = 0;\n", + " for i in 0..n {\n", + " if op(input) == One {\n", + " set res = res + 1;\n", + " }\n", + " }\n", + " return res;\n", + "}\n", + "\n", + "operation RunNQAE(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(RunQAE, n, (theta, k));\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Spin Echo Optimization\n", + "\n", + "After building our $A$ and $Q$, we can use properties of quantum circuits to reduce the number of rotations by merging them.\n", + "Essentially, we can compute the inverse of our rotations through the Z gates, allowing us to merge the operators $A^\\dagger S_1 A$.\n", + "This optimization is called Spin Echo optimization. \n", + "Please refer to [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) for more details on why it works. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation QSpinEcho(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", + " A(ctls, target, Mapped(x -> 2.0 * x, theta));\n", + " ApplyToEachCA(H, ctls);\n", + " Z(target);\n", + " within {\n", + " ApplyToEachCA(X, ctls + [target]);\n", + " } apply {\n", + " Controlled Z (ctls, target);\n", + " }\n", + " \n", + "}\n", + "\n", + "operation RunQAESpinEcho(theta : Double[], k : Int) : Result {\n", + " use ctls = Qubit[Length(theta) - 1];\n", + " use target = Qubit();\n", + " RepeatCA(QSpinEcho, k, (ctls, target, theta));\n", + " A(ctls, target, theta);\n", + " ApplyToEachCA(H, ctls);\n", + " let res = MResetZ(target);\n", + " ResetAll(ctls);\n", + " return res;\n", + "}\n", + "\n", + "operation RunNQAESpinEcho(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(RunQAESpinEcho, n, (theta, k));\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Resource Estimation of Spin Echo Optimization\n", + "\n", + "To see the effectiveness of the Spin Echo optimization, we will use the resource estimator to see the difference in gate count. \n", + "For this we will use the resource estimator and for bit length 2 and 3 we will see the how many fewer gates the optimized circuit needs for given $k$." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.core.display import HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Differences with Spin Echo optimization at bit length 2
k1Q gate reduction2Q gate reduction
116.0%28.57%
220.45%33.33%
423.17%36.36%
824.68%38.1%
1625.48%39.02%
3225.9%39.51%
6426.1%39.75%
12826.21%39.88%
\n", + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Differences with Spin Echo optimization at bit length 3
k1Q gate reduction2Q gate reduction
114.89%18.18%
219.28%20.0%
421.94%21.05%
823.41%21.62%
1624.19%21.92%
3224.59%22.07%
6424.79%22.15%
12824.9%22.18%
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs = []\n", + "for bitlen in [2, 3]:\n", + " deltas = []\n", + " theta = list(map(lambda _ : random.uniform(0, 3.14), range(bitlen))) # Random thetas\n", + " for k in map(lambda x : 2 ** x, range(8)):\n", + " spin_echo_res = RunQAESpinEcho.estimate_resources(theta=theta, k=k)\n", + " res = RunQAE.estimate_resources(theta=theta, k=k)\n", + "\n", + " def delta(key : str) -> int:\n", + " return (res[key] - spin_echo_res[key])\n", + "\n", + " delta_2q = str(np.round(delta('CNOT') / res['CNOT'] * 100, 2)) + '%'\n", + " delta_1q = str(np.round((delta('QubitClifford') + delta('R') + delta('T')) / (res['QubitClifford'] + res['R'] + res['T']) * 100, 2)) + '%'\n", + " deltas.append([k, delta_1q, delta_2q])\n", + " df = pd.DataFrame(deltas, columns=[\"k\", \"1Q gate reduction\", \"2Q gate reduction\"])\n", + " df = df.style.set_caption(f\"Differences with Spin Echo optimization at bit length {bitlen}\").hide_index()\n", + " dfs.append(df)\n", + "\n", + "html_dfs = list(map(lambda df : df.to_html(), dfs))\n", + "HTML(\"
\".join(html_dfs))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the Spin Echo circuit requires fewer gates across the board and for higher $k$ we get bigger benefits.\n", + "\n", + "## Maximum Likelihood Estimator (MLE)\n", + "\n", + "We will be using the MLE to get our optimal theta results with a modified optimization function that you can see in the code below as `loglikelihood`.\n", + "\n", + "To learn more about why and how this estimator works with QAE please see our other sample and [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf).\n", + "\n", + "We use (and adapt) the MLE calculation methods from the work resulting from [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf) that can be found on [GitHub](https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/algorithms/SimpleIntegral_AEwoPE.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_theta(hit_list, number, shots):\n", + " \"\"\"\n", + " calculate optimal theta values\n", + " hit_list: list of count of obserbving \"1\" for qc_list\n", + " numebr_grover_list: list of number of Grover operators \n", + " shots_list: list of number of shots\n", + "\n", + " Return:\n", + " theta_candidates: list of optimal theta\n", + " \"\"\"\n", + "\n", + " small = 1.e-15 # small valued parameter to avoid zero division\n", + " confidence_level = 5 # confidence level to determine the search range\n", + "\n", + " theta_candidates = []\n", + " range_min = 0.0 + small\n", + " range_max = 1.0 - small\n", + " for igrover in range(len(number)):\n", + "\n", + " def loglikelihood(p):\n", + " ret = np.zeros_like(p)\n", + " theta = np.arcsin(np.sqrt(p))\n", + " for n in range(igrover + 1):\n", + " ihit = hit_list[n]\n", + " arg = (2 * number[n] + 1) * theta\n", + " ret = ret + 2 * ihit * np.log(np.abs(np.sin(arg))) + 2 * (\n", + " shots - ihit) * np.log(np.abs(np.cos(arg)))\n", + " return -ret\n", + "\n", + " search_range = (range_min, range_max)\n", + " prob_candidate = optimize.brute(loglikelihood, [search_range])[0]\n", + " theta_candidates.append(np.arcsin(np.sqrt(prob_candidate)))\n", + " perror = cramer_rao_error(igrover, shots, prob_candidate, number)\n", + " range_max = min(prob_candidate+confidence_level * perror, 1.0 - small)\n", + " range_min = max(prob_candidate-confidence_level * perror, 0.0 + small)\n", + " return theta_candidates\n", + "\n", + "\n", + "def cramer_rao_error(M, shots, p0, number):\n", + " \"\"\"\n", + " calculate Cramér-Rao lower bound\n", + " M: upper limit of the sum in Fisher information \n", + " shots_list: list of number of shots\n", + " p0: the true parameter value to be estimated\n", + " numebr_grover_list: list of number of Grover operators \n", + "\n", + " Return:\n", + " square root of Cramér-Rao lower bound: lower bound on the standard deviation of unbiased estimators\n", + " \"\"\"\n", + " fisher_info = 0\n", + " for k in range(M + 1):\n", + " mk = number[k]\n", + " fisher_info += shots / (p0 * (1 - p0)) * (2 * mk + 1)**2\n", + " return np.sqrt(1 / fisher_info)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the statistical preliminaries out of the way, let's build a function that assembles our $\\theta_i, i \\in [0, n]$, runs our circuit and calculates the most likely values." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "def compute_theta(bit_length: int, y_int: tuple) -> list:\n", + " (y0, y) = y_int\n", + " thetas = []\n", + " for i in range(bit_length):\n", + " y_sc = i * (y - y0) / bit_length\n", + " thetas.append(2 * math.pi * (y_sc - y0))\n", + " return thetas\n", + "\n", + "\n", + "def integrate(run_fn, bit_length: int, y_int: tuple, ks, shots=250) -> list:\n", + " prev = 0\n", + " (_, y) = y_int\n", + " print(f\"integration for y in {y_int}\")\n", + " # Precompute thetas\n", + " theta = compute_theta(bit_length=bit_length, y_int=y_int)\n", + " # Run Amplitude estimation\n", + " good_states = []\n", + " for k in ks:\n", + " good_states.append(run_fn(n=shots, theta=theta, k=k, y_int=y_int))\n", + " result_thetas = calculate_theta(good_states, ks, shots)\n", + " return list(map(lambda x: x * y, result_thetas))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then proceed to actually integrate our work and collect data." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "n = 15\n", + "ys = list(map(lambda x : 0.5 * x / n, list(range(n + 1))))\n", + "ks = [0, 1, 2, 4, 8, 16]\n", + "\n", + "def get_results(run_fn, bit_length=2, ys=ys, ks=ks, shots=200):\n", + " k_vals = dict()\n", + " for k in ks:\n", + " k_vals[k] = []\n", + " prev = ys[0]\n", + " for y in ys: \n", + " res = list(integrate(run_fn, bit_length=2, y_int=(0, y), shots=200, ks=ks))\n", + " assert len(ks) == len(res)\n", + " for i in range(len(ks)):\n", + " k_vals[ks[i]] += [res[i]]\n", + " prev = y\n", + " return k_vals" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integration for y in (0, 0.0)\n", + "integration for y in (0, 0.03333333333333333)\n", + "integration for y in (0, 0.06666666666666667)\n", + "integration for y in (0, 0.1)\n", + "integration for y in (0, 0.13333333333333333)\n", + "integration for y in (0, 0.16666666666666666)\n", + "integration for y in (0, 0.2)\n", + "integration for y in (0, 0.23333333333333334)\n", + "integration for y in (0, 0.26666666666666666)\n", + "integration for y in (0, 0.3)\n", + "integration for y in (0, 0.3333333333333333)\n", + "integration for y in (0, 0.36666666666666664)\n", + "integration for y in (0, 0.4)\n", + "integration for y in (0, 0.43333333333333335)\n", + "integration for y in (0, 0.4666666666666667)\n", + "integration for y in (0, 0.5)\n" + ] + } + ], + "source": [ + "k_vals = get_results(RunNQAESpinEcho.simulate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll plot our approximations for different values of $k$ against the exact integral" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x : float) -> float:\n", + " return (math.sin(math.pi * x)) ** 2\n", + "\n", + "def int_f(x : float) -> float:\n", + " return x / 2 - math.sin(2 * math.pi *x) / (4 * math.pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "colors = dict()\n", + "colors[0] = 'b'\n", + "colors[1] = 'r'\n", + "colors[2] = 'c'\n", + "colors[4] = 'm'\n", + "colors[8] = 'y'\n", + "colors[16] = 'pink'\n", + "colors[32] = 'grey'" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def plot(ys : list, k_vals : dict) -> None:\n", + " int_f_y = list(map(int_f, ys))\n", + " f_y = list(map(f, ys))\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('y')\n", + " #int_f_y = list(map(lambda x : sum(f_y[1:x+1]) / n, range(len(ys))))\n", + " int_fx_plot, = plt.plot(ys, int_f_y, color='g', label='$g(y) = \\int_{x=0}^y \\sin^2(\\pi x) dx$')\n", + " apprx_plots = []\n", + " for k, vals in k_vals.items(): \n", + " f_vals = list(map(lambda x : x / 1, vals))\n", + " apprx_plot, = plt.plot(ys, f_vals, colors[k], label='$\\widehat{g(y)}, ' + f'k={k}$')\n", + " apprx_plots.append(apprx_plot)\n", + " ax.legend(handles=[int_fx_plot] + apprx_plots)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(ys, k_vals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this plot we see that all of our results look fairly close to the expected value graphed in green.\n", + "\n", + "Therefore, we'll graph the errors to get see which $k$ performs best." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "def epsilon_squared(x : float, expected : float) -> float:\n", + " return (x - expected) ** 2\n", + "\n", + "def compute_err(ys : list, vals : list) -> list:\n", + " assert len(ys) == len(vals)\n", + " err = []\n", + " f_y = list(map(f, ys))\n", + " int_f_y = list(map(int_f, ys))\n", + " #int_f_y = list(map(lambda x : sum(f_y[1:x+1]) / n, range(len(ys))))\n", + " for i in range(len(ys)):\n", + " y = ys[i]\n", + " g_y = int_f_y[i]\n", + " g_hat_y = vals[i]\n", + " err.append(epsilon_squared(g_hat_y, g_y))\n", + " return err\n", + "\n", + "def plot_err(ys, k_err : dict) -> None:\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('y')\n", + " ax.set_ylabel('error')\n", + " err_plots = []\n", + " for k, err in k_err.items(): \n", + " err_plot, = plt.plot(ys, err, colors[k], label='$\\epsilon^2(y)$, ' + f'k={k}')\n", + " err_plots.append(err_plot)\n", + " ax.legend(handles=err_plots)\n", + "\n", + "def plot_average_err(k_err_avg : dict) -> None:\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('$k$')\n", + " ax.set_ylabel('Average $\\epsilon^2$')\n", + " plt.bar(list(map(lambda x : str(x), k_err_avg.keys())), k_err_avg.values())\n", + "\n", + "def build_err(ys : list, k_vals : dict) -> tuple:\n", + " k_err = dict()\n", + " k_err_avg = dict()\n", + " for k, vals in k_vals.items():\n", + " f_vals = list(map(lambda x : f(x) / 2, vals))\n", + " k_err[k] = compute_err(ys, f_vals)\n", + " k_err_avg[k] = np.average(k_err[k])\n", + " return (k_err, k_err_avg)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "k_err, k_err_avg = build_err(ys, k_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_err(ys, k_err)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we clearly see that $k=0$ performs worse than the other values. Let's look at the average error to get a better picture." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_average_err(k_err_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we'd expect, the error is trending downward with increasing $k$.\n", + "\n", + "Let us now repeat the same on IonQ Harmony to see if the results are the same." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "import qsharp.azure\n", + "import datetime\n", + "from qsharp.azure import AzureJob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we will connect to Azure Quantum and select the IonQ harmony target" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "application/x-qsharp-data": "\"Connecting to Azure Quantum...\"", + "text/plain": [ + "Connecting to Azure Quantum..." + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connected to Azure Quantum workspace AdriansProjectWorkspace in location westus.\n" + ] + } + ], + "source": [ + "targets = qsharp.azure.connect(\n", + " resourceId=\"\",\n", + " location=\"\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This workspace's 10 targets:\n", + "- ionq.qpu (average queue time 1 day, 0:16:31)\n", + "- ionq.qpu.aria-1 (average queue time 0:31:54)\n", + "- ionq.simulator (average queue time 0:00:02)\n", + "- quantinuum.hqs-lt-s1 (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s1-apival (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s2 (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s2-apival (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s1-sim (average queue time 0:00:29)\n", + "- quantinuum.hqs-lt-s2-sim (average queue time 0:00:31)\n", + "- quantinuum.hqs-lt (average queue time 0:00:00)\n" + ] + } + ], + "source": [ + "\n", + "print(f\"This workspace has {len(targets)} targets:\")\n", + "for target in targets:\n", + " print(f\"- {target.id} (average queue time {datetime.timedelta(seconds=target.average_queue_time)})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading package Microsoft.Quantum.Providers.IonQ and dependencies...\n", + "Active target is now ionq.qpu\n" + ] + }, + { + "data": { + "text/plain": [ + "{'id': 'ionq.qpu', 'current_availability': {}, 'average_queue_time': 87391}" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qsharp.azure.target(\"ionq.qpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we write some logic to handle our jobs. Since jobs submitted to real hardware might take a bit to complete, we want to have infrastructure to submit jobs, check their status and fetch their results." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "def submit_integration_jobs_yint(bit_length: int, y_int: tuple, ks, shots=250):\n", + " theta = compute_theta(bit_length=bit_length, y_int=y_int)\n", + " # Run Amplitude estimation\n", + " k_jobs = dict()\n", + " for k in ks:\n", + " k_jobs[k] = qsharp.azure.submit(RunQAESpinEcho, jobName = f\"QAE for bit length {bit_length}, k={k}, y_int={y_int}\", shots=shots, theta=theta, k=k)\n", + " return k_jobs\n", + "\n", + "def submit_integration_jobs(bit_length: int, ys : list, ks, shots=250):\n", + " y_k_jobs = dict()\n", + " for y in ys:\n", + " y_int = (0, y)\n", + " y_k_jobs[y_int] = submit_integration_jobs_yint(bit_length, y_int, ks, shots)\n", + " return y_k_jobs\n", + "\n", + "def get_job(job_id : str) -> tuple:\n", + " current_job = qsharp.azure.status(jobId=job_id)\n", + " succeeded = current_job.status == 'Succeeded'\n", + " if succeeded:\n", + " print(f'Job completed')\n", + " elif current_job.status == 'Failed':\n", + " print(f'Job \\\"{current_job.name}\\\" failed. Please review reason at {current_job.uri}')\n", + " else:\n", + " print(f'Job \\\"{current_job.name}\\\" is still running. Please check back later!')\n", + " return (succeeded, current_job)\n", + "\n", + "\n", + "def get_job_result(job_id : str, shots : int) -> int:\n", + " (success, _) = get_job(job_id=job_id)\n", + " if not success:\n", + " raise Exception(\"Job not completed\")\n", + " output = qsharp.azure.output(jobId=job_id)\n", + " if '1' not in output: # All 0 return\n", + " return 0\n", + " return np.round(output['1'] * shots)\n", + "\n", + "\n", + "def get_all_job_results(y_k_jobs : dict, shots=250) -> dict:\n", + " y_k_job_result = dict()\n", + " for (y, k_jobs) in y_k_jobs.items():\n", + " y_k_job_result[y] = dict()\n", + " for (k, job) in k_jobs.items():\n", + " y_k_job_result[y][k] = get_job_result(job_id=job.id, shots=shots)\n", + " return y_k_job_result\n", + "\n", + "def build_use_job_output(y_k_job_result : dict):\n", + " def use_job_output(n : int, theta : list, k : int, y_int : tuple) -> int:\n", + " return y_k_job_result[y_int][k]\n", + " return use_job_output\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's go ahead and run them!\n", + "\n", + "\n", + "**Please note that this sample makes use of paid services on Azure Quantum. \n", + "The cost of running this sample with the provided parameters on IonQ is approximately \\$147. \n", + "This quantity is only an approximate estimate and should not be used as a binding reference. \n", + "The cost of the service might vary depending on your region, demand and other factors.**\n", + "\n", + "Please note this might take a while. Please keep the tab with the sample open until completion." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitted all jobs successfully!\n" + ] + } + ], + "source": [ + "y_k_jobs = submit_integration_jobs(bit_length=2,ys=ys,ks=ks)\n", + "\n", + "clear_output(wait=True)\n", + "print(\"Submitted all jobs successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "with open('jobs-qpu.pkl', 'wb') as pkl_file:\n", + " pickle.dump(y_k_jobs, pkl_file)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processed all results successfully!\n" + ] + } + ], + "source": [ + "y_k_job_results = get_all_job_results(y_k_jobs,)\n", + "\n", + "clear_output(wait=True)\n", + "print(\"Processed all results successfully!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we're done, we will get our results.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integration for y in (0, 0.0)\n", + "integration for y in (0, 0.03333333333333333)\n", + "integration for y in (0, 0.06666666666666667)\n", + "integration for y in (0, 0.1)\n", + "integration for y in (0, 0.13333333333333333)\n", + "integration for y in (0, 0.16666666666666666)\n", + "integration for y in (0, 0.2)\n", + "integration for y in (0, 0.23333333333333334)\n", + "integration for y in (0, 0.26666666666666666)\n", + "integration for y in (0, 0.3)\n", + "integration for y in (0, 0.3333333333333333)\n", + "integration for y in (0, 0.36666666666666664)\n", + "integration for y in (0, 0.4)\n", + "integration for y in (0, 0.43333333333333335)\n", + "integration for y in (0, 0.4666666666666667)\n", + "integration for y in (0, 0.5)\n" + ] + } + ], + "source": [ + "k_vals_aq = get_results(build_use_job_output(y_k_job_results))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now graph our results/errors and see if they differ from our findings on the simulator!" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(ys, k_vals_aq)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "k_err, k_err_avg = build_err(ys, k_vals_aq)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_err(ys, k_err)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_average_err(k_err_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our graph we see our results are not as on the simulator. \n", + "In fact, in our testing $k=0$ performed better than any other $k$.\n", + "This comes down to the noise effects of the additional gates we need for the larger values of $k$.\n", + "This is an interesting result because it shows considerations for current quantum computers that a perfect simulator does not depict: Every gate introduces noise.\n", + "So one of our goals must be to reduce circuit depth. \n", + "Despite having the reduced depth already using the spin echo optimization, we still have noise effects. \n", + "Without this optimization's circuit depth reduction we'd expect noise to be even higher.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('qsharp-env-37')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "vscode": { + "interpreter": { + "hash": "2ae822f0f83fed12107faf85edb2b742fdce767c971cd51f224ccfc7e38aba9d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/azure-quantum/qae-numerical-integration/README.md b/samples/azure-quantum/qae-numerical-integration/README.md new file mode 100644 index 000000000000..0a874a4c3f7d --- /dev/null +++ b/samples/azure-quantum/qae-numerical-integration/README.md @@ -0,0 +1,40 @@ +--- +page_type: sample +author: adrianleh +description: Numerical Integration with Quantum Amplitude Estimation, using the Azure Quantum service +ms.author: t-alehmann@microsoft.com +ms.date: 09/06/2021 +languages: +- qsharp +- python +products: +- qdk +- azure-quantum +--- + +# Numerical Integration with Quantum Amplitude Estimation (QAE) + +In this sample we will be using Quantum Amplitude Estimation to perform numerical integration on the function $f(x) = \sin^2(\pi x)$. + +This sample is based on the work [arXiv:2005.07711](https:arxiv.org/abs/2005.07711) by Vazquez and Woerner. +We build QAE, optimize it, see the effects of the optimization and run on both the simulator and hardware. +This will allow us to the real-world effects of noise in NISQ machines. + +In this sample we cover techniques of visualizing results and seeing noise on hardware in action. + +This sample is a Q# jupyter notebook targeted at IonQ machines. + +## Q# with Jupyter Notebook + +Make sure that you have followed the [Q# + Jupyter Notebook quickstart](https://docs.microsoft.com/azure/quantum/install-jupyter-qdk) for the Quantum Development Kit, and then start a new Jupyter Notebook session from the folder containing this sample: + +```shell +cd qae-num-int +jupyter notebook +``` + +Once Jupyter starts, open the `QuantumAmplitudeEstimation.ipynb` notebook and follow the instructions there. + +## Manifest + +- [QuantumAmplitudeEstimation.ipynb](https://github.com/microsoft/quantum/blob/main/samples/azure-quantum/qae-num-int/QuantumAmplitudeEstimation.ipynb): IQ# notebook for this sample targetting IonQ. \ No newline at end of file From 58bbf2d5859dcebd8d45f2fd1cc7d0629c222eb5 Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Thu, 8 Sep 2022 18:10:33 -0500 Subject: [PATCH 2/6] Apply PR feedback --- .../QuantumAmplitudeEstimation.ipynb | 301 ++++++++++-------- 1 file changed, 170 insertions(+), 131 deletions(-) diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb index 5a826bae3b3b..a39d4b31f35a 100644 --- a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -7,21 +7,24 @@ "# Numerical Integration with Quantum Amplitude Estimation\n", "\n", "In this sample we will be integrating functions numerically using Quantum Amplitude Estimation (QAE).\n", + "Warning: This sample is intended for users with an advanced level of knowledge of mathematics.\n", "\n", "This sample is based on the work [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) by Vazquez and Woerner.\n", "\n", - "In this sample we intend to cover techniques of visualizing results and seeing noise on hardware in action.\n", + "In this sample we cover techniques of visualizing results and seeing noise on hardware in action.\n", "\n", "The basics of QAE are that we are given an operator $A$ with the following properties\n", "\n", "$$A\\ket{0}_{n+1} = \\sqrt{1-a}\\ket{\\psi_0}_n\\ket{0} + \\sqrt{a}\\ket{\\psi_1}_n\\ket{1}$$\n", "\n", + "with $\\psi_0$ and $\\psi_1$ being arbitrary states.\n", + "\n", "From this we construct the operators:\n", "\n", "- $S_{\\psi_0}, S_{\\psi_1}$, which are reflections across $\\psi_0$ and $\\psi_1$ respectively\n", "- $Q=A S_{\\psi_0} A^\\dagger S_{\\psi_1}$ as the full operator\n", "\n", - "Amplitude estimation will then try to estimate $a$.\n", + "Amplitude estimation will then try to estimate $a$ given the operators $A$ and $Q$.\n", "For this we construct a circuit where we apply $A$ followed by $k$ applications of $Q$ and in the end measure the last qubit:\n", "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ \n", "\n", @@ -33,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -76,23 +79,13 @@ "\n", "Our algorithm has two main components:\n", "\n", - "- State preparation $A$: We prepare state using controlled Y rotations on a target qubit. For $i \\in [1,2^n]$, we control Y-axis rotation with angles $\\theta_i = 2\\pi(x_i - x_0)$ on the control qubits being in state $\\ket{i}_n$. \n", - "Additionally, we control the rotation $2\\pi x_0$ on the control qubits being $\\ket{0}_n$. \n", - "The paper optimizes this to only have $n+1$ thetas, where $R_Y(\\theta_0)$ is uncontrolled and $R_Y(\\theta_i), i > 0$ is controlled on the $(n - i)^\\text{th}$ control wire.\n", - "Due to the uniform spacing, we see $$\\exists \\Delta, x_i = x_0 + i * \\Delta$$\n", - "Therefore it follows that the optimized version is equivalent to the version that is controlled on $\\ket{i}_n, i \\in [0, 2^n]$.\n", - "\n", - "- Iteration operator $Q$: The iteration operator $Q$ is given as follows $$Q=A S_0 A^\\dagger S_1$$ where \n", - "$$S_0 = I_{n + 1} - 2 \\ket{0}\\bra{0}_{n+1}, S_1 = I_n \\otimes Z$$\n", - "\n", - "The final algorithm will than be given by\n", - "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ \n", - "\n" + "- State preparation $A$\n", + "- Iteration operator $Q$\n" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -103,44 +96,92 @@ "open Microsoft.Quantum.Convert;\n", "open Microsoft.Quantum.Arrays;\n", "open Microsoft.Quantum.Diagnostics;\n", - "open Microsoft.Quantum.Measurement;\n", + "open Microsoft.Quantum.Measurement;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's build our state preparation $A$:\n", "\n", - "operation A(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", + "We prepare state using controlled $Y$-axis rotations on a target qubit. For $i \\in [1,2^n]$, we control $Y$-axis rotation with angles $\\theta_i = 2\\pi(x_i - x_0)$ on the control qubits being in state $\\ket{i}_n$. \n", + "Additionally, we control the rotation $2\\pi x_0$ on the control qubits being $\\ket{0}_n$. \n", + "The paper optimizes this to only have $n+1$ thetas, where $R_Y(\\theta_0)$ is uncontrolled and $R_Y(\\theta_i), i > 0$ is controlled on the $(n - i)^\\text{th}$ control wire.\n", + "Due to the uniform spacing, we see $$\\exists \\Delta, x_i = x_0 + i * \\Delta$$\n", + "Therefore it follows that the optimized version is equivalent to the version that is controlled on $\\ket{i}_n, i \\in [0, 2^n]$." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation A(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + " EqualityFactI(Length(theta), Length(ctls) + 1, \"Thetas and controls must have same length\");\n", " ApplyToEachCA(H, ctls);\n", " Ry(theta[0], target);\n", " for i in IndexRange(ctls) {\n", - " Controlled (Ry(theta[i + 1], _)) ([ctls[Length(ctls) - 1 - i]], target);\n", + " Controlled Ry([ctls[Length(ctls) - 1 - i]], (theta[i + 1], target));\n", " }\n", - "}\n", - "\n", - "operation Q(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... and our Iteration operator $Q$: The iteration operator $Q$ is given as follows $$Q=A S_0 A^\\dagger S_1$$ where \n", + "$$S_0 = I_{n + 1} - 2 \\ket{0}\\bra{0}_{n+1}, S_1 = I_n \\otimes Z$$" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation Q(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", " Z(target);\n", " within {\n", - " Adjoint A(ctls, target, theta);\n", - " ApplyToEachCA(X, ctls + [target]);\n", + " Adjoint A(theta, ctls, target);\n", + " ApplyToEachCA(X, ctls + [target]); // Turns |0...0> into |1...1> (i.e., enabling the controlled Z to reflect)\n", " } apply {\n", " Controlled Z (ctls, target);\n", " }\n", - "}\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final algorithm will then be built to correspond to the matrix operation:\n", + "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", "operation RunQAE(theta : Double[], k : Int) : Result {\n", " use ctls = Qubit[Length(theta) - 1];\n", " use target = Qubit();\n", - " A(ctls, target, theta);\n", - " RepeatCA(Q, k, (ctls, target, theta));\n", + " A(theta, ctls, target);\n", + " RepeatCA(Q, k, (theta, ctls, target));\n", " let res = MResetZ(target);\n", " ResetAll(ctls);\n", " return res;\n", "}\n", "\n", "operation CountOneResults<'TInput> (op : ('TInput => Result), n : Int , input : 'TInput) : Int {\n", - " mutable res = 0;\n", - " for i in 0..n {\n", - " if op(input) == One {\n", - " set res = res + 1;\n", - " }\n", - " }\n", - " return res;\n", + " return Count(res -> res == One, DrawMany(op, n, input));\n", "}\n", "\n", "operation RunNQAE(n : Int, theta : Double[], k : Int) : Int {\n", @@ -155,24 +196,24 @@ "## Spin Echo Optimization\n", "\n", "After building our $A$ and $Q$, we can use properties of quantum circuits to reduce the number of rotations by merging them.\n", - "Essentially, we can compute the inverse of our rotations through the Z gates, allowing us to merge the operators $A^\\dagger S_1 A$.\n", + "Essentially, we can compute the inverse of our rotations through the `Z` gates, allowing us to merge the operators $A^\\dagger S_1 A$.\n", "This optimization is called Spin Echo optimization. \n", "Please refer to [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) for more details on why it works. \n" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "%%qsharp\n", - "operation QSpinEcho(ctls : Qubit[], target : Qubit, theta : Double[]) : Unit is Adj + Ctl {\n", - " A(ctls, target, Mapped(x -> 2.0 * x, theta));\n", + "operation QSpinEcho(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + " A(Mapped(x -> 2.0 * x, theta), ctls, target);\n", " ApplyToEachCA(H, ctls);\n", " Z(target);\n", " within {\n", - " ApplyToEachCA(X, ctls + [target]);\n", + " ApplyToEachCA(X, ctls + [target]); // Turns |0...0> into |1...1> (i.e., enabling the controlled Z to reflect)\n", " } apply {\n", " Controlled Z (ctls, target);\n", " }\n", @@ -182,8 +223,8 @@ "operation RunQAESpinEcho(theta : Double[], k : Int) : Result {\n", " use ctls = Qubit[Length(theta) - 1];\n", " use target = Qubit();\n", - " RepeatCA(QSpinEcho, k, (ctls, target, theta));\n", - " A(ctls, target, theta);\n", + " RepeatCA(QSpinEcho, k, (theta, ctls, target));\n", + " A(theta, ctls, target);\n", " ApplyToEachCA(H, ctls);\n", " let res = MResetZ(target);\n", " ResetAll(ctls);\n", @@ -207,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -216,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -224,7 +265,7 @@ "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -235,50 +276,50 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 2
116.0%28.57%116.0%28.57%
220.45%33.33%220.45%33.33%
423.17%36.36%423.17%36.36%
824.68%38.1%824.68%38.1%
1625.48%39.02%1625.48%39.02%
3225.9%39.51%3225.9%39.51%
6426.1%39.75%6426.1%39.75%
12826.21%39.88%12826.21%39.88%
\n", "
\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -289,44 +330,44 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 3
114.89%18.18%114.89%18.18%
219.28%20.0%219.28%20.0%
421.94%21.05%421.94%21.05%
823.41%21.62%823.41%21.62%
1624.19%21.92%1624.19%21.92%
3224.59%22.07%3224.59%22.07%
6424.79%22.15%6424.79%22.15%
12824.9%22.18%12824.9%22.18%
\n" @@ -335,14 +376,14 @@ "" ] }, - "execution_count": 36, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dfs = []\n", - "for bitlen in [2, 3]:\n", + "for bitlen in (2, 3):\n", " deltas = []\n", " theta = list(map(lambda _ : random.uniform(0, 3.14), range(bitlen))) # Random thetas\n", " for k in map(lambda x : 2 ** x, range(8)):\n", @@ -373,22 +414,24 @@ "\n", "We will be using the MLE to get our optimal theta results with a modified optimization function that you can see in the code below as `loglikelihood`.\n", "\n", - "To learn more about why and how this estimator works with QAE please see our other sample and [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf).\n", + "To learn more about why and how this estimator works with QAE please see [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf).\n", "\n", - "We use (and adapt) the MLE calculation methods from the work resulting from [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf) that can be found on [GitHub](https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/algorithms/SimpleIntegral_AEwoPE.ipynb)." + "We use (and adapt) the MLE calculation methods from the work resulting from [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf) that can be found in the [Qiskit community tutorials on GitHub](https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/algorithms/SimpleIntegral_AEwoPE.ipynb)." ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ - "def calculate_theta(hit_list, number, shots):\n", + "from typing import List, Tuple\n", + "\n", + "def calculate_theta(hit_list: List[int], number: List[int], shots: List[int]) -> List[float]:\n", " \"\"\"\n", " calculate optimal theta values\n", - " hit_list: list of count of obserbving \"1\" for qc_list\n", - " numebr_grover_list: list of number of Grover operators \n", + " hit_list: list of count of obserbving \"1\"\n", + " number: list of number of Grover operators \n", " shots_list: list of number of shots\n", "\n", " Return:\n", @@ -401,12 +444,12 @@ " theta_candidates = []\n", " range_min = 0.0 + small\n", " range_max = 1.0 - small\n", - " for igrover in range(len(number)):\n", + " for idx_grover_operator in range(len(number)):\n", "\n", " def loglikelihood(p):\n", " ret = np.zeros_like(p)\n", " theta = np.arcsin(np.sqrt(p))\n", - " for n in range(igrover + 1):\n", + " for n in range(idx_grover_operator + 1):\n", " ihit = hit_list[n]\n", " arg = (2 * number[n] + 1) * theta\n", " ret = ret + 2 * ihit * np.log(np.abs(np.sin(arg))) + 2 * (\n", @@ -416,27 +459,24 @@ " search_range = (range_min, range_max)\n", " prob_candidate = optimize.brute(loglikelihood, [search_range])[0]\n", " theta_candidates.append(np.arcsin(np.sqrt(prob_candidate)))\n", - " perror = cramer_rao_error(igrover, shots, prob_candidate, number)\n", - " range_max = min(prob_candidate+confidence_level * perror, 1.0 - small)\n", - " range_min = max(prob_candidate-confidence_level * perror, 0.0 + small)\n", + " pbound = cramer_rao_bound(idx_grover_operator, shots, prob_candidate, number)\n", + " range_max = min(prob_candidate+confidence_level * pbound, 1.0 - small)\n", + " range_min = max(prob_candidate-confidence_level * pbound, 0.0 + small)\n", " return theta_candidates\n", "\n", "\n", - "def cramer_rao_error(M, shots, p0, number):\n", + "def cramer_rao_bound(M: int, shots: List[int], p0: float, number: List[int]) -> float:\n", " \"\"\"\n", " calculate Cramér-Rao lower bound\n", " M: upper limit of the sum in Fisher information \n", " shots_list: list of number of shots\n", " p0: the true parameter value to be estimated\n", - " numebr_grover_list: list of number of Grover operators \n", + " number: list of number of Grover operators \n", "\n", " Return:\n", " square root of Cramér-Rao lower bound: lower bound on the standard deviation of unbiased estimators\n", " \"\"\"\n", - " fisher_info = 0\n", - " for k in range(M + 1):\n", - " mk = number[k]\n", - " fisher_info += shots / (p0 * (1 - p0)) * (2 * mk + 1)**2\n", + " fisher_info = sum(map(lambda mk : shots / (p0 * (1 - p0)) * (2 * mk + 1)**2, number[:M+1]))\n", " return np.sqrt(1 / fisher_info)\n" ] }, @@ -449,13 +489,13 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 40, "metadata": { "scrolled": true }, "outputs": [], "source": [ - "def compute_theta(bit_length: int, y_int: tuple) -> list:\n", + "def compute_theta(bit_length: int, y_int: Tuple[float, float]) -> List[float]:\n", " (y0, y) = y_int\n", " thetas = []\n", " for i in range(bit_length):\n", @@ -464,7 +504,7 @@ " return thetas\n", "\n", "\n", - "def integrate(run_fn, bit_length: int, y_int: tuple, ks, shots=250) -> list:\n", + "def integrate(run_fn, bit_length: int, y_int: Tuple[float, float], ks: List[int], shots=250) -> List[float]:\n", " prev = 0\n", " (_, y) = y_int\n", " print(f\"integration for y in {y_int}\")\n", @@ -487,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -512,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -551,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -564,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -580,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -601,12 +641,12 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -632,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -644,7 +684,6 @@ " err = []\n", " f_y = list(map(f, ys))\n", " int_f_y = list(map(int_f, ys))\n", - " #int_f_y = list(map(lambda x : sum(f_y[1:x+1]) / n, range(len(ys))))\n", " for i in range(len(ys)):\n", " y = ys[i]\n", " g_y = int_f_y[i]\n", @@ -680,7 +719,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -689,12 +728,12 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -718,12 +757,12 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 61, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 682720dcef5bf2999bb505f0d2331d8dd00e8ea6 Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Thu, 8 Sep 2022 19:59:51 -0500 Subject: [PATCH 3/6] Apply PR feedback --- .../QuantumAmplitudeEstimation.ipynb | 320 +++++++++--------- 1 file changed, 159 insertions(+), 161 deletions(-) diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb index a39d4b31f35a..226abd3c2a06 100644 --- a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -30,22 +30,31 @@ "\n", "After running the circuit multiple times we estimate $a$ to be the probability of getting result $1$.\n", "\n", - "Our results improve if we build an $A$ that has the same $a$ but more qubits or by increasing the number of iterations $k$.\n", + "Our results improve if we build an $A$ that has the same $a$ acts on a greater number of qubits $n$ or by increasing the number of iterations $k$.\n", "Increasing $n$ comes at the cost of needing more qubits, whereas $k$ comes at the cost of higher circuit depth.\n" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing Q# environment...\n", + "." + ] + } + ], "source": [ "import qsharp" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -54,7 +63,11 @@ "import math\n", "import random\n", "from scipy import optimize\n", - "import pandas as pd" + "import pandas as pd\n", + "\n", + "import qsharp.azure\n", + "import datetime\n", + "from qsharp.azure import AzureJob" ] }, { @@ -73,7 +86,8 @@ "* Estimate the amplitudes at those given points\n", "* Calculate the Riemann integral using these values\n", "\n", - "The reason amplitude estimation is effective on quantum computer has quadratic speedup over classical computer when estimating amplitudes as this algorithm fundamentally builds on Grover's search.\n", + "The reason amplitude estimation is effective on quantum computers is that the quantum version has quadratic speedup over its classical counterpart. \n", + "This stems from the fact that the QAE algorithm fundamentally builds on Grover's search.\n", "\n", "For a circuit with $n+1$ qubits, we have one target qubit and $n$ control qubits.\n", "\n", @@ -85,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -139,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -203,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -248,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -257,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -265,7 +279,7 @@ "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -276,50 +290,50 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 2
116.0%28.57%116.0%28.57%
220.45%33.33%220.45%33.33%
423.17%36.36%423.17%36.36%
824.68%38.1%824.68%38.1%
1625.48%39.02%1625.48%39.02%
3225.9%39.51%3225.9%39.51%
6426.1%39.75%6426.1%39.75%
12826.21%39.88%12826.21%39.88%
\n", "
\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -330,44 +344,44 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 3
114.89%18.18%114.89%18.18%
219.28%20.0%219.28%20.0%
421.94%21.05%421.94%21.05%
823.41%21.62%823.41%21.62%
1624.19%21.92%1624.19%21.92%
3224.59%22.07%3224.59%22.07%
6424.79%22.15%6424.79%22.15%
12824.9%22.18%12824.9%22.18%
\n" @@ -376,7 +390,7 @@ "" ] }, - "execution_count": 52, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -421,7 +435,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -489,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 11, "metadata": { "scrolled": true }, @@ -497,10 +511,8 @@ "source": [ "def compute_theta(bit_length: int, y_int: Tuple[float, float]) -> List[float]:\n", " (y0, y) = y_int\n", - " thetas = []\n", - " for i in range(bit_length):\n", - " y_sc = i * (y - y0) / bit_length\n", - " thetas.append(2 * math.pi * (y_sc - y0))\n", + " y_scs = [i * (y - y0) / bit_length for i in range(bit_length)]\n", + " thetas = [2 * math.pi * (y_sc - y0) for y_sc in y_scs]\n", " return thetas\n", "\n", "\n", @@ -527,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -552,7 +564,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -591,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -604,7 +616,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -620,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -629,7 +641,6 @@ " f_y = list(map(f, ys))\n", " fig, ax = plt.subplots()\n", " ax.set_xlabel('y')\n", - " #int_f_y = list(map(lambda x : sum(f_y[1:x+1]) / n, range(len(ys))))\n", " int_fx_plot, = plt.plot(ys, int_f_y, color='g', label='$g(y) = \\int_{x=0}^y \\sin^2(\\pi x) dx$')\n", " apprx_plots = []\n", " for k, vals in k_vals.items(): \n", @@ -641,12 +652,12 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -672,11 +683,11 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "def epsilon_squared(x : float, expected : float) -> float:\n", + "def loss(x : float, expected : float) -> float: \n", " return (x - expected) ** 2\n", "\n", "def compute_err(ys : list, vals : list) -> list:\n", @@ -684,11 +695,7 @@ " err = []\n", " f_y = list(map(f, ys))\n", " int_f_y = list(map(int_f, ys))\n", - " for i in range(len(ys)):\n", - " y = ys[i]\n", - " g_y = int_f_y[i]\n", - " g_hat_y = vals[i]\n", - " err.append(epsilon_squared(g_hat_y, g_y))\n", + " err = [loss(g_hat_y, g_y) for g_hat_y, g_y in zip(vals, int_f_y)]\n", " return err\n", "\n", "def plot_err(ys, k_err : dict) -> None:\n", @@ -697,14 +704,14 @@ " ax.set_ylabel('error')\n", " err_plots = []\n", " for k, err in k_err.items(): \n", - " err_plot, = plt.plot(ys, err, colors[k], label='$\\epsilon^2(y)$, ' + f'k={k}')\n", + " err_plot, = plt.plot(ys, err, colors[k], label='$L(\\hat{y}, y)$, ' + f'k={k}')\n", " err_plots.append(err_plot)\n", " ax.legend(handles=err_plots)\n", "\n", "def plot_average_err(k_err_avg : dict) -> None:\n", " fig, ax = plt.subplots()\n", " ax.set_xlabel('$k$')\n", - " ax.set_ylabel('Average $\\epsilon^2$')\n", + " ax.set_ylabel('Frequentis risk (average error)')\n", " plt.bar(list(map(lambda x : str(x), k_err_avg.keys())), k_err_avg.values())\n", "\n", "def build_err(ys : list, k_vals : dict) -> tuple:\n", @@ -719,7 +726,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -728,12 +735,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -757,12 +764,12 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -783,50 +790,16 @@ "source": [ "As we'd expect, the error is trending downward with increasing $k$.\n", "\n", - "Let us now repeat the same on IonQ Harmony to see if the results are the same." + "Let us now repeat the same on IonQ Harmony to see if the results are the same.\n", + "\n", + "First, we will connect to the Azure Quantum service and select the IonQ harmony target." ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "import qsharp.azure\n", - "import datetime\n", - "from qsharp.azure import AzureJob" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we will connect to Azure Quantum and select the IonQ harmony target" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "application/x-qsharp-data": "\"Connecting to Azure Quantum...\"", - "text/plain": [ - "Connecting to Azure Quantum..." - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Connected to Azure Quantum workspace AdriansProjectWorkspace in location westus.\n" - ] - } - ], "source": [ "targets = qsharp.azure.connect(\n", " resourceId=\"\",\n", @@ -836,29 +809,28 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "This workspace's 10 targets:\n", - "- ionq.qpu (average queue time 1 day, 0:16:31)\n", - "- ionq.qpu.aria-1 (average queue time 0:31:54)\n", + "This workspace has 10 targets:\n", + "- ionq.qpu (average queue time 0:01:13)\n", + "- ionq.qpu.aria-1 (average queue time 3:40:44)\n", "- ionq.simulator (average queue time 0:00:02)\n", "- quantinuum.hqs-lt-s1 (average queue time 0:00:00)\n", - "- quantinuum.hqs-lt-s1-apival (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s1-apival (average queue time 0:00:01)\n", "- quantinuum.hqs-lt-s2 (average queue time 0:00:00)\n", - "- quantinuum.hqs-lt-s2-apival (average queue time 0:00:00)\n", - "- quantinuum.hqs-lt-s1-sim (average queue time 0:00:29)\n", - "- quantinuum.hqs-lt-s2-sim (average queue time 0:00:31)\n", + "- quantinuum.hqs-lt-s2-apival (average queue time 0:00:01)\n", + "- quantinuum.hqs-lt-s1-sim (average queue time 3:47:43)\n", + "- quantinuum.hqs-lt-s2-sim (average queue time 0:02:33)\n", "- quantinuum.hqs-lt (average queue time 0:00:00)\n" ] } ], "source": [ - "\n", "print(f\"This workspace has {len(targets)} targets:\")\n", "for target in targets:\n", " print(f\"- {target.id} (average queue time {datetime.timedelta(seconds=target.average_queue_time)})\")" @@ -866,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -880,10 +852,10 @@ { "data": { "text/plain": [ - "{'id': 'ionq.qpu', 'current_availability': {}, 'average_queue_time': 87391}" + "{'id': 'ionq.qpu', 'current_availability': {}, 'average_queue_time': 73}" ] }, - "execution_count": 45, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -901,7 +873,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -973,7 +945,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -985,7 +957,7 @@ } ], "source": [ - "y_k_jobs = submit_integration_jobs(bit_length=2,ys=ys,ks=ks)\n", + "#y_k_jobs = submit_integration_jobs(bit_length=2,ys=ys,ks=ks)\n", "\n", "clear_output(wait=True)\n", "print(\"Submitted all jobs successfully!\")" @@ -993,19 +965,44 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "import pickle\n", - "\n", + "import pickle\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ "with open('jobs-qpu.pkl', 'wb') as pkl_file:\n", " pickle.dump(y_k_jobs, pkl_file)\n" ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "with open('jobs-qpu.pkl', 'rb') as pkl_file:\n", + " y_k_jobs = pickle.load(pkl_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -1018,7 +1015,6 @@ ], "source": [ "y_k_job_results = get_all_job_results(y_k_jobs,)\n", - "\n", "clear_output(wait=True)\n", "print(\"Processed all results successfully!\")" ] @@ -1032,7 +1028,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 38, "metadata": {}, "outputs": [ { @@ -1071,12 +1067,12 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1093,7 +1089,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -1102,12 +1098,12 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1124,12 +1120,12 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEICAYAAACXo2mmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbY0lEQVR4nO3de5ReVZnn8e+PQMJFEWiijblYAQvtwIRbCRkBXSAuEkAiKnQYEYw9HTMr6VZ7lmMYtdtmmhlGW6ZFLiE4UYLYEZqLmTYOt5nBtcaOkJBMmoDRIuFSkNUEmCYImYQKz/xxdpk3lar33amcU2+d5PdZ6111zj577/c5hOSpc/Y++ygiMDMzK8N+7Q7AzMz2Hk4qZmZWGicVMzMrjZOKmZmVxknFzMxKs3+7A2inI488Mjo6OtodhplZraxcufKliBg70LF9Oql0dHSwYsWKdodhZlYrkp4Z7Jhvf5mZWWmcVMzMrDROKmZmVhonFTMzK42TipmZlcZJxczMSuOkYmZmpXFSMTOz0jipmJlZafbpJ+rN6qZj/k/bHUKWp685v90hWJv4SsXMzErjpGJmZqWpNKlImiZpnaRuSfMHOC5J16XjaySd3KqtpP+Q6q6WdL+kdzccuzLVXyfp3CrPzczMdlVZUpE0CrgBmA5MBi6VNLlftelAZ/rMBm7KaPutiJgSEScCfw/8eWozGZgJHAdMA25M/ZiZ2TCp8krlVKA7ItZHxDZgCTCjX50ZwOIoLAcOk3RUs7YRsbmh/SFANPS1JCK2RsQGoDv1Y2Zmw6TKpDIOeK5hvyeV5dRp2lbS1ZKeAz5NulLJ/D4zM6tQlUlFA5RFZp2mbSPiqxExAbgdmLcb34ek2ZJWSFqxadOmAQM3M7OhqTKp9AATGvbHAy9k1slpC/Aj4JO78X1ExMKI6IqIrrFjB3wbppmZDVGVSeVRoFPSJEmjKQbRl/arsxS4PM0Cmwq8GhEbm7WV1NnQ/kLgVw19zZQ0RtIkisH/R6o6OTMz21VlT9RHRK+kecB9wChgUUSslTQnHV8ALAPOoxhUfwOY1axt6voaSe8D3gKeAfr6WyvpDuAJoBeYGxHbqzo/MzPbVaXLtETEMorE0Vi2oGE7gLm5bVP5Jweo3nfsauDqocZrZsPLy87sffxEvZmZlcZJxczMSuOkYmZmpXFSMTOz0jipmJlZafySLvsdz8Qxsz3lpGJmVqJ9/Zcz3/4yM7PSOKmYmVlpnFTMzKw0TipmZlYaJxUzMytNy9lfkrqAM4F3A1uAx4EHI+KVimMzM7OaGfRKRdJnJT0GXAkcBKwDXgTOAB6QdKukicMTppmZ1UGzK5VDgNMjYstAByWdSPEirGcriMtsj+3rzwuYtcOgVyoRcQOwTdKXBjm+OiIeqiwyMzOrnaYD9enNiTOGKRYzM6u5nGVa/rek64EfA6/3FUbEY5VFZWZmtZSTVD6Yfl7VUBbA2eWHY2ZmddYyqUTEWcMRiJmZ1V/Lhx8lvUPStZJWpM+3Jb1jOIIzM7N6yXmifhHwGnBJ+mwGvl9lUGZmVk85YyrHRMQnG/b/UtLqiuIxM7May7lS2SLpjL4dSadTLNdiZma2k5wrlTnA4oZxlP8LXFFdSGZmVldNr1QkjQIui4gTgCnAlIg4KSLW5HQuaZqkdZK6Jc0f4LgkXZeOr5F0cqu2kr4l6Vep/j2SDkvlHZK2SFqdPgvy/hOYmVlZcp6oPyVtb46Izbkdp4R0AzAdmAxcKmlyv2rTKdYP6wRmAzdltH0AOD4ipgC/pljwss9TEXFi+szJjdXMzMqRc/trlaSlwJ3s/ET93S3anQp0R8R6AElLKJZ8eaKhzgxgcUQEsFzSYZKOAjoGaxsR9ze0Xw58KuMczMxsGOQM1B8BvEzxBP3H0ueCjHbjgOca9ntSWU6dnLYAnwN+1rA/SdIqSQ9LOnOgoCTN7nvmZtOmTRmnYWZmuZpeqaTbUC9FxJeH0LcGKIvMOi3bSvoq0Avcnoo2AhMj4mVJpwD3Sjqu/y27iFgILATo6urqH4+Zme2BpkklIrY3Dp7vph5gQsP+eOCFzDqjm7WVdAXF1dJH0q0zImIrsDVtr5T0FHAssGKI8ZuZ2W7KGVNZPcQxlUeBTkmTgOeBmcC/6ldnKTAvjZmcBrwaERslbRqsraRpwFeAD0fEG30dSRoLvJIS4dEUg//rM87PzMxKkpNUGsdU+gTQNKlERK+kecB9wChgUUSslTQnHV8ALAPOA7qBN4BZzdqmrq8HxlC80hhgeZrp9SHgKkm9wHZgTkS8knF+ZmZWkpxVimcNtfOIWEaROBrLFjRsBzA3t20qf+8g9e8C7hpqrGZmtudyVik+VtJDkh5P+1Mkfa360MzMrG5yphTfQvGA4ZsA6Wn6mVUGZWZm9ZSTVA6OiEf6lfVWEYyZmdVbTlJ5SdIxpOdEJH2K4pkQMzOzneTM/ppL8bDg+yU9D2wAPl1pVGZmVks5s7/WA+dIOgTYLyJeqz4sMzOro5wrFQAi4vXWtczMbF+WM6ZiZmaWxUnFzMxKk/Pw48GSvi7plrTfKSln6XszM9vH5FypfJ9i9d9/mfZ7gL+qLCIzM6utnKRyTER8kx1P1G9h4PedmJnZPi4nqWyTdBA7Hn48hvTeEjMzs0Y5U4r/AvjvwARJtwOnA5+tMigzM6unnIcfH5D0GDCV4rbXFyLipcojMzOz2mmZVBpeJ9y33tdESe8AnokILyxpZma/k3P760bgZGANxZXK8Wn79yTNiYj7K4zPzMxqJGeg/mngpIjoiohTgJOAx4FzgG9WGJuZmdVMTlJ5f8P74YmIJyiSzPrqwjIzszrKuf21TtJNwJK0/4fAryWNIT27sq/qmP/TdoeQ5elrzm93CGa2j8i5Uvks0A18EfgSsD6VvQmcVVFcZmZWQzlTircA306f/n5bekRmZlZbOVOKO4H/BEwGDuwrj4ijK4zLzMxqKHdByZuAXorbXYuB26oMyszM6iknqRwUEQ8BiohnIuIbwNk5nUuaJmmdpG5J8wc4LknXpeNrGh60HLStpG9J+lWqf4+kwxqOXZnqr5N0bk6MZmZWnpyk8v8k7Qf8RtI8SRcB72zVSNIo4AZgOsWts0slTe5XbTrQmT6zKa6IWrV9ADg+IqYAvwauTG0mAzOB44BpwI2pHzMzGyY5SeWLwMHAnwKnAJcBV2S0OxXojoj1EbGNYkryjH51ZgCLo7AcOEzSUc3aRsT9DcvDLAfGN/S1JCK2RsQGihlrp2bEaWZmJWmaVNJv+pdExG8joiciZkXEJ1MCaGUc8FzDfk8qy6mT0xbgc8DPduP7kDRb0gpJKzZt2pRxGmZmlqtpUomI7cApkobyUq6B2kRmnZZtJX2VYvLA7bvxfUTEwrTkTNfYsWMHaGJmZkOV80T9KuAnku4EXu8rjIi7W7TrASY07I8HXsisM7pZW0lXABcAH4mIvsSR831mZlahnDGVI4CXKWZ8fSx9Lsho9yjQKWmSpNEUg+hL+9VZClyeZoFNBV6NiI3N2kqaBnwFuDAi3ujX10xJYyRNohj8fyQjTjMzK0nOE/WzhtJxRPRKmgfcB4wCFkXEWklz0vEFwDLgPIpB9TeAWc3apq6vB8YAD6S7cssjYk7q+w7gCYrbYnPT7TszMxsmOU/UH0sx1fddEXG8pCkUVwl/1aptRCyjSByNZQsatgOYm9s2lb+3yfddDVzdKi4zM6tGzu2vWyieBXkTICLWUNyOMjMz20lOUjk4IvqPTfg1wmZmtoucpPKSpGNI03MlfYod76s3MzP7nZwpxXOBhcD7JT0PbAA+XWlUZmZWSzlJ5ZmIOEfSIcB+EfFa1UGZmVk95dz+2iBpITAVv5TLzMyayEkq7wMepLgNtkHS9ZLOqDYsMzOro5ZJJSK2RMQdEfEJ4CTgUODhyiMzM7PayblSQdKHJd0IPEbxSuFLKo3KzMxqKeeJ+g3AauAO4MsR8XrzFmZmtq/Kmf11QkRsrjwSMzOrvZyksk3SXIrX9B7YVxgRn6ssKjMzq6WcMZXbgN8HzqUYoB8P+FkVMzPbRU5SeW9EfB14PSJuBc4H/kW1YZmZWR3lJJU3089/lnQ88A6go7KIzMystnLGVBZKOhz4GsXbFd8GfL3SqMzMrJZy3vz4vbT5c+DoasMxM7M6G/T2l6TLJDU7foyXazEzs0bNrlR+D1glaSWwEthEMaX4vcCHgZeA+ZVHaGZmtTFoUomI70i6HjgbOB2YAmwBngQ+ExHPDk+IZmZWF03HVCJiO/BA+piZmTWVtaCkmZlZDicVMzMrTcukImnMAGVHVBOOmZnVWc6Vyt2SDujbkXQUHmMxM7MB5CSVe4E7JY2S1AHcB1yZ07mkaZLWSeqWtMv0YxWuS8fXSDq5VVtJF0taK+ktSV0N5R2StkhanT4LcmI0M7Py5DxRf4uk0RTJpQP4fET8olU7SaOAG4CPAj3Ao5KWRsQTDdWmA53pcxpwE3Bai7aPA58Abh7ga5+KiBNbxWZmZtUYNKlI+rPGXWACxRsgp0qaGhHXtuj7VKA7Itan/pYAM4DGpDIDWBwRASyXdFi6vdYxWNuIeDKVZZ+kmZkNj2a3v97e8HkbcA/Q3VDWyjjguYb9nlSWUyen7UAmSVol6WFJZw5UQdJsSSskrdi0aVNGl2ZmlqvZE/V/2b8srQX2tszXCw90KRGZdXLa9rcRmBgRL0s6BbhX0nH9Y42IhcBCgK6urlZ9mpnZbsiZUvwjSYdKOoTi1tU6SV/O6LuH4pZZn/HAC5l1ctruJCK2RsTLaXsl8BRwbEacZmZWkpzZX5PTb/sfB5YBE4HPZLR7FOiUNCkN9M+keB9Lo6XA5WkW2FTg1YjYmNl2J5LGpgF+JB1NMfi/PiNOMzMrSc5Lug5Iz6l8HLg+It6U1PK2UUT0SppHMQV5FLAoItZKmpOOL6BIUudRjNW8Acxq1hZA0kXAd4GxwE8lrY6Ic4EPAVdJ6gW2A3Mi4pXc/xBmZrbncpLKzcDTwP8Bfi7pPUDOmAoRsYwicTSWLWjYDmBubttUfg/FpIH+5XcBd+XEZWZm1ch5TuU64LqGomcknVVdSGZmVlfNnlO5LCJ+2O95lUatnlMxM7N9TLMrlUPSz5xnUszMzJo+p3Jzmk21OSL+yzDGZGZmNdV0SnF68+OFwxSLmZnVXM7sr1+kd9X/GHi9rzAiHqssKjMzq6WcpPLB9POqhrIAzi4/HDMzq7OcKcWePmxmZln8jnozMyuNk4qZmZXGScXMzEqTs/T9xZLenra/JunuxnfJm5mZ9cm5Uvl6RLwm6QzgXOBWinfJm5mZ7SQnqWxPP88HboqInwCjqwvJzMzqKiepPC/pZuASYJmkMZntzMxsH5OTHC6heFnWtIj4Z+AIIOd1wmZmto9ptvT9oek1wgcC/yuVHQFsBVYMS3RmZlYrzZ6o/xFwAbCSYlkWNRwL4OgK4zIzsxpqtvT9BennpOELx8zM6iznOZWHcsrMzMyajakcCBwMHCnpcHbc/joUePcwxGZmZjXTbEzl88AXKRLISnYklc3ADdWGZWZmddRsTOU7wHck/UlEfHcYYzIzs5rKeZ/KdyV9EOhorB8RiyuMy8zMaihnoP424K+BM4APpE9XTueSpklaJ6lb0vwBjkvSden4msaFKgdrmxa4XCvpLUld/fq7MtVfJ+ncnBjNzKw8Oa8T7gImR0TsTseSRlGMvXwU6AEelbQ0Ip5oqDYd6Eyf0ygWqjytRdvHgU8AN/f7vsnATOA4inGgByUdGxHbMTOzYZGzTMvjwO8Poe9Tge6IWB8R24AlwIx+dWYAi6OwHDhM0lHN2kbEkxGxboDvmwEsiYitEbEB6E79mJnZMMm5UjkSeELSIxRLtAAQERe2aDcOeK5hv4fiaqRVnXGZbQf6vuUD9LUTSbOB2QATJ05s0aWZme2OnKTyjSH2rQHK+t9CG6xOTtuhfB8RsRBYCNDV1bVbt/TMzKy5nNlfD0t6D9AZEQ9KOhgYldF3DzChYX888EJmndEZbYfyfWZmVqGc2V9/DPwdOwbGxwH3ZvT9KNApaZKk0RSD6Ev71VkKXJ5mgU0FXo2IjZlt+1sKzJQ0RtIkisH/RzLiNDOzkuTc/ppLMeD9S4CI+I2kd7ZqFBG9kuZRvItlFLAoItZKmpOOLwCWAedRDKq/Acxq1hZA0kXAd4GxwE8lrY6Ic1PfdwBPAL3AXM/8MjMbXjlJZWtEbJOKIQtJ+9N6fAOAiFhGkTgayxY0bAdF0spqm8rvAe4ZpM3VwNU5sZmZWflyphQ/LOnfAwdJ+ihwJ/Dfqg3LzMzqKCepzAc2Af9IscjkMuBrVQZlZmb1lDP76y3glvQxMzMbVMukImkDAz/v4dcJm5nZTnLX/upzIHAxcEQ14ZiZWZ21HFOJiJcbPs9HxN8AZ1cfmpmZ1U3O7a+TG3b3o7hyeXtlEZmZWW3l3P76dsN2L/A0cEkl0ZiZWa3lzP46azgCMTOz+su5/fVnzY5HxLXlhWNmZnWWO/vrA+xY0PFjwM/Z+X0nZmZm2S/pOjkiXgOQ9A3gzoj411UGZmZm9ZOzTMtEYFvD/jago5JozMys1nKuVG4DHpF0D8WT9RcBiyuNyszMailn9tfVkn4GnJmKZkXEqmrDMjOzOsq5/QVwMLA5Ir4D9KQ3K5qZme0k53XCfwF8BbgyFR0A/LDKoMzMrJ5yrlQuAi4EXgeIiBfwMi1mZjaAnKSyLb32NwAkHVJtSGZmVlc5SeUOSTcDh0n6Y+BB/MIuMzMbQNPZX5IE/Bh4P7AZeB/w5xHxwDDEZmZmNdM0qURESLo3Ik4BnEjMzKypnNtfyyV9oPJIzMys9nKeqD8LmCPpaYoZYKK4iJlSZWBmZlY/g16pSJqYNqcDR1O8QvhjwAXpZ0uSpklaJ6lb0vwBjkvSden4msa3TA7WVtIRkh6Q9Jv08/BU3iFpi6TV6bMgJ0YzMytPs9tf9wJExDPAtRHxTOOnVceSRgE3UCSlycClkib3qzYd6Eyf2cBNGW3nAw9FRCfwUNrv81REnJg+c1rFaGZm5WqWVNSwffQQ+j4V6I6I9RGxDVgCzOhXZwawOArLKaYtH9Wi7Qzg1rR9K/DxIcRmZmYVaJZUYpDtXOPY+UVePaksp06ztu+KiI0A6ec7G+pNkrRK0sOSzmQAkmZLWiFpxaZNm3b3nMzMrIlmA/UnSNpMccVyUNqGHQP1h7boWwOU9U9Og9XJadvfRmBiRLws6RTgXknHRcTmxkoRsRBYCNDV1TWUZGlmZoMYNKlExKg97LsHmNCwPx54IbPO6CZt/0nSURGxMd0qezHFuxXYmrZXSnoKOBZYsYfnYWZmmXKXvh+KR4FOSZMkjQZmsuM9932WApenWWBTgVfTLa1mbZcCV6TtK4CfAEgamwb4kXQ0xeD/+upOz8zM+st5TmVIIqJX0jzgPmAUsCgi1kqak44vAJYB5wHdwBvArGZtU9fXUKxH9kfAs8DFqfxDwFWSeoHtwJyIeKWq8zMzs11VllQAImIZReJoLFvQsB3A3Ny2qfxl4CMDlN8F3LWHIZuZ2R6o8vaXmZntY5xUzMysNE4qZmZWGicVMzMrjZOKmZmVxknFzMxK46RiZmalcVIxM7PSOKmYmVlpnFTMzKw0TipmZlYaJxUzMyuNk4qZmZXGScXMzErjpGJmZqVxUjEzs9I4qZiZWWmcVMzMrDROKmZmVhonFTMzK42TipmZlcZJxczMSuOkYmZmpXFSMTOz0jipmJlZaSpNKpKmSVonqVvS/AGOS9J16fgaSSe3aivpCEkPSPpN+nl4w7ErU/11ks6t8tzMzGxXlSUVSaOAG4DpwGTgUkmT+1WbDnSmz2zgpoy284GHIqITeCjtk47PBI4DpgE3pn7MzGyYVHmlcirQHRHrI2IbsASY0a/ODGBxFJYDh0k6qkXbGcCtaftW4OMN5UsiYmtEbAC6Uz9mZjZM9q+w73HAcw37PcBpGXXGtWj7rojYCBARGyW9s6Gv5QP0tRNJsymuigB+K2ld7gkNkyOBl8rsUP+5zN52m8+nhTafD+x957S3nQ+MvHN6z2AHqkwqGqAsMuvktB3K9xERC4GFLfpqG0krIqKr3XGUxecz8u1t57S3nQ/U65yqvP3VA0xo2B8PvJBZp1nbf0q3yEg/X9yN7zMzswpVmVQeBTolTZI0mmIQfWm/OkuBy9MssKnAq+nWVrO2S4Er0vYVwE8aymdKGiNpEsXg/yNVnZyZme2qsttfEdEraR5wHzAKWBQRayXNSccXAMuA8ygG1d8AZjVrm7q+BrhD0h8BzwIXpzZrJd0BPAH0AnMjYntV51ehEXtrboh8PiPf3nZOe9v5QI3OSRGthirMzMzy+Il6MzMrjZOKmZmVxkllhGi1pE3dSFok6UVJj7c7ljJImiDpf0p6UtJaSV9od0xlkDRK0ipJf9/uWMog6Uvpz+dxSX8r6cB2x7S7Bvu7I+lP0r8RayV9s13xteKkMgJkLmlTNz+gWC5nb9EL/NuI+ANgKjB3L/gzAvgC8GS7gyiDpHHAnwJdEXE8xSSfme2Nakh+QL+/O5LOolg1ZEpEHAf8dRviyuKkMjLkLGlTKxHxc+CVdsdRlojYGBGPpe3XKP4h3mXFhjqRNB44H/heu2Mp0f7AQZL2Bw6mhs+qDfJ3598A10TE1lTnxV0ajhBOKiPDYMvV2AgkqQM4Cfhlm0PZU38D/DvgrTbHUYqIeJ7iN/hngY0Uz73d396oSnMscKakX0p6WNIH2h3QYJxURoahLEtjbSDpbcBdwBcjYnO74xkqSRcAL0bEynbHUpb0GowZwCTg3cAhki5rb1Sl2R84nOLW65cpntUb6N+NtnNSGRm8xEwNSDqAIqHcHhF3tzuePXQ6cKGkpylut54t6YftDWmPnQNsiIhNEfEmcDfwwTbHVJYe4O60ovsjFFeXR7Y5pgE5qYwMOUvaWBul3wr/K/BkRFzb7nj2VERcGRHjI6KD4v+3/xERdf+t/llgqqSD05/XR9hLJiEA9wJnA0g6FhhNyasWl8VJZQSIiF6gb1maJ4E7GpalqSVJfwv8A/A+ST1pWZ06Ox34DMVv9KvT57x2B2U7RMQvgb8DHgP+keLft9osb9JnkL87i4Cj0zTjJcAVMUKXQ/EyLWZmVhpfqZiZWWmcVMzMrDROKmZmVhonFTMzK42TipmZlcZJxczMSuOkYmZmpXFSMRthJJ0j6bZ2x2E2FE4qZiPPCcCqdgdhNhROKmYjzwnAKkljJP1A0n8cqSvSmvW3f7sDMLNdnAC8SLEW3Pciou6rB9s+xGt/mY0gaXn9l4BngM9HxD+0OSSz3eLbX2Yjy2SKVyH0AtvbHIvZbnNSMRtZTgB+QfGOk+9Leleb4zHbLU4qZiPLCcDjEfFr4CsUr409oM0xmWXzmIqZmZXGVypmZlYaJxUzMyuNk4qZmZXGScXMzErjpGJmZqVxUjEzs9I4qZiZWWn+PxwXOECIT9u6AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1150,11 +1146,13 @@ "source": [ "In our graph we see our results are not as on the simulator. \n", "In fact, in our testing $k=0$ performed better than any other $k$.\n", - "This comes down to the noise effects of the additional gates we need for the larger values of $k$.\n", + "This comes down to the noise incurred by the additional gates that we need to apply for the larger values of $k$.\n", "This is an interesting result because it shows considerations for current quantum computers that a perfect simulator does not depict: Every gate introduces noise.\n", - "So one of our goals must be to reduce circuit depth. \n", + "As a result, one of our goals must be to reduce circuit depth. \n", "Despite having the reduced depth already using the spin echo optimization, we still have noise effects. \n", - "Without this optimization's circuit depth reduction we'd expect noise to be even higher.\n" + "Without this optimization's circuit depth reduction we'd expect noise to be even higher.\n", + "But we can see that even with very few qubits and high noise we were able to approximate our integral quite closely.\n", + "That means that there is a lot more to explore with what we can do on current hardware.\n" ] } ], From 5e30f646409a16b5f2ef86802f7ccaf2b5b7d4bd Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Fri, 9 Sep 2022 09:59:54 -0500 Subject: [PATCH 4/6] Apply PR feedback --- .../QuantumAmplitudeEstimation.ipynb | 144 +++++++++--------- 1 file changed, 72 insertions(+), 72 deletions(-) diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb index 226abd3c2a06..a31cb30e9333 100644 --- a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -133,7 +133,7 @@ "outputs": [], "source": [ "%%qsharp\n", - "operation A(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + "operation PrepareState(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl { // Corresponds to operator A\n", " EqualityFactI(Length(theta), Length(ctls) + 1, \"Thetas and controls must have same length\");\n", " ApplyToEachCA(H, ctls);\n", " Ry(theta[0], target);\n", @@ -158,10 +158,10 @@ "outputs": [], "source": [ "%%qsharp\n", - "operation Q(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + "operation Rotate(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl { // Corresponds to operator Q\n", " Z(target);\n", " within {\n", - " Adjoint A(theta, ctls, target);\n", + " Adjoint PrepareState(theta, ctls, target);\n", " ApplyToEachCA(X, ctls + [target]); // Turns |0...0> into |1...1> (i.e., enabling the controlled Z to reflect)\n", " } apply {\n", " Controlled Z (ctls, target);\n", @@ -184,11 +184,11 @@ "outputs": [], "source": [ "%%qsharp\n", - "operation RunQAE(theta : Double[], k : Int) : Result {\n", + "operation EstimateAmplitude(theta : Double[], k : Int) : Result {\n", " use ctls = Qubit[Length(theta) - 1];\n", " use target = Qubit();\n", - " A(theta, ctls, target);\n", - " RepeatCA(Q, k, (theta, ctls, target));\n", + " PrepareState(theta, ctls, target);\n", + " RepeatCA(Rotate, k, (theta, ctls, target));\n", " let res = MResetZ(target);\n", " ResetAll(ctls);\n", " return res;\n", @@ -198,8 +198,8 @@ " return Count(res -> res == One, DrawMany(op, n, input));\n", "}\n", "\n", - "operation RunNQAE(n : Int, theta : Double[], k : Int) : Int {\n", - " return CountOneResults(RunQAE, n, (theta, k));\n", + "operation EstimateAmplitudeNShots(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(EstimateAmplitude, n, (theta, k));\n", "}\n" ] }, @@ -222,8 +222,8 @@ "outputs": [], "source": [ "%%qsharp\n", - "operation QSpinEcho(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", - " A(Mapped(x -> 2.0 * x, theta), ctls, target);\n", + "operation RotateSpinEcho(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + " PrepareState(Mapped(x -> 2.0 * x, theta), ctls, target);\n", " ApplyToEachCA(H, ctls);\n", " Z(target);\n", " within {\n", @@ -234,19 +234,19 @@ " \n", "}\n", "\n", - "operation RunQAESpinEcho(theta : Double[], k : Int) : Result {\n", + "operation EstimateAmplitudeSpinEcho(theta : Double[], k : Int) : Result {\n", " use ctls = Qubit[Length(theta) - 1];\n", " use target = Qubit();\n", - " RepeatCA(QSpinEcho, k, (theta, ctls, target));\n", - " A(theta, ctls, target);\n", + " RepeatCA(RotateSpinEcho, k, (theta, ctls, target));\n", + " PrepareState(theta, ctls, target);\n", " ApplyToEachCA(H, ctls);\n", " let res = MResetZ(target);\n", " ResetAll(ctls);\n", " return res;\n", "}\n", "\n", - "operation RunNQAESpinEcho(n : Int, theta : Double[], k : Int) : Int {\n", - " return CountOneResults(RunQAESpinEcho, n, (theta, k));\n", + "operation EstimateAmplitudeNShotsSpinEcho(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(EstimateAmplitudeSpinEcho, n, (theta, k));\n", "}" ] }, @@ -279,7 +279,7 @@ "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -290,50 +290,50 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 2
116.0%28.57%116.0%28.57%
220.45%33.33%220.45%33.33%
423.17%36.36%423.17%36.36%
824.68%38.1%824.68%38.1%
1625.48%39.02%1625.48%39.02%
3225.9%39.51%3225.9%39.51%
6426.1%39.75%6426.1%39.75%
12826.21%39.88%12826.21%39.88%
\n", "
\n", - "\n", + "
\n", " \n", " \n", " \n", @@ -344,44 +344,44 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
Differences with Spin Echo optimization at bit length 3
114.89%18.18%114.89%18.18%
219.28%20.0%219.28%20.0%
421.94%21.05%421.94%21.05%
823.41%21.62%823.41%21.62%
1624.19%21.92%1624.19%21.92%
3224.59%22.07%3224.59%22.07%
6424.79%22.15%6424.79%22.15%
12824.9%22.18%12824.9%22.18%
\n" @@ -401,8 +401,8 @@ " deltas = []\n", " theta = list(map(lambda _ : random.uniform(0, 3.14), range(bitlen))) # Random thetas\n", " for k in map(lambda x : 2 ** x, range(8)):\n", - " spin_echo_res = RunQAESpinEcho.estimate_resources(theta=theta, k=k)\n", - " res = RunQAE.estimate_resources(theta=theta, k=k)\n", + " spin_echo_res = EstimateAmplitudeSpinEcho.estimate_resources(theta=theta, k=k)\n", + " res = EstimateAmplitude.estimate_resources(theta=theta, k=k)\n", "\n", " def delta(key : str) -> int:\n", " return (res[key] - spin_echo_res[key])\n", @@ -591,7 +591,7 @@ } ], "source": [ - "k_vals = get_results(RunNQAESpinEcho.simulate)" + "k_vals = get_results(EstimateAmplitudeNShotsSpinEcho.simulate)" ] }, { @@ -657,7 +657,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -740,7 +740,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -769,7 +769,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -882,7 +882,7 @@ " # Run Amplitude estimation\n", " k_jobs = dict()\n", " for k in ks:\n", - " k_jobs[k] = qsharp.azure.submit(RunQAESpinEcho, jobName = f\"QAE for bit length {bit_length}, k={k}, y_int={y_int}\", shots=shots, theta=theta, k=k)\n", + " k_jobs[k] = qsharp.azure.submit(EstimateAmplitudeSpinEcho, jobName = f\"QAE for bit length {bit_length}, k={k}, y_int={y_int}\", shots=shots, theta=theta, k=k)\n", " return k_jobs\n", "\n", "def submit_integration_jobs(bit_length: int, ys : list, ks, shots=250):\n", From 9aa578456b982358d85269fb9ca20850f8b26c18 Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Fri, 9 Sep 2022 13:11:10 -0500 Subject: [PATCH 5/6] Fix operation vs operator --- .../QuantumAmplitudeEstimation.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb index a31cb30e9333..acbde311acc3 100644 --- a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -13,13 +13,13 @@ "\n", "In this sample we cover techniques of visualizing results and seeing noise on hardware in action.\n", "\n", - "The basics of QAE are that we are given an operator $A$ with the following properties\n", + "The basics of QAE are that we are given an operation implementation a unitary $A$ with the following properties\n", "\n", "$$A\\ket{0}_{n+1} = \\sqrt{1-a}\\ket{\\psi_0}_n\\ket{0} + \\sqrt{a}\\ket{\\psi_1}_n\\ket{1}$$\n", "\n", "with $\\psi_0$ and $\\psi_1$ being arbitrary states.\n", "\n", - "From this we construct the operators:\n", + "From this we construct the operations implementing the following operators:\n", "\n", "- $S_{\\psi_0}, S_{\\psi_1}$, which are reflections across $\\psi_0$ and $\\psi_1$ respectively\n", "- $Q=A S_{\\psi_0} A^\\dagger S_{\\psi_1}$ as the full operator\n", From 73f0bfdaf64edde1fd4ed5d944f5453f0ba56ebc Mon Sep 17 00:00:00 2001 From: Adrian Lehmann Date: Fri, 9 Sep 2022 15:42:42 -0500 Subject: [PATCH 6/6] Add IDE type information for Q# callables --- .../QuantumAmplitudeEstimation.ipynb | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb index acbde311acc3..086fd304d393 100644 --- a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -177,6 +177,17 @@ "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ " ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Not required, but can be helpful to provide type information to some IDEs.\n", + "EstimateAmplitude: qsharp.QSharpCallable = None\n", + "EstimateAmplitudeNShots: qsharp.QSharpCallable = None" + ] + }, { "cell_type": "code", "execution_count": 6, @@ -215,6 +226,17 @@ "Please refer to [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) for more details on why it works. \n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Not required, but can be helpful to provide type information to some IDEs.\n", + "EstimateAmplitudeSpinEcho: qsharp.QSharpCallable = None\n", + "EstimateAmplitudeNShotsSpinEcho: qsharp.QSharpCallable = None" + ] + }, { "cell_type": "code", "execution_count": 7,