{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Parametric compilation examples\n", "\n", "In this notebook, we demonstrate parametric compilation by way of three \"experiments\": \n", "\n", "* Qubit Spectroscopy, in which we sweep over a detuning parameter,\n", "* Power Rabi, in which we sweep over pulse scale,\n", "* Time Rabi, in which we sweep over pulse duration.\n", "\n", "The intent here is to demonstrate Quil-T features; as such we do not do much in the way of data analysis." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from typing import Optional\n", "from pyquil import Program, get_qc\n", "from pyquil.quilatom import Qubit, Frame\n", "from pyquil.quilbase import Gate, Pulse, DefCalibration\n", "from pyquil.gates import RX\n", "\n", "qc = get_qc('Aspen-M-3')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "cals = qc.compiler.get_calibration_program()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we write a useful little helper, to extract the first pulse from a gate calibration." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "NONBLOCKING PULSE 0 \"rf\" drag_gaussian(alpha: 0.3183552471062913, anh: -220655329.522463, detuning: -321047.14178613486, duration: 2.4000000000000003e-8, fwhm: 6.000000000000001e-9, phase: 0, scale: 0.625214040700785, t0: 1.2000000000000002e-8)\n" ] } ], "source": [ "import numpy as np\n", "\n", "def get_pulse(cal: DefCalibration) -> Optional[Pulse]:\n", " return next((i for i in cal.instrs if isinstance(i, Pulse)), None)\n", "\n", "rx0 = cals.get_calibration(RX(np.pi, 0))\n", "print(get_pulse(rx0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Qubit Spectroscopy\n", "\n", "\n", "Here we present a simple Qubit spectroscopy experiment. The general idea is that we scan over a range of frequencies, applying a pulse and measuring the resulting probability that the qubit is excited. There are some natural matters which we do _not_ concern ourselves with, for example the choice of pulse duration, or carefully inspecting the readout values. Instead we wish to demonstrate how this sort of experiment can be done using parametric compilation.\n", "\n", "We first define a function which can produce a parametric program to perform this experiment." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DECLARE detuning REAL[1]\n", "DECLARE ro BIT[1]\n", "DEFFRAME 0 \"rf\":\n", "\tSAMPLE-RATE: 1000000000\n", "\tINITIAL-FREQUENCY: 5041070703.43581\n", "\tDIRECTION: \"tx\"\n", "\tCENTER-FREQUENCY: 4875000000\n", "\tHARDWARE-OBJECT: \"q0_rf\"\n", "SHIFT-FREQUENCY 0 \"rf\" detuning[0]\n", "RX(pi) 0\n", "MEASURE 0 ro[0]\n", "\n" ] } ], "source": [ "def qubit_spectroscopy(qubit: int, param: str, *, calibrations: Program, shots: int = 1000) -> Program:\n", " \"\"\" Generate a program for doing a Qubit spectroscopy experiment.\n", " \n", " :param qubit: The qubit index to run on.\n", " :param param: The name of the parameter used for detuning.\n", " :param calibrations: The QPU calibrations, needed in order to identify an appropriate pulse and frame.\n", " :param shots: The number of shots to execute for a single run.\n", " \"\"\"\n", " \n", " # The basic idea is:\n", " # - shift the frequency by the amount indicated by `param`\n", " # - do an RX(pi) gate\n", " # - measure\n", " \n", " # We first find the frame on which the RX(pi) pulse is applied.\n", " cal = calibrations.get_calibration(RX(np.pi, qubit))\n", " pulse = get_pulse(cal)\n", " frame = pulse.frame\n", " \n", " # When we construct the program, we are sure to include the frame definition\n", " # (since SHIFT-FREQUENCY is applied to this frame).\n", " return Program(\n", " calibrations.frames[pulse.frame],\n", " 'DECLARE ro BIT',\n", " f'DECLARE {param} REAL',\n", " f'SHIFT-FREQUENCY {frame} {param}',\n", " f'RX(pi) {qubit}',\n", " f'MEASURE {qubit} ro'\n", " ).wrap_in_numshots_loop(1000)\n", "\n", "print(qubit_spectroscopy(0, 'detuning', calibrations=cals))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we compile and run, considering detuning frequencies in the range from -3 MHz to +3 MHz. Note that with parametric compilation we only require one call to the compiler." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "exe = qc.compiler.native_quil_to_executable(qubit_spectroscopy(0, 'detuning', calibrations=cals))\n", "\n", "detunings = np.linspace(-3e6, 3e6, 100)\n", "dprobs = []\n", "for detuning in detunings:\n", " results = qc.run(exe, memory_map={\"detuning\": [detuning]}).get_register_map()[\"ro\"]\n", " p1 = np.sum(results)/len(results)\n", " dprobs.append(p1)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", "plt.plot(detunings, dprobs, '.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Power Rabi\n", "\n", "We consider another experiment, in which we vary the waveform amplitude and consider how this effects the probability that a qubit is excited. This is formally quite similar to the previous Qubit spectroscopy." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DECLARE ro BIT[1]\n", "DECLARE scale REAL[1]\n", "DEFFRAME 0 \"rf\":\n", "\tHARDWARE-OBJECT: \"q0_rf\"\n", "\tINITIAL-FREQUENCY: 5041070703.43581\n", "\tSAMPLE-RATE: 1000000000\n", "\tCENTER-FREQUENCY: 4875000000\n", "\tDIRECTION: \"tx\"\n", "SET-SCALE 0 \"rf\" scale[0]\n", "RX(pi) 0\n", "MEASURE 0 ro[0]\n", "\n" ] } ], "source": [ "from copy import deepcopy\n", "\n", "def power_rabi(qubit: int, param: str, *, calibrations: Program, shots: int = 1000) -> Program:\n", " \"\"\" Generate a program for doing a power Rabi experiment.\n", " \n", " :param qubit: The qubit index to run on.\n", " :param param: The name of the parameter used for amplitude scaling.\n", " :param calibrations: The QPU calibrations, needed in order to identify an appropriate pulse and frame.\n", " :param shots: The number of shots to execute for a single run.\n", " \"\"\"\n", " \n", " # The basic idea is:\n", " # - set the frame scaling to the amount indicated by `param`\n", " # - perform the pulse of an RX(pi) gate\n", " # - measure\n", " \n", " # We first find the frame on which the RX(pi) pulse is applied.\n", " cal = calibrations.get_calibration(RX(np.pi, qubit))\n", " pulse = get_pulse(cal)\n", " frame = pulse.frame\n", " \n", " # When we construct the program, we are sure to include the frame definition\n", " # (since SET-SCALE is applied to this frame).\n", " return Program(\n", " calibrations.frames[pulse.frame],\n", " 'DECLARE ro BIT',\n", " f'DECLARE {param} REAL',\n", " f'SET-SCALE {frame} {param}',\n", " f'RX(pi) {qubit}',\n", " f'MEASURE {qubit} ro'\n", " ).wrap_in_numshots_loop(1000)\n", "\n", "print(power_rabi(0, 'scale', calibrations=cals))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "exe = qc.compiler.native_quil_to_executable(power_rabi(0, 'scale', calibrations=cals))\n", "\n", "scales = np.linspace(1e-4, 1.0, 20)\n", "sprobs = []\n", "for scale in scales:\n", " results = qc.run(exe, memory_map={\"scale\": [scale]}).get_register_map()[\"ro\"]\n", " p1 = np.sum(results)/len(results)\n", " sprobs.append(p1)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "plt.plot(scales, sprobs, '.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Time Rabi\n", "\n", "Key to our use of parametric compilation in the previous two experiments is that the variable which we were speeping over (frequency or scale) had an associated Quil-T instruction (`SHIFT-FREQUENCY` or `SET-SCALE`). In this example we consider a \"Time Rabi\" experiment, which involves varying the pulse length. \n", "\n", "A current limitation of Quil-T is that waveforms must be resolved at compile time, and so the `duration` field of a template waveform cannot be a run-time parameter. The workaround for our Time Rabi experiment is that we must generate a new program for each value of `duration`, and we cannot rely on parametric compilation for this." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DECLARE ro BIT[1]\n", "DEFFRAME 0 \"rf\":\n", "\tHARDWARE-OBJECT: \"q0_rf\"\n", "\tSAMPLE-RATE: 1000000000\n", "\tDIRECTION: \"tx\"\n", "\tINITIAL-FREQUENCY: 5041070703.43581\n", "\tCENTER-FREQUENCY: 4875000000\n", "NONBLOCKING PULSE 0 \"rf\" drag_gaussian(alpha: 0.3183552471062913, anh: -220655329.522463, detuning: -321047.14178613486, duration: 2.4000000000000003e-8, fwhm: 6.000000000000001e-9, phase: 0, scale: 0.625214040700785, t0: 1.2000000000000002e-8)\n", "MEASURE 0 ro[0]\n", "\n" ] } ], "source": [ "from copy import deepcopy\n", "\n", "def time_rabi(qubit: int, duration: float, *, calibrations: Program, shots: int = 1000) -> Program:\n", " \"\"\" Generate a program for doing a time Rabi experiment.\n", " \n", " :param qubit: The qubit index to run on.\n", " :param duration: The pulse duration, in seconds.\n", " :param calibrations: The QPU calibrations, needed in order to identify an appropriate pulse and frame.\n", " :param shots: The number of shots to execute for a single run.\n", " \"\"\"\n", " \n", " # The basic idea is:\n", " # - get the pulse associated to an RX(pi) gate\n", " # - perform a modified version of this, with the `duration` updated\n", " # - measure\n", " \n", " # We first find the frame on which the RX(pi) pulse is applied.\n", " cal = calibrations.get_calibration(RX(np.pi, qubit))\n", " pulse = get_pulse(cal)\n", " frame = pulse.frame\n", " fdefn = calibrations.frames[frame]\n", " \n", " updated_pulse = deepcopy(pulse)\n", " # Note: duration must be aligned to 4 sample boundaries.\n", " updated_pulse.waveform.parameters[\"duration\"] = 4*np.round(duration*fdefn.sample_rate / 4) / fdefn.sample_rate\n", " \n", " # When we construct the program, we are sure to include the frame definition\n", " # (since SET-SCALE is applied to this frame).\n", " return Program(\n", " fdefn,\n", " 'DECLARE ro BIT',\n", " updated_pulse,\n", " f'MEASURE {qubit} ro'\n", " ).wrap_in_numshots_loop(1000)\n", "\n", "print(time_rabi(0, 1e-8, calibrations=cals))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "times = np.linspace(1e-9, 100e-9, 20)\n", "tprobs = []\n", "for time in times:\n", " exe = qc.compiler.native_quil_to_executable(time_rabi(0, time, calibrations=cals))\n", " results = qc.run(exe).get_register_map()[\"ro\"]\n", " p1 = np.sum(results)/len(results)\n", " tprobs.append(p1)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "plt.plot(times, tprobs, '.')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.8.14" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }