Quantinuum Technical Workshop

Yesterday I attended a workshop by Quantinuum, introducing their latest Helios chip to the Singapore quantum ecosystem. The programme included tutorials on hybrid quantum-classical computing workflows, including real-time measurement and conditional circuit operations, as well as applications to quantum error correction and quantum chemistry.

As someone who previously worked on NISQ processors and interested in trying out the latest generation of quantum processors, it was exciting to learn more about the new capabilities that are available:

• Real-time qubit measurements and reset combined with conditional operations open new opportunities for circuit design, such as the use of probabilistically generated magic states to reduce circuit depth.
• Gate fidelities are improved by an order of magnitude! 
• It seems like quantum error correction can actually work on real hardware!

 At the same time, some of the big challenges we struggled with before remain open problems:

• Trapped ion systems are slow. Current "error correction" capabilities are practically limited to error detection and post-selection - full-on error correction requires too big an overhead in terms of circuit depths. There is a need to carefully tailor the error correction code to the specific problem and hardware.
• Quantum chemistry use cases seem to have hit a wall in terms of the complexity of implementing the second-quantized Hamiltonians - circuit depths and required number of measurements become intractable well before one can use all of the available physical qubits. Switching from variational algorithms to subspace methods only partially addresses this.

And some other thorny issues mentioned during the discussion breaks:

• With superconducting quantum processors or other platforms with fixed qubit positions, one often has the luxury of choosing the best set of the qubits on the device and avoiding bad ones. This isn't supported on the Quantinuum processors due to the qubit shuttling - you have to use whatever you're given and can't keep track of which ions are the best to use. This might make the performance more unpredictable from day to day. One suggested approach was to instead perform a tomography on the different quantum logic regions of the device (where the gates are actually performed), to see if there is substantial variation in their fidelities.
• Because the gates are so slow, zero noise extrapolation (a simple and effective error mitigation scheme) have limited noise data to work with. Methods to generate more data (by probabilistically expanding only some of the two-qubit gates) need to execute many more circuits, giving a big overhead in terms of compilation time.
• Conditional circuit operations such as post-selection can substantially increase the number of shots required and expenses incurred by the end-user.

All in all, it was great to see the broad interest in the hardware and insightful technical questions from the audience. Looking forward to seeing what Singaporean researchers get up to with the new Helios processor once it is installed and operational in Singapore late next year!

What's next for applied quantum computing?

NISQ (noisy intermediate-scale quantum) algorithms generated a lot of excitement and a lot of publications - the 2022 review has amassed almost 2000 citations! Nowadays the tone is more subdued, with many experts believing any useful practical applications of quantum processors will need quantum error correction. The new hot topics are understanding how to make useful error correction a reality, and what might be done with a few hundred logical qubits. 

What then should a new student interested in applied quantum computing focus on?

Ryan Babbush and collaborators already argued in 2021 that algorithms with quadratic speedups won't be useful in practice. So sorry, but we won't be able to solve complex industry optimization problems using Grover search. However, their analysis indicated that quartic speedups and beyond could be practically useful. Which quantum algorithms have this property?

Consulting the excellent review article Quantum algorithms: A survey of applications and end-to-end complexities, there are only a few examples of known or suspected quartic or beyond end-to-end quantum speedups! They are:

Tensor principal component analysis (PCA). Ordinary PCA is a data reduction step widely used in data analysis and machine learning. It's not yet clear what tensor PCA might be useful for, but if an application can be found quantum computers will probably give a useful speedup.

Topological data analysis (TDA). This is another promising direction where a useful speedup for certain problems is possible. Following an initial buzz of excitement in 2022, it's unclear whether there are practical applications for where such a speedup can be useful. Recently-developed quantum-inspired classical algorithms will be useful to identify potential use-cases for quantum TDA.

On the classical computing side, quantum-inspired tensor network methods are very promising for near-term applications.  

There are also other approaches (QAOA, quantum machine learning) which attracted a lot of interest since 2020 and are still being explored theoretically, but at least in their present formulations they seem unable to provide a useful speedup for classical problems, with their most promising applications related to directly studying or simulating certain quantum systems. Thus, interest has shifted from "beating" classical methods on carefully-selected problems to better understanding the foundations of quantum machine learning. While this is a fascinating topic, it is at this stage it is more theoretical than applied research.

From NISQ to small logical quantum circuits

After six years of huge interest in NISQ (noisy intermediate-scale quantum) circuits there are still no practical applications where a noisy quantum device can outperform the best classical methods. Noise is too detrimental, and classical methods are too powerful. Experts continue to argue that now is not the time for commercial applications: quantum error correction, hundreds of logical qubits, and millions of error-corrected gates are needed.

Then what's next? Circuits of a moderate size with some limited error correction capabilities. LISQ (logical intermediate-scale quantum) or something else, for short.

