Making quantum logic 10X better on quantum computers

Anyone who experiments with real quantum computers can attest that today’s systems - as important as they are for research - are far from perfect. Addressing the challenge of hardware instability has been a huge driver for the research field for decades. Through its partner network and open-science challenges IBM has been exploring new ways to accelerate progress in quantum computing.

Since 2018 Q-CTRL has been a member of the IBM Quantum Startup network, working closely with the team at IBM to explore how quantum firmware can enable new developments in the field. In the NISQ era and beyond quantum firmware provides a validated approach to mitigate errors in individual hardware elements and individual qubit operations using the concepts of robust quantum control.

The objective, of course, is to improve the performance of the underlying hardware by reducing gate errors, reducing device variability, and extending hardware uptime between calibrations. And the results have been quite extraordinary:

• Up to 10X improvements in quantum logic error rates
• Up to 10X improvements in hardware performance across the chip
• Up to 10X improvements in hardware stability over time

Reducing gate errors with Qiskit Pulse

Quantum computers are noisy devices. Even the best superconducting quantum bits forget their quantum information in less than a millisecond due to noise from interactions with the outside world. Much of today's hardware research focuses on how to mitigate the computing errors caused by this noise as we pursue large-scale, fault-tolerant devices.

IBM began a collaboration with Q-CTRL because of the team's specialized expertise in reducing noise and errors in quantum computers.

In collaboration with Q-CTRL, IBM Quantum used Boulder Opal to run error-robust quantum gates on a five-qubit IBM Quantum Canary processor, representing up to a ten-times improvement in error suppression over pre-programmed single-qubit Qiskit gates alone. These results show just how powerful pulse-level control can be for programming a quantum computer over the cloud.

The starting point was the realization that noise isn't always random — some sources of noise exhibit patterns caused by their underlying source, such as drift in the hardware or ambient fields. Pulse-level control offers a way to handle these less-random noise sources.

IBM Quantum already incorporated noise-aware control when implementing gates, such as Derivative Removal by Adiabatic Gate (DRAG), which ensures that qubits only access the states used for computation, or the Echoed Cross Resonance gates, which remove undesired two-qubit interactions.

In their work with Q-CTRL, IBM looked to correct additional hardware errors caused by qubit frequency detuning, leakage, and microwave amplitude fluctuations by crafting custom gates with specially-tuned phases and amplitudes and sending them to the five-qubit Valencia processor over the cloud.

How do you decide what the pulses should look like? You start by analyzing the Hamiltonian — the energy equation — that describes the quantum computer's operations at a physical level. This information allows you to craft hardware-aware logic gates, like the X or the Hadamard gate, specially tuned to the device being controlled, even incorporating smoothing filters that correct for distortions introduced by the dilution refrigerator's finite bandwidth limitation.

Below, you can see what one of those pulses looks like, output from Q-CTRL's Boulder Opal optimization engine and decomposed into I and Q, the real and imaginary parts of the pulse, respectively. (Pulses are decomposed into a complex-valued waveform based on the Rabi rate, Ω, and the drive phase 𝜙, where the pulse is equal to I(t) + iQ(t). I = Ω cos( 𝜙), while Q = Ω sin(𝜙 ).)

We used Qiskit Pulse and Q-CTRL's Boulder Opal to run error-robust quantum gates on a five-qubit IBM Quantum Canary processor. These results show just how powerful pulse-level control can be for programming a quantum computer over the cloud.

IBM Quantum’s hardware and Qiskit Pulse define pulses that have their own set of variables and constraints, so you have to calibrate pulses to the hardware by developing a mapping between the hardware’s variables and our control pulse’s I and Q variables. You start by performing a Rabi experiment, varying a square pulse’s duration and measuring the qubit’s response in order to determine a rough mapping between the hardware’s measured response and the pulses that you send. Then, you can use fully automated calibration routines to account for the fine differences between values that we send the chip and what the qubit actually reads.

After all of this pulse design and calibration, measurements on IBM quantum computers showed that Q-CTRL’s single-qubit gates consistently outperformed default gates:

• Error rates were up to ten times better on the new gates
• Error rates were five times better on average for the whole IBM Quantum Valencia device experimented on.
• These pulses reduced the gate variability between qubits — theymake all of the qubits perform nearly as well as the best-performing qubit.
• Calibration remained useful for a week, rather than for default gates that require daily calibration.
• These gates worked well in parallel, and were resilient to ambient noise as well as crosstalk noise that arises when you act on multiple qubits simultaneously.

Below you can see a graph of the results comparing the error rates of the default X-gate on the left and Q-CTRL’s custom gates on the right, where darker colors mean lower error rates.

Ultimately these gates help improve the performance and stability of quantum algorithms when run on real quantum computers - delivering better value for end-users.

AI-based gate optimization without physical models

The IBM team had a particular interest in improving the performance of multiqubit gates - the entangling operations that are currently performance limiting in nearly all quantum computers. Again through their collaboration the Q-CTRL team set out to tackle this challenge in order to ultimately deliver better customer value for IBM hardware users.

In the case of multiqubit gates, the so-called Hamiltonian model was much more difficult to fully characterize - it required many measurements to probe in sufficient detail the energy terms and interactions relevant to improving the gates. So instead the Q-CTRL team focused on allowing an autonomous AI agent to find solutions superior to those designed by the expert team at IBM, this time with zero user intervention.

Q-CTRL developed two distinct approaches for the task: closed-loop automated “black box” optimization and reinforcement learning. They differ in subtle ways but both involve allowing an autonomous agent to test new strategies and discover solutions which give the best quantum logic gates.

In these frameworks you don’t provide any optimization parameters or underlying model of the physics you’re trying to exploit. Instead, you simply provide the algorithm a set of actions it can take, the ability to perform experiments, and then a decision engine to determine what to do with the new measurement information it’s gained. The system learns all of the relevant physics and hardware constraints, simply by attempting to satisfy a reward function. As always, the “magic” lies in the means of learning and convergence, both of which we’ll be describing in a forthcoming manuscript. But the results were quite extraordinary.

The agent independently found single qubit logic gates up to 3x faster than the default without performance degradation. And in laboratory experiments on IBM's hardware, the team found the new AI agent could also autonomously discover new multiqubit gates with over two times reduction in errors relative to the default gates - again without any expert intervention.

Even better, the pulses designed by the agent extended the useful calibration window of the hardware even further - up to 25 days in one experiment. You might ask how - the fact that training the AI agent must be completed over multiple measurement days on IBM hardware - primarily due to queues for access - may have inadvertently allowed the learner to design pulses robust against slow changes in the hardware.

Overall these are highly motivating initial demonstrations that Boulder Opal - integrated directly into hardware via analog-layer programming - can open up new opportunities in quantum computing research, and accelerate progress in the field. We're really excited to see what else the community can do with our tools!

The new AI capability driven by this collaboration is a major step towards fully abstracted quantum computer hardware powered by AI. Just like software abstraction on conventional computers enables programmers to write algorithms without a need to understand how a transistor works, this tool makes it much easier for you as researchers to explore the potential of quantum computers.

Watching a quantum computer tune itself up with this tool and deliver quantum logic with lower errors than that achieved by the best hardware development teams in the world was quite amazing. You should give it a try.

You can see the results of Q-CTRL's work with IBM in two technical manuscripts that have shown huge enhancements and advanced the state of the art in the field.

Error-robust quantum logic optimization using a cloud quantum computer interface

Experimental Deep Reinforcement Learning for Error-Robust Gateset Design on a Superconducting Quantum Computer

‍