diff --git a/community/ignis/RB_overview.ipynb b/community/ignis/RB_overview.ipynb index 39c684af8..8406dc93f 100644 --- a/community/ignis/RB_overview.ipynb +++ b/community/ignis/RB_overview.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Note: Trusted Notebook\" width=\"500 px\" align=\"left\">" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -8,34 +15,17 @@ "\n", "### Contributors\n", "\n", - "Shelly Garion$^{1}$, Yael Ben-Haim$^{2}$ and David McKay$^{2}$\n", + "Shelly Garion$^{1}$, Yael Ben-Haim$^{1}$ and David McKay$^{2}$\n", "\n", "1. IBM Research Haifa, Haifa University Campus, Mount Carmel Haifa, Israel\n", - "2. IBM T.J. Watson Research Center, Yorktown Heights, NY, USA\n", - "\n", - "### References\n", - "\n", - "1. Easwar Magesan, J. M. Gambetta, and Joseph Emerson, Robust randomized benchmarking of quantum processes,\n", - "https://arxiv.org/pdf/1009.3639\n", - "\n", - "2. Easwar Magesan,, Jay M. Gambetta, and Joseph Emerson, Characterizing Quantum Gates via Randomized Benchmarking,\n", - "https://arxiv.org/pdf/1109.6887\n", - "\n", - "3. A. D. C'orcoles, Jay M. Gambetta, Jerry M. Chow, John A. Smolin, Matthew Ware, J. D. Strand, B. L. T. Plourde, and M. Steffen, Supplementary material for ''Process verification of two-qubit quantum gates by randomized benchmarking'', https://arxiv.org/pdf/1210.7011\n", - "\n", - "4. Jay M. Gambetta, A. D. C´orcoles, S. T. Merkel, B. R. Johnson, John A. Smolin, Jerry M. Chow,\n", - "Colm A. Ryan, Chad Rigetti, S. Poletto, Thomas A. Ohki, Mark B. Ketchen, and M. Steffen,\n", - "Characterization of addressability by simultaneous randomized benchmarking, https://arxiv.org/pdf/1204.6308\n", - "\n", - "5. David C. McKay, Sarah Sheldon, John A. Smolin, Jerry M. Chow, and Jay M. Gambetta, Three Qubit Randomized Benchmarking,\n", - "https://arxiv.org/pdf/1712.06550" + "2. IBM T.J. Watson Research Center, Yorktown Heights, NY, USA\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Intorduction\n", + "## Introduction\n", "\n", "One of the main challenges in building a quantum information processor is the non-scalability of completely\n", "characterizing the noise affecting a quantum system via process tomography. In addition, process tomography is sensitive to noise in the pre- and post rotation gates plus the measurements (SPAM errors). Gateset tomography can take these errors into account, but the scaling is even worse. A complete characterization\n", @@ -44,7 +34,24 @@ "\n", "Since complete process tomography is infeasible for large systems, there is growing interest in scalable\n", "methods for partially characterizing the noise affecting a quantum system. A scalable (in the number $n$ of qubits comprising the system) and robust algorithm for benchmarking the full set of Clifford gates by a single parameter using randomization techniques was presented in [1]. The concept of using randomization methods for benchmarking quantum gates is commonly called **Randomized Benchmarking\n", - "(RB)**." + "(RB)**.\n", + "\n", + "\n", + "### References\n", + "\n", + "1. Easwar Magesan, J. M. Gambetta, and Joseph Emerson, *Robust randomized benchmarking of quantum processes*,\n", + "https://arxiv.org/pdf/1009.3639\n", + "\n", + "2. Easwar Magesan, Jay M. Gambetta, and Joseph Emerson, *Characterizing Quantum Gates via Randomized Benchmarking*,\n", + "https://arxiv.org/pdf/1109.6887\n", + "\n", + "3. A. D. C'orcoles, Jay M. Gambetta, Jerry M. Chow, John A. Smolin, Matthew Ware, J. D. Strand, B. L. T. Plourde, and M. Steffen, *Process verification of two-qubit quantum gates by randomized benchmarking*, https://arxiv.org/pdf/1210.7011\n", + "\n", + "4. Jay M. Gambetta, A. D. C´orcoles, S. T. Merkel, B. R. Johnson, John A. Smolin, Jerry M. Chow,\n", + "Colm A. Ryan, Chad Rigetti, S. Poletto, Thomas A. Ohki, Mark B. Ketchen, and M. Steffen,\n", + "*Characterization of addressability by simultaneous randomized benchmarking*, https://arxiv.org/pdf/1204.6308\n", + "\n", + "5. David C. McKay, Sarah Sheldon, John A. Smolin, Jerry M. Chow, and Jay M. Gambetta, *Three Qubit Randomized Benchmarking*, https://arxiv.org/pdf/1712.06550" ] }, { @@ -53,14 +60,14 @@ "source": [ "## The Randomized Benchmarking Protocol\n", "\n", - "A RB protocol consists of the following steps:\n", + "A RB protocol (see [1,2]) consists of the following steps:\n", "\n", "(We should first import the relevant qiskit classes for the demonstration)." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -89,14 +96,14 @@ "that should return the qubits to the initial state.\n", "\n", "More precisely, for each length $m$, we choose $K_m$ RB sequences. \n", - "Each such sequence contains $m$ random elements $C_{i_j}$ chosen uniformly from the Clifford group on $n$-qubits, and the $m+1$ element is defined as follows: $C_{i_{m+1}} = (C_{i_1}\\cdot ... \\cdot C_{i_m})^{-1}$.\n", + "Each such sequence contains $m$ random elements $C_{i_j}$ chosen uniformly from the Clifford group on $n$-qubits, and the $m+1$ element is defined as follows: $C_{i_{m+1}} = (C_{i_1}\\cdot ... \\cdot C_{i_m})^{-1}$. It can be found efficiently by the Gottesmann-Knill theorem.\n", "\n", "For example, we generate below several sequences of 2-qubit Clifford circuits." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -106,7 +113,7 @@ "nQ=2 \n", "rb_opts = {}\n", "#Number of Cliffords in the sequence\n", - "rb_opts['length_vector'] = [1, 10, 20, 50, 75, 100, 125]\n", + "rb_opts['length_vector'] = [1, 10, 20, 50, 75, 100, 125, 150, 175]\n", "#Number of seeds (random sequences)\n", "rb_opts['nseeds'] = 5 \n", "#Default pattern\n", @@ -124,31 +131,31 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " ┌───┐┌─────┐┌───┐ ┌───┐┌───┐┌───┐ ░ ┌───┐┌─────┐»\n", - "qr_0: |0>┤ H ├┤ Sdg ├┤ H ├──■───────────────────┤ H ├┤ S ├┤ X ├─░─┤ X ├┤ Sdg ├»\n", - " └───┘└─────┘└───┘┌─┴─┐┌─────┐┌───┐┌───┐└───┘└───┘└───┘ ░ └───┘└─────┘»\n", - "qr_1: |0>─────────────────┤ X ├┤ Sdg ├┤ H ├┤ X ├────────────────░─────────────»\n", - " └───┘└─────┘└───┘└───┘ ░ »\n", - " cr_0: 0 ═════════════════════════════════════════════════════════════════════»\n", - " »\n", - " cr_1: 0 ═════════════════════════════════════════════════════════════════════»\n", - " »\n", - "« ┌───┐ ┌───┐┌───┐┌───┐┌─┐\n", - "«qr_0: ┤ H ├─────────────────■─────┤ H ├┤ S ├┤ H ├┤M├\n", - "« └───┘┌───┐┌───┐┌───┐┌─┴─┐┌─┐└───┘└───┘└───┘└╥┘\n", - "«qr_1: ─────┤ X ├┤ H ├┤ S ├┤ X ├┤M├────────────────╫─\n", - "« └───┘└───┘└───┘└───┘└╥┘ ║ \n", - "«cr_0: ══════════════════════════╬═════════════════╩═\n", - "« ║ \n", - "«cr_1: ══════════════════════════╩═══════════════════\n", - "« \n" + " ┌───┐┌───┐┌───┐ ░ ┌───┐┌─────┐┌───┐ ┌─┐»\n", + "qr_0: |0>──────────────■───────┤ H ├┤ S ├┤ Y ├─░─┤ Y ├┤ Sdg ├┤ H ├───────■──┤M├»\n", + " ┌─────┐┌───┐┌─┴─┐┌───┐└───┘└───┘└───┘ ░ └───┘└─────┘└───┘┌───┐┌─┴─┐└╥┘»\n", + "qr_1: |0>┤ Sdg ├┤ H ├┤ X ├┤ Y ├────────────────░──────────────────┤ Y ├┤ X ├─╫─»\n", + " └─────┘└───┘└───┘└───┘ ░ └───┘└───┘ ║ »\n", + " cr_0: 0 ════════════════════════════════════════════════════════════════════╩═»\n", + " »\n", + " cr_1: 0 ══════════════════════════════════════════════════════════════════════»\n", + " »\n", + "« \n", + "«qr_0: ─────────────\n", + "« ┌───┐┌───┐┌─┐\n", + "«qr_1: ┤ H ├┤ S ├┤M├\n", + "« └───┘└───┘└╥┘\n", + "«cr_0: ═══════════╬═\n", + "« ║ \n", + "«cr_1: ═══════════╩═\n", + "« \n" ] } ], @@ -166,11 +173,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "#Create a new circuit without the measurement\n", + "# Create a new circuit without the measurement\n", "qc = qiskit.QuantumCircuit(*rb_circs[0][-1].qregs,*rb_circs[0][-1].cregs)\n", "for i in rb_circs[0][-1][0:-nQ]:\n", " qc._attach(i)" @@ -178,34 +185,22 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "#Create a new circuit without the measurement\n", - "qc = qiskit.QuantumCircuit(*rb_circs[0][-1].qregs,*rb_circs[0][-1].cregs)\n", - "for i in rb_circs[0][-1][0:-nQ]:\n", - " qc._attach(i)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[-0.707-0.707j 0. +0.j 0. +0.j 0. +0.j ]\n", - " [ 0. -0.j -0.707-0.707j -0. +0.j 0. +0.j ]\n", - " [ 0. +0.j 0. +0.j -0.707-0.707j 0. +0.j ]\n", - " [ 0. -0.j 0. +0.j 0. +0.j -0.707-0.707j]]\n" + "[[-0.707+0.707j 0. +0.j 0. +0.j 0. +0.j ]\n", + " [ 0. +0.j -0.707+0.707j 0. -0.j 0. +0.j ]\n", + " [ 0. +0.j -0. +0.j -0.707+0.707j 0. +0.j ]\n", + " [ 0. +0.j -0. +0.j 0. +0.j -0.707+0.707j]]\n" ] } ], "source": [ - "#The Unitary is an identity (with a global phase)\n", + "# The Unitary is an identity (with a global phase)\n", "backend = qiskit.Aer.get_backend('unitary_simulator')\n", "basis_gates = ['u1','u2','u3','cx'] # use U,CX for now\n", "basis_gates_str = ','.join(basis_gates)\n", @@ -228,18 +223,18 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Run on a noisy simulator\n", "noise_model = NoiseModel()\n", - "noise_model.add_all_qubit_quantum_error(depolarizing_error(0.002, 1), ['u1', 'u2', 'u3'])\n", - "noise_model.add_all_qubit_quantum_error(depolarizing_error(0.002, 2), 'cx')\n", + "# Depolarizing_error\n", + "dp = 0.002 \n", + "noise_model.add_all_qubit_quantum_error(depolarizing_error(dp, 1), ['u1', 'u2', 'u3'])\n", + "noise_model.add_all_qubit_quantum_error(depolarizing_error(dp, 2), 'cx')\n", "\n", - "backend = qiskit.Aer.get_backend('qasm_simulator')\n", - "basis_gates = 'u1,u2,u3,cx'\n", - "result_list = []" + "backend = qiskit.Aer.get_backend('qasm_simulator')" ] }, { @@ -252,9 +247,9 @@ "is measured. \n", "Here $\\rho_\\psi$ is the initial state taking into account preparation errors and $E_\\psi$ is the\n", "POVM element that takes into account measurement errors.\n", - "In the ideal (noise-free) case $\\rho_\\psi = E_\\psi = |\\psi \\rangle \\langle \\psi|$. \n", + "In the ideal (noise-free) case $\\rho_\\psi = E_\\psi = | \\psi {\\rangle} {\\langle} \\psi |$. \n", "\n", - "In practice one can measure the probability to go back to the exact initial state, i.e. all the qubits in the ground state ($|00...0\\rangle$) or just the probability for one of the qubits to return back to the ground state. Measuring the qubits independently can be more convenient if a correlated measurement scheme is not possible. Both measurements will fit to the same decay parameter according to the properties of the twirl. " + "In practice one can measure the probability to go back to the exact initial state, i.e. all the qubits in the ground state $ {|} 00...0 {\\rangle}$ or just the probability for one of the qubits to return back to the ground state. Measuring the qubits independently can be more convenient if a correlated measurement scheme is not possible. Both measurements will fit to the same decay parameter according to the properties of the twirl. " ] }, { @@ -263,10 +258,11 @@ "source": [ "### Step 4: Find the averaged sequence fidelity\n", "\n", - "Average over the $K_m$ random realizations to find the averaged sequence **fidelity**,\n", - "$$F_{seq}(m,\\psi) = Tr[E_\\psi \\textit{S}_{K_m}(\\rho_\\psi)]$$\n", + "Average over the $K_m$ random realizations of the sequence to find the averaged sequence **fidelity**,\n", + "$$F_{seq}(m,|\\psi{\\rangle}) = Tr[E_\\psi \\textit{S}_{K_m}(\\rho_\\psi)]$$\n", "where \n", - "$$\\textit{S}_{K_m} = \\frac{1}{K_m} \\sum_{\\textbf{i}_\\textbf{m}} \\textit{S}_{\\textbf{i}_\\textbf{m}}$$" + "$$\\textit{S}_{K_m} = \\frac{1}{K_m} \\sum_{\\textbf{i}_\\textbf{m}} \\textit{S}_{\\textbf{i}_\\textbf{m}}$$\n", + "is the average sequence operation." ] }, { @@ -275,45 +271,193 @@ "source": [ "### Step 5: Fit the results\n", "\n", - "Repeat Steps 1 through 4 for different values of $m$ and fit the\n", - "Fit the results for the averaged sequence delity to the model:\n", - "$$ \\textit{F}_g(m,|\\psi \\rangle ) = A_0 p^m +B_0$$\n", + "Repeat Steps 1 through 4 for different values of $m$ and fit the results for the averaged sequence fidelity to the model:\n", + "$$ \\textit{F}_{seq}^{(0)} \\big(m,{|}\\psi {\\rangle} \\big) = A_0 \\alpha^m +B_0$$\n", "where $A_0$ and $B_0$ absorb state preparation and measurement errors as well as an edge effect from the\n", "error on the final gate.\n", "\n", - "$p$ determines the average error-rate $r$, which is also called **Error per Clifford (EPC)** \n", - "according to the relation $$ r = 1-p-\\frac{1-p}{2^n} = \\frac{2^n-1}{2^n}(1-p)$$" + "$\\alpha$ determines the average error-rate $r$, which is also called **Error per Clifford (EPC)** \n", + "according to the relation $$ r = 1-\\alpha-\\frac{1-\\alpha}{2^n} = \\frac{2^n-1}{2^n}(1-\\alpha)$$\n", + "(where $n=nQ$ is the number of qubits).\n", + "\n", + "As an example, we calculate the average sequence fidelity for each of the RB sequences, fit the results to the exponential curve, and compute the paraemters $\\alpha$ and EPC." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "After seed 0, EPC 0.011154\n", - "After seed 1, EPC 0.011494\n", - "After seed 2, EPC 0.010545\n", - "After seed 3, EPC 0.011478\n", - "After seed 4, EPC 0.011082\n" + "After seed 0, alpha: 0.984443, EPC: 0.011668\n", + "After seed 1, alpha: 0.984050, EPC: 0.011962\n", + "After seed 2, alpha: 0.984245, EPC: 0.011816\n", + "After seed 3, alpha: 0.984849, EPC: 0.011363\n", + "After seed 4, alpha: 0.985262, EPC: 0.011053\n" ] } ], "source": [ - "#Create the RB fitter\n", + "qobj_list = []\n", + "# Create the RB fitter\n", "rb_fit = rb.RBFitter(None, xdata, rb_opts['rb_pattern'])\n", "for rb_seed,rb_circ_seed in enumerate(rb_circs):\n", " qobj = qiskit.compile(rb_circ_seed,\n", " backend=backend,\n", - " basis_gates=basis_gates)\n", + " basis_gates=basis_gates_str)\n", " job = backend.run(qobj, noise_model=noise_model)\n", + " qobj_list.append(qobj) \n", "\n", - " #add data to the fitter\n", + " # Add data to the fitter\n", " rb_fit.add_data(job.result())\n", - " print('After seed %d, EPC %f'%(rb_seed,rb_fit.fit[0]['epc']))" + " print('After seed %d, alpha: %f, EPC: %f'%(rb_seed,rb_fit.fit[0]['params'][1], rb_fit.fit[0]['epc']))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "ax = plt.subplot(1, 1, 1)\n", + "\n", + "# Plot the essence by calling plot_rb_data\n", + "rb_fit.plot_rb_data(0, ax=ax, add_label=True, show_plt=False)\n", + " \n", + "# Add title and label\n", + "ax.set_title('%d Qubit RB'%(nQ), fontsize=18)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The intuition behind RB\n", + "\n", + "The depolarizing quantum channel has a parameter $\\alpha$, and works like this: with probability $\\alpha$, the state remains the same as before; with probability $1-\\alpha$, the state becomes the totally mixed state, namely:\n", + "\n", + "$$\\rho_f = \\alpha \\rho_i + \\frac{1-\\alpha}{2^n} * \\mathbf{I}$$\n", + "\n", + "Suppose that we have a sequence of $m$ gates, not necessarily Clifford gates, \n", + "where the error channel of the gates is a depolarizing channel with parameter $\\alpha$ \n", + "(same $\\alpha$ for all the gates). \n", + "Then with probability $\\alpha^m$ the state is correct at the end of the sequence, \n", + "and with probability $1-\\alpha^m$ it becomes the totally mixed state, therefore:\n", + "\n", + "$$\\rho_f^m = \\alpha^m \\rho_i + \\frac{1-\\alpha^m}{2^n} * \\mathbf{I}$$\n", + "\n", + "Now suppose that in addition we start with the ground state; \n", + "that the entire sequence amounts to the identity; \n", + "and that we measure the state at the end of the sequence with the standard basis. \n", + "We derive that the probability of success at the end of the sequence is:\n", + "\n", + "$$\\alpha^m + \\frac{1-\\alpha^m}{2^n} = \\frac{2^n-1}{2^n}\\alpha^m + \\frac{1}{2^n} = A_0\\alpha^m + B_0$$\n", + "\n", + "It follows that the probability of success, aka fidelity, decays exponentially with the sequence length, with exponent $\\alpha$.\n", + "\n", + "The last statement is not necessarily true when the channel is other than the depolarizing channel. However, it turns out that if the gates are uniformly-randomized Clifford gates, then the noise of each gate behaves on average as if it was the depolarizing channel, with some parameter that can be computed from the channel, and we obtain the exponential decay of the fidelity." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simultaneous Randomized Benchmarking\n", + "\n", + "\n", + "RB is designed to address fidelities in multiqubit systems in two ways. For one, RB over the full $n$-qubit space\n", + "can be performed by constructing sequences from the $n$-qubit Clifford group. Additionally, the $n$-qubit space\n", + "can be subdivided into sets of qubits $\\{n_i\\}$ and $n_i$-qubit RB performed in each subset simultaneously [4]. \n", + "Both methods give metrics of fidelity in the $n$-qubit space. \n", + "\n", + "For example, it is common to perform 2Q RB on the subset of two-qubits defining a CNOT gate while the other qubits are quiescent. As explained in [4], this RB data will not necessarily decay exponentially because the other qubit subspaces are not twirled. Subsets are more rigorously characterized by simultaneous RB, which also measures some level of crosstalk error since all qubits are active.\n", + "\n", + "An example of simultaneous RB (1Q RB and 2Q RB) can be found in: \n", + "https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/ignis/randomized_benchmarking.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predicted Gate Fidelity\n", + "\n", + "If we know the errors on the underlying gates (the gateset) we can predict the fidelity. First we need to count the number of these gates per Clifford. \n", + "\n", + "Then, the two qubit Clifford gate error function gives the error per 2Q Clifford. It assumes that the error in the underlying gates is depolarizing. This function is derived in the supplement to https://arxiv.org/abs/1712.06550. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of u1 gates per Clifford: 1.498462\n", + "Number of u2 gates per Clifford: 1.756923\n", + "Number of u3 gates per Clifford: 0.513007\n", + "Number of cx gates per Clifford: 1.518322\n" + ] + } + ], + "source": [ + "#Count the number of single and 2Q gates in the 2Q Cliffords\n", + "gates_per_cliff = rb.rb_utils.gates_per_clifford(qobj_list,xdata[0],basis_gates,rb_opts['rb_pattern'][0])\n", + "for i in range(len(basis_gates)):\n", + " print(\"Number of %s gates per Clifford: %f\"%(basis_gates[i],\n", + " np.mean([gates_per_cliff[0][i],gates_per_cliff[0][i]])))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted 2Q Error per Clifford: 8.943612e-03\n" + ] + } + ], + "source": [ + "# Prepare lists of the number of qubits and the errors\n", + "ngates = np.zeros(7)\n", + "ngates[0:3] = gates_per_cliff[0][0:3]\n", + "ngates[3:6] = gates_per_cliff[1][0:3]\n", + "ngates[6] = gates_per_cliff[0][3]\n", + "gate_qubits = np.array([0,0,0,1,1,1,-1], dtype=int)\n", + "gate_errs = np.zeros(len(gate_qubits))\n", + "gate_errs[[1,4]] = dp/2 #convert from depolarizing error to epg (1Q)\n", + "gate_errs[[2,5]] = 2*dp/2 #convert from depolarizing error to epg (1Q)\n", + "gate_errs[6] = dp*3/4 #convert from depolarizing error to epg (2Q)\n", + "\n", + "#Calculate the predicted epc\n", + "pred_epc = rb.rb_utils.twoQ_clifford_error(ngates,gate_qubits,gate_errs)\n", + "print(\"Predicted 2Q Error per Clifford: %e\"%pred_epc)" ] }, { diff --git a/community/terra/qis_adv/Clifford_Group.ipynb b/community/terra/qis_adv/Clifford_Group.ipynb index 6725250aa..bcc52437e 100644 --- a/community/terra/qis_adv/Clifford_Group.ipynb +++ b/community/terra/qis_adv/Clifford_Group.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Note: Trusted Notebook\" width=\"500 px\" align=\"left\">" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -69,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -173,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -285,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -371,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -456,7 +463,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -613,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -725,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -833,7 +840,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -973,7 +980,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -1068,7 +1075,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -1093,21 +1100,6 @@ "metadata": {}, "output_type": "display_data" }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAADUAAAAyBAMAAAAOzY77AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMA74lUMhCZZs3dIrurRHbLQ9+lAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABIklEQVQ4EWOQ//+JAQtg+v9fgEHYxRWLFAOri7MAgwg2GZAYC0QuTF0FUwVUrpkhcgGyJLMoXB+7AANTA5JcTM5XuBz3AQZmEA8O+BBy/AcYeD/DJYAMJLn4BAbefzjk1iswsKAEAJK+9Qm45fCZCXQLMy63cG9gYMflB6Df2RpwuJNhMkOgAy65oHdHkKXYDv44Do8HZAk4GxoPcD4yY1QOOTRAbNakIgdEeBoGIMtzGLDOgsmxHjuPIlfIwKABk2NgeI8it4eBwT4AllfQ5P4wMNw3wC7H+g0o9wC7HBcwHfsr4JAD6sMlh89MBqBb7HG4hWE3A0M9Lj8A/Z6By++cBqzA0gOaznLkewqQApRV7w1SWCNJwJmDLH3iKyPxlK0AGSZZVRPbH6EAAAAASUVORK5CYII=\n", - "text/latex": [ - "$$\\left[\\begin{matrix}0 & 1\\\\1 & 0\\end{matrix}\\right]$$" - ], - "text/plain": [ - "⎡0 1⎤\n", - "⎢ ⎥\n", - "⎣1 0⎦" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", @@ -1188,7 +1180,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1278,19 +1270,6 @@ }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "('V*Z', Matrix([\n", - " [ 1, -1],\n", - " [-I, -I]]), Matrix([\n", - " [ 1, -1],\n", - " [-I, -I]]))" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -1309,7 +1288,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -1417,7 +1396,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1525,7 +1504,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1634,7 +1613,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1754,7 +1733,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": { "scrolled": true }, @@ -1840,7 +1819,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1986,7 +1965,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -2016,7 +1995,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -2045,7 +2024,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -2074,7 +2053,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -2090,9 +2069,16 @@ "print (\"The size of Class 4 is: \", Class4Size)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**The size of the Clifford group on 2-qubits**" + ] + }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -2111,9 +2097,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python [conda env:YaelEnv]", "language": "python", - "name": "python3" + "name": "conda-env-YaelEnv-py" }, "language_info": { "codemirror_mode": { @@ -2125,7 +2111,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.6.5" } }, "nbformat": 4,