The benefits of high-resolution pulses for quantum computers
By: Daniel Egger, Naoki Kanazawa
Many advances in quantum computing have been driven by improving our control over quantum systems. The qubit readout as well as the unitary gates that process the quantum information are implemented by control pulses that drive the quantum system. The control pulses of the IBM Quantum systems are implemented by a pulse envelope modulated at a frequency which depends on the qubit or resonator being driven. The envelope of the pulse is created by an arbitrary waveform generator (AWG), shown in Fig. 1(a), an electronic device that produces waveforms as a series of user-specified voltage targets. The duration for which each voltage is output is the length of a sample, i.e. the cycle time of the control system. Shorter samples, i.e. higher resolution, allow users to create more versatile pulse shapes.
The IBM Quantum systems through the IBM Cloud has been offering its users the control of the pulse shapes through the Qiskit-Pulse module. Coding at the pulse layer enables users to create quantum gates tailored to their application within hardware capabilities, characterize quantum devices and implement control sequences such as dynamical decoupling. These features are highlighted with examples in the post “Get to the heart of real quantum hardware”. Recently, IBM Quantum released pulse shaping capabilities with a 16x increase in time resolution to premium users. This corresponds to a decrease in sample length from 3.556ns to 0.222ns. This remarkable performance improvement is made possible by enhancements of our software stack to make better use of the existing control electronics. We illustrate this increased resolution in Fig. 1 with a Derivative Removal by Adiabatic Gate (DRAG) pulse. Such pulses are designed to drive the 0 to 1 transition of transmon qubits while avoiding leakage to higher-level states, see Fig. 1(b). Both (c) and (d) show the same DRAG pulse with the standard resolution in (c)and the high-resolution in (d). Exquisite pulse-level control of the IBM Quantum processing devices is now available to anybody with an internet connection.
Programming with high-resolution quantum systems
Hardly anything changes for the user when switching from low-resolution to high-resolution backends. For example, the code below shows the construction of a DRAG pulse for a high-resolution backend.
The structure of the code is identical to the case when low-resolution systems are used. We must, however, pay attention to several details. The pulse envelope is loaded to the control system in chunks of 16 samples, here represented by sample_multiple. In high-resolution systems users can fill this 16 sample chunk with independent sample values to create high precision control pulses. The control pulses defined in the high-resolution systems therefore have a longer data length or duration which must be a multiple of sample_multiple.
Low-resolution pulses that a user calibrated can still be used on the high-resolution system by updating the timing related parameters such as duration and sigma. Those parameters must be multiplied by 16 to replicate the pulse shape in the low-resolution system. In our pulse model the derivative of a pulse envelope is calculated from the system cycle time. Since the quadrature envelope of DRAG pulses is defined by the time derivative of the in-phase component we must also multiply the parameter beta by 16. This parameter scales the amplitude of the quadrature component employed to suppress leakage to the non-computational states. It is noteworthy that the update to the high-resolution may change the area under the envelope of your pulses and you may thus need to fine-tune the parameter amp to realize an identical performance to the low-resolution system.
High-resolution quantum systems also increase the number of samples that the user must communicate to the control system. This increases the data volume and the load on the transport layers. However, many pulses can be specified by analytical functions which we refer to as ParametricPulses. For instance, the lengthy readout pulses are often specified as Gaussian square pulses, i.e. a flat-top pulse with Gaussian-shaped rising and falling edges, which can be compactly represented as ParametricPulse.
Since width is also measured in units of cycle time it must be multiplied by 16 when migrating code from low- to high-resolution. Compared to the first example the code structure is identical. However, pulse.GaussianSquare saves us from having to transfer each of the 19,200 complex samples for each measurement pulse through the software stack. Indeed, the size of the schedule shown above with the ParametricPulse weighs about 700 Bytes when assembled and saved in JSon format but weighs about 300 kBytes when a SamplePulse is used instead. This represents a 99% reduction in data volume. Support for ParametricPulses will only become available on backends in several weeks. However, you can already use them since Qiskit will automatically convert a ParametricPulse to a SamplePulse if the backend does not support it. In Qiskit-Pulse we currently support Gaussian, GaussianSquare, Drag and Constant as ParametricPulse. See the API documentation for more details.
Benefits of high-resolution
High-resolution control pulses allow you to explore novel control schemes. We now illustrate this new capability by discussing gate calibration, higher energy states and optimal control.
To execute quantum circuits on real hardware with custom gates you first need to calibrate the control pulses that implement these custom gates. On low-resolution backends the shape of the control pulses with steep step-wise edges, as illustrated in Fig. 1(c), may not match the analytical function that describes the pulse. However, with the high-resolution systems you can now create control pulses that better approximate analytical functions and avoid sharp edges which is necessary to realize high fidelity gates. In the paper Qiskit Pulse: Programming Quantum Computers Through the Cloud with Pulses we show how Qiskit users can create their own controlled-NOT (CNOT) gates to create a universal gate set together with single-qubit gates. In this paper, we used the high-resolution of Qiskit-Pulse to demonstrate an open-loop calibration of a CNOT gate implemented by the pulse schedule shown in Fig. 2(a). The drive channels d0 and d1 are used to stimulate the target and the control qubit, respectively, while the control channel u1 is used to apply the cross-resonance (CR) pulses. Using Qiskit-Pulse with Qiskit-Ignis enables us to study the interactions of the two-qubits under the cross-resonance drive, i.e. the pulse sequence in the red box, with various amplitudes for the CR pulses, see Fig. 2(b). The cross-resonance drive creates a strong ZX interaction which we use to create a CNOT gate by calibrating the amplitude of the CR pulses. When the pulse amplitude is set to 0.229, the pulse sequence yields a half pi rotation around the x-axis of the target qubit with the sign depending on the state of the control qubit. We correct single-qubit unitary errors caused by unwanted interactions by applying single-qubit rotations before and after the CR sequence. These single-qubit rotation angles are classically optimized to maximize the CNOT fidelity which results in the pulse sequence of the CNOT gate shown in Fig. 2(a).
The pulse schedule was programmed with the same time resolution as the control system’s internal pulse definition used for Quantum Circuit (QASM) experiments. With this powerful pulse programming environment we realized a 98.1% gate fidelity which is comparable to the system’s CNOT gate fidelity of 98.4% on that day. All experimental code is available in the Zenodo open data repository. Now you can create your own custom entangling gates with high-resolution using Qiskit-Pulse!
The higher time resolution yields sufficient bandwith to investigate novel quantum control schemes. We illustrate this by creating a single-qubit geometric gate between the |0> and |2> state of the transmon. The rotation that a geometric gate implements depends only on the path that the quantum system takes in Hilbert space during the time evolution. This gate is implemented by simultaneously driving a 2pi rotation between the |0> to |1> and the |1> to |2> transitions which differ in frequency by the anharmonicity of the transmon, see Fig. 3(a). We therefore require properly calibrated X gates between |0> to |1> and between |1> to |2> which we label X01 and X12, respectively. The backend provides us with a properly calibrated X01 gate. By modulating the pulse that implements X01 with the anharmonicity of the transmon and by scaling its amplitude we can implement a calibrated X12 gate that has the same duration as X01. This modulation requires a bandwidth comparable to the anharmonicity, which is typically -400 ~ -300 MHz for transmon devices. To avoid calibrating 2pi rotations we implement the geometric gate by two back-to-back simultaneously driven X01 and X12 gates as shown in Fig. 3(b). The pulse envelope of the X01 and X12 gates are scaled by the complex parameters a and b which control the rotation angles theta and phi on the Bloch sphere spanned by |0> and |2>, see Fig. 3(a). A custom discriminator built using Qiskit-Ignis allows us to tell apart the |0>, |1>, and |2> states in the IQ-plane, see Fig. 3(c). We scan the angle theta from 0 to pi and measure the population in the transmon to show how the population is transfered from |0> to |2>, see Fig. 3(d). This geometric gate can only be implemented with high-resolution backends as illustrated by the fast oscillations in the pulse envelopes shown in Fig. 3(b). A Jupyter notebook with the single-qubit geometric gate is available in the Qiskit community tutorials.
A lot of work in quantum control is devoted to shaping the envelope of the control pulses to overcome unwanted effects such as leakage and cross-talk. A higher time resolution allows users to build more versatile pulses capable of addressing such issues to increase gate fidelity. For example, short gates may be desirable to mitigate T1-decay and decrease the overall run time of the quantum circuits. However, even DRAG pulses fail to reduce leakage to non-computational states when they are too short. In the recent research paper Leakage reduction in fast superconducting qubit gates via optimal control Werninghaus et al. created a piecewise-constant (PWC) single-qubit pulse lasting 4.16ns and sampled at 2.4GS/s that overcame leakage to non-computational states, see Fig. 4. Each complex sample of the PWC pulse is classically optimized to maximize the gate fidelity. By comparison, the shortest DRAG pulse on the same system with comparable fidelity was 5.42 ns, i.e. 30% longer. While the experiments of Werninghaus et al. were not done on a cloud Quantum computer they highlight that investigating complex pulse shapes is only feasible with control systems that have a high enough resolution. The high-resolution that IBM Quantum makes available will allow researchers to further explore how such complex pulses can benefit quantum computing and to further develop methods of quantum control.
With the high-resolution offered by the IBM Quantum backends you can now explore a wealth of quantum phenomena and dynamics that only until recently was restricted to a few privileged physicists operating in research laboratories.
