Enabling Real-Time Capabilities: The Processor Designed for Quantum Control
If you’re anything like me, you’ve wondered countless times why your Ph.D. in Physics was about making legacy equipment work as you intended instead of probing some cool physics. It’s a fact that the majority of advances in experimental quantum physics have been achieved by combining general-purpose equipment to perform arbitrary pulse sequences.
The time evolution of qubits is usually counted in nanoseconds, so ultra-fast real-time feedback and decision-making are crucial. And it’s not like control systems can just work at that speed without a bit of help. Or can they?
You probably came here because you got bored playing with FPGA codes and kicking old AWGs. That’s one of the reasons we developed the Quantum Orchestration Platform and its OPX in the first place. So today, I invite you on a journey into the heart of the OPX, the Pulse Processing Unit (PPU), an FPGA-based processor built from the ground up for quantum control in “qubit-time.” Let’s plunge headlong into quantum control systems of the best kind.
The Key Components of Quantum Control
For a processing unit to handle all possible quantum control sequences, it must be able to perform a universal set of operations on a qubit: waveform generation, acquisition, and manipulation. But it also must be able to run a universal set of classical operations – logic statements and loops – and Turing-complete processing. These horsemen of quantum control are the axes that span the spectrum of possible sequences. You might be thinking: it sounds like the OPX is just an AWG & digitizer combo running some FPGA code. Well, no (you’ll see soon, keep reading), but I get why you’d go there.
Parametric Waveform Generation, Acquisition, and Manipulation
The idea is to have a system perform pulse sequences and skip the whole point-by-point waveform definition – the very thing that makes AWGs so annoying. In a physics lab, you can explain a Ramsey sequence in just a couple of sentences. So why does it take so long to explain it to your experimental setup? The reason is simple: AWGs are not made with these procedures in mind. The purpose of the Quantum Orchestration Platform is to simplify all this.
You write a few lines of high-level code (in QUA, our Python-embedded language), and then the OPX does all the heavy lifting, supported by the Hadamard PPU inside it. If you’re curious to see examples, check back soon for my next blog post, where I’ll show you how to run Ramsey and active frequency tracking in QUA.
“So, the PPU can manipulate waveforms in real time. What does it mean for me in the lab?”
No more loading hours of sequences:
The PPU requires only a few points to define the basic envelope, and then it will take it from there. No loading, and no compilation times.
No more offline waveform manipulation:
Just tell the OPX (and its Hadamard PPU) what you want to do with the given waveform, and it will do it in real-time during the experiment, in time scales comparable with qubit time evolution. Stretch it, amplify it, process it using a value you just measured a few nanoseconds ago, then send it to the qubit. That’s all.
No more loading zeros and post-selecting:
The PPU understands logic commands
like wait() or align(), so you don’t have to manually calculate waiting times and load a
bunch of zeros into the AWG. Who invented that anyway? And wait until you see what a simple align() command means for repeat-until-success protocols. This is particularly relevant for dynamic sequences, such as heralding schemes on NV center qubits. Check out our Optically Addressable Qubits page to read more.
Infinite branching and real-time stuff:
How many branching paths can you load into an AWG? Well, if your processor can talk physics, there’s no limit to the conditions you can set.
Am I talking about any classical processing done during your quantum experiment? You bet.
Parametric Waveform for EXPERTS
Duration, frequency, phase (relative and absolute), amplitude, and bandwidth of anything you generate or measure are real-time parameters living on the FPGA. Any compensation is performed on the fly: FIR & IIR filters, crosstalk matrix, etc. You get high fidelity ADC, time-tagging, integration & full/sliced/accumulated demodulation in nanoseconds. Simultaneously on 18 independent threads. Communicate to the lab PC only when you need it. Everything else is live.
General Classical Processing and Comprehensive Control Flow
The story of advanced quantum control doesn’t end with measuring and playing pulses. What happens when you want to play a pulse conditionally on the state of a qubit? We’re talking about evaluating a measurement, doing calculations and estimations, and sending the correct pulse, all in hundreds of nanoseconds (should be much less than the coherence times of your qubit). Until recently, this required programming FPGAs, ADwin controllers, and similar to talk to AWGs, and boy, was it inefficient. The process is painful, time-consuming, and has limitations because of the latencies between instruments. Lucky for us playful physicists, it’s also a thing of the past.
The OPX integrates all the necessary tools for control sequences. Its Hadamard PPU handles computation, estimations, and control flow operations without the need to communicate back to the user’s computer. Programming an active reset sequence in QUA takes the same amount of time as explaining it to a fellow physicist:
play("pi", qubit, condition=(state==1)) # Active reset This line takes less than 200ns to perform on an actual qubit. The Hadamard can perform State-, error- and Bayesian estimations in real-time, just like more complicated neural-net-based estimations or correlation functions, and use the results to change the next pulse parametrically. It recognizes control flow instructions, such as loops and if-else statements, and runs them on the fast FPGA electronics (you compile logic statements instead of unraveling Python loops).
You can program a pulse sequence to be sent only when a measurement, done a few nanoseconds before, falls within certain thresholds. These could even be arbitrary dynamic thresholds that update themselves during each sequence loop in real time. I mean, why not go bigger and crazier? Imagine having a frequency-tracking macro that runs within each iteration of some fancy experiment, ensuring your sequences always have the drive at perfect resonance with the qubit (keep an eye out for the next blog post). Let’s forget about FPGA programming and ADwin controllers and make space for exciting physics.
“What can I expect in practice once real-time processing and control flow are in place?”
Speed up typical routines: Your loops and calculations run on an FPGA processor instead of your computer, removing all communication overheads, reducing latencies, and avoiding clogging your network. This, plus active reset, ensures the shortest runtimes. Imagine running a 2D Ramsey plot in 2 minutes instead of 900.
Enable new experiments: The lowest latencies allow you to jam more pulses into your qubit’s coherence time. It’s as simple as that. Additionally, the PPU runs all sorts of estimations and computations, enabling many procedures to run in real time. Not to mention the time tagging capabilities for optically addressable qubits!
Design quantum experiments, not electronics: You can write in physics-talk and rest assured that pulses and gates, conditions and loops run with the lowest latency possible. Hopefully, you won’t need to hear the term FPGA around your lab anymore.
Be future-agnostic: The PPU architecture ensures that the work you do today won’t place bottlenecks and limitations on tomorrow’s ideas. The OPX is ready for quantum error correction and operations on any number of qubits right out of the box.
Real-time processing and control flow for EXPERTS
Even if you write your code in Python, all the processing, operations, conditions, and loops run on the PPU’s FPGA. Real-time branching in 2 or 200 paths is just a switch command.
The PPU requires only the instructions and a few points for the envelope of the waveforms. Everything else is computed on the fly when needed, and results can be used nanoseconds later in defining the next pulse.
Unless required, the PPU will not communicate with the user PC, ensuring no bottlenecks and no jamming of the local network with correlation data.
The OPX includes a 16 core Linux processor to handle the heavy computation. Neural network training, averaging, and FFT can all run in real-time during your experiment, and you get back into your Python environment only what you need.
Enabled by the Pulse Processing Unit
When you can write procedures in physics-talk, and the hardware is up to the challenge, even the most complicated sequences become first-year programming exercises, running with the lowest possible latencies. We’ve supported customers in obtaining speed-ups of over 400 times for 2D-Ramsey sequences, over 20 times for Rabi-Chevron sequences (see figure below), and writing dynamic tracking codes using all sorts of fancy adaptive estimation algorithms. The OPX allowed one user to perform a 10-qubits active reset and generate a noiseless plot (100000 averages) in 20 seconds instead of the usual hour.
“With the OPX we were able to reduce the cost of infrastructure development from a few weeks to a few days, without any need to directly program the FPGA.” – Dr. Roni Winik, Engineering Quantum Systems Group – MIT
We have witnessed customers write their own macros for Bayesian estimations, Kalman filters, machine learning, laser stabilization and intensity noise reduction, and much more. The OPX and its Hadamard PPU continue to enable outstanding research, such as coherent control of dark states in waveguide-based QED [1], number-resolved photocounter for microwave [2], stabilization of squeezing in microwave modes [3], and many more. The QOP is just starting to show its incredible breadth of applications and keeps speeding up research in quantum computing with donors in silicon [4], superconducting cat-qubits [5], and even dark matter detection [6]. How far can we push it?
“What can’t the PPU do?”
That’s where you come in.
Is there a sequence you hope to run on your setup but don’t yet know how? Is there an experiment you want to implement, but it would take too much time and effort?
Drop me a line! The QM team (myself included) is always up for a good challenge.
References
[1] Zanner, M., et al. “Coherent control of a multi-qubit dark state in waveguide quantum electrodynamics.” Nature Physics (2022).
[2] Dassonneville, R., et al. “Number-resolved photocounter for propagating microwave mode.” Physical Review Applied 14.4 (2020): 044022.
[3] Dassonneville, R., et al. “Dissipative stabilization of squeezing beyond 3 dB in a microwave mode.” PRX Quantum 2.2 (2021): 020323.
[4] Fernández de Fuentes, I., et al. “Coherent quantum control of a single 123 Sb atom in silicon.” Bulletin of the American Physical Society (2022).
[5] Leghtas, Z., et al. “Macroscopic bit-flip times in a superconducting cat-qubit”. Bulletin of the American Physical Society (2022).
[6] Agrawal, A., et al. “Dark Matter Signal Enhancement with a Superconducting Qubit.” Bulletin of the American Physical Society (2022).
Additional resources
Optically Addressable Qubits page