What can we expect from these up and coming small scale logical circuits?

First, a lot of the tools developed for the NISQ era will become obsolete. For example, variational quantum circuits involving continuously-parameterised quantum gates cannot be easily implemented in a fault-tolerant manner. Instead, post-variational hybrid quantum-classical algorithms for this era will need to offload the continuously-parameterised part of the algorithm to a classical computer, with the quantum circuit used to measure a set of (hopefully classically-intractable) observables that are used as inputs to the classical tunable model.

Second, the hardware, algorithms, and the error correcting code cannot be considered in isolation. Choosing the right error correcting code will be essential to get the most out of the current hardware. Examples of this can be seen in QuEra's logical circuit demonstration from late last year, where the use of a 3D quantum error correction code allowed them to perform random IQP circuit sampling with error detection, and Quantinuum's recent demonstration of repeated error correction. Similar to the NISQ era, different hardware platforms will have different strengths and limitations in what kinds of circuits they will be able to run.

Finally, the most valuable software tools in the NISQ era were for quantum control and state tomography, essential to get the most out of the noisy hardware. These tools will remain important, since fidelities at the physical qubit level directly affect the amount of quantum error correction overhead required. As we move to logical circuits, the new valuable quantum software will be in the form of compilers that will take all the hassle out of hardware and error code selection out of the end-user and translate a given logical circuit into simple, understandable hardware requirements.

Towards fault-tolerant quantum computing with Rydberg atoms

 I'm a bit late to the party, but finally managed to get a chance to read the paper "Logical quantum processor based on reconfigurable atom arrays" by Harvard, QuEra, and collaborators, which hit the headlines a few weeks ago. My thoughts:

• Sadly many articles covering the paper gloss over the important distinction between error detection and error correction: QuEra's press release, The Harvard Gazette, EurekaAlert, and others. Optics & Photonics News provides more balanced coverage. The impressively high (above break-even) fidelities demonstrated in the paper require post-selection, discarding experimental runs where errors were detected. The post-selection probability is as low as 0.04% for the largest system sizes studied, and will get exponentially smaller for bigger circuits. The bottom line: scaling up to a useful size needs integration of error correction.
• How to integrate error correction? One needs to process the error detection measurements in real-time and then apply correcting gates to the qubits while the circuit is being run. Figure 4 of the paper does demonstrate implementation of measurement-dependent feedforward operations, but not yet integrated with error decoding and correction operations. This seems to be in principle an engineering challenge that can be solved with more hard work.
• Scaling up to more qubits and deeper circuits will require continuous pumping and replenishment of Rydberg atoms. Otherwise, the circuit width will be limited by the finite success probability for trapping each atom, and the depth by the ~10s trapping lifetime.
• The quantum processor architecture, involving separate storage, processing, and readout zones, as well as the ability to execute gates with arbitrary connectivity and in parallel using just a few structured laser beams, looks much more promising for scalability compared to superconducting quantum processors.

There is more discussion over at Shtetl-Optimized.

Quantum error correction - now published

The paper "Suppressing quantum errors by scaling a surface code logical qubit" by the Google Quantum AI team was published yesterday in Nature. I previously wrote about this work when the preprint was posted to arXiv last year.

The peer review file accompanying the paper is an interesting read. The authors mention challenges involved in making superconducting quantum computers that are robust to catastrophic noise induced by cosmic rays - radiation shielding will not be sufficient:

"Given the current error scale of an impact event is essentially unsurvivable, the event rate needs to be at least on the order of the computation time. Reasonable estimates for fault tolerant computations are generally measured in hours (c.f. [5] which proposes 8 hours for Shor’s algorithm), so current event rates should need to improve by around 3000x from current event rates. Additionally, if chip areas grow approximately proportional to number of qubits, given that the event rate is directly proportional to chip area, the event rate will also increase by around 100,000x from this effect, which will need to be overcome as well. The 10x reduction offered by the use of lead shielding and a low-radiation laboratory is nowhere near sufficient to solve this problem at scale."

Solving this problem will require new superconducting qubit and quantum processor designs that can be more robust to cosmic rays, e.g. localizing their disruptive effects to a small fraction of the qubits so that quantum error correction can still be applied.

 The authors also write in their reply to referees that the performance fine-tuning required for the distance-5 code to match the performance of the distance-3 code took place over 6 weeks.

As I wrote before - this is an impressive achievement, but in the race to build a working, fault-tolerant quantum computer it should be seen of the end of the beginning, not the beginning of the end!

More on quantum error correction

Hot on the heels of the Google team's recent demonstration of quantum error correction, last week Quantinuum released a heavily-promoted preprint: Implementing Fault-tolerant Entangling Gates on the Five-qubit Code and the Color Code. This work studies the performance of quantum error correcting codes using trapped ion quantum processors.

The authors compare the performance of logical gates implemented using two different error-correcting codes (5 qubit code and the colour code), without running error correction cycles. Logical CNOT gates were performed with higher fidelity compared to physical CNOT gates, however "the inclusion of QEC cycles along with more careful measurements will be crucial components in a “fair” comparison between the performance of physical and logical qubits."

Error rates are still too high for the 5 qubit code to be useful; even with a 1000-fold reduction in the physical two-qubit gate errors, simulations indicate the error correction using the 5 qubit code will not give an improvement compared to non error-corrected circuits! The authors speculate that this code might still be useful as a quantum memory.

On the other hand, "the color code CNOT with an added FT QEC cycle should eventually outperform the standalone gate, but requires somewhat lower error rates than we currently achieve. In contrast, adding a non-FT QEC to the end of the gate operation causes the simulated logical gate to always perform worse than the physical operation in the error regimes we probed." 

One challenge with the ion trap architecture is that adding additional qubits (ions) generally reduces the gate fidelities due to effects such as cross-talk. 

Another challenge identified in this work is that different error correction codes can have different performance depending on the quantum computing platform used and relative strengths of different noise sources. "It is currently difficult to predict which codes and implementations of those codes may perform the best in general scenarios, and when considering anything but the simplest error models, one is usually forced to resort to numerical studies. Additionally, the exploration space is vast."

Useful error-corrected quantum circuits are still a long way off, requiring difficult improvements to the performance of physical gates.

Quantum error correction in practice: it's really really hard

Suppressing quantum errors by scaling a surface code logical qubit

Today the Google AI team published a study demonstrating surface code quantum error correction using their superconducting quantum processor, advertised by an impressive-sounding summary on social media:

Fresh on the arxiv, Quantum AI demonstrates lower quantum error by scaling a surface code logical qubit from distance-3 (17 qubits) to distance-5 (49 qubits).

"These results mark the first experimental demonstration where quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation."

In the paper, the "improved performance" is from a 3.0% logical error rate per correction cycle (distance-3 code) to 2.9% logical error per error correction cycle (distance-5), obtained after heroic efforts to improve the performance of their device (see Fig. 3c).

Specifically, setting the qubit and gate parameters (e.g. qubit frequencies and drive pulse parameters) for the physical qubits is an incredibly complicated optimization problem:

It is noisy, non-convex, and all parameters are explicitly or implicitly intertwined due to engineered interactions and/or crosstalk. Furthermore, since each parameter is constrained to ∼ 100 values by the control electronics, processor circuit, and gate parameters, the search-space is ∼ 10^552 . This space is intractable to search exhaustively and traditional global optimizers do not perform well on the objective. Therefore, we invented the Snake optimizer to address it.

The paper notes:

"Our experiment lies in a crossover regime where, due to finite-size effects, increasing system size initially suppresses the logical error rate before later increasing it."

 and

"Based on the error budget and simulations in Fig. 4, we estimate that component performance must improve by at least 20% to move below threshold, and significantly improve beyond that to achieve practical scaling."

Take-home message: Practical quantum error correction is still a long way off!

Steps towards a quantum advantage

Xanadu's latest results on Gaussian BosonSampling attracted quite a bit of media attention. Their essential breakthrough is to combine time multiplexing with number-resolved photon detectors to massively increase the number of modes and photon counts, pushing their device into a regime that seems to be intractable using classical computers. 

It is reassuring that one of the reviewers of the Nature paper was Sergio Boixo, who has also authored work on developing more efficient classical algorithms for spoofing Gaussian BosonSampling. Other advanced classical algorithms can spoof shallow circuits and measurements with too many photons per mode.

The Gaussian BosonSampling device is now accessible on AWS. The price per shot is (\$0.00020) is slightly more than half of that of the superconducting processors (\$0.00035). Note this is not a general-purpose system, which remains challenging to implement, as noted by the Xanadu team in their paper:

If one were to target a universal and programmable interferometer, with depth equal to the number of modes, that covers densely the set of unitary matrices, the exponential accumulation of loss would prohibit showing a quantum advantage. There are then two ways around this no-go result: one can either give up programmability and build an ultralow loss fixed static interferometer, ...., or give up universality while maintaining a high degree of multimode entanglement using long-ranged gates.

Despite the lack of universality, this does seem to be the first classically-intractable programmable quantum processor available for general use via the cloud!

 On a related note, last week Nature published a paper demonstrating repeated error correction, using 17 superconducting qubits to create a single logical qubit. Each error correction cycle took 1.1 us and succeeding with 97% probability (95% without post-selection). Quantum error correction experiments are still at a very early stage; this experiment (and most others) have not yet reached the "break-even" point where the logical qubit lifetime exceeds the lifetime of a single physical qubit.