Noisy vs. fault-tolerant quantum computing - understanding the needs

It is critical to understand the difference between today’s noisy and tomorrow’s fault-tolerant quantum computer. Solving complex problems of real value, in, e.g., electronic structure calculations in large, complex molecules, actually does not require that many qubits (a few 100s of them), so what’s the big deal? Can’t we already get that commercially in current gate-based quantum computers?

Yes, but critically the qubits performing the calculation must be highly insensitive to errors. This is what we mean when we refer to fault-tolerant operation, and such qubits are denoted “logical qubits”. They are needed because the quantum algorithms that solve these complex problems require executing millions of quantum logical gate operations before convergence occurs. If error correction is not carried out during these operations, the noise will accumulate, and the solution will not converge.

This is why it is important to pursue fault-tolerant quantum computers: the quantum processor unit (QPU) would need to have on the order of millions of qubits and few 100s-1,000 logical qubits in order to accurately solve a large, complex, and realistic quantum-chemical problem within a few days.

In turn, on today’s noisy quantum computer, we have to settle for “noisy intermediate scale quantum” (NISQ) applications: due to decoherence, the qubits lose their superposition state too quickly, which in turn leads to a reduced “circuit depth”, i.e., how many sequential logical operations we can perform, before errors and noise limit the calculation. On NISQ machines, the noise will accumulate when the circuit depth increases, limiting the number of operations. Thus, while the next generation NISQ quantum computers certainly have enough qubits to be of interest (e.g., 433 qubits on the IBM Osprey expected later this year, or 216 qubits on the current Xanadu Borealis), they are not reliable enough to be able to attack problems in quantum chemistry involving large, complex molecules.

Understanding the scope of fault-tolerant quantum computers

In a recent paper, Goings et al. (Google, Boehringer Ingelheim, QSimulate collaboration) investigated the cytochrome P450 enzyme, and assessed the computational resources needed to assess its electronic structure [1].

The electronic structure of complex chemical compounds like enzymes is the exact class of hard problems where quantum computers offer a potential new approach to find an accurate solution: the problem becomes exponentially larger every time an orbital is added to the chemical problem, and this is inherently built into the quantum computer approach, where each added qubit doubles the number of states that can be represented.

The cytochrome P450s (see picture) is a superfamily of enzymes that plays the role as a catalyst in steroid hormone synthesis and drug metabolism, and is found throughout the kingdoms of life (animals, plants, bacteria, viruses etc.).

The premise of the paper

• A fault-tolerant quantum computer exists.
• It has a large number of physical qubits with a finite, small error rate.
• To implement the fault-tolerant operation, an error correction code (chosen as the so-called “surface” code) is applied to a large number of physical qubits to operate the small number of logical qubits. Surface codes are building blocks of quantum computing platforms based on 2D arrays of qubits responsible for detecting and correcting errors. The ratio between the number of physical qubits needed to implement a single logical qubit depends on 1)?the desired computation time, including the number of executed gates required to uphold the fault-tolerance of the logical qubit, and 2)?the error rate of the physical qubit.

Solution strategy

The paper then lays out a strategy for solving the quantum chemical problem on a fault-tolerant quantum computer.

• The quantum chemical calculations in the quantum computer rely on simply using a phase-estimation algorithm on the electronic structure Hamiltonian to find the ground-state energy.
• The number of logical qubits needed depends on the number of orbitals in the active space of the quantum chemical system, and on the approach used; in this paper they chose a qubitised quantum walk algorithm that was solved in three different ways.

Background explanation on the resources needed to solve the problem

The paper then turns to estimating what is needed for solving the quantum chemical problem on a fault-tolerant quantum computer. The computational overhead (i.e., number of gate executions, number of qubits, etc.) that are needed for the problem to converge depends on several factors.

First, we have the factors stemming from the algorithm choice and its numerical implementation

• As they use an iterative algorithm, the desired convergence accuracy is an important factor.
• The three ways the algorithm was solved turned out to give quite different requirements and execution times, so the specific choice of algorithm must be chosen carefully.

Secondly, we have factors stemming from the chemical and dynamical nature of the problem: The computational overhead will for instance depend directly on the temporal dynamics of the chemical system (the so-called L1-norm of the Hamiltonian coefficients). That is, the complexity increases the more the chemical system depends on time, and this directly affects the execution time in terms of number of iterations before convergence.

Finally, and most important for our discussion here, is factors stemming from the complexity in executing the required quantum logical gates on a fault-tolerant quantum circuit.

• A particular obstacle is the so-called Toffoli gates needed to execute the quantum walk algorithm.

1. The Toffoli gate is a quantum computer logic gate (a CCNOT or controlled-controlled-not gate) that acts on 3 qubits. It is a gate that is typically not directly executable on a quantum computer circuit, and it is instead implemented by decomposing into roughly 5 native (i.e. “easy”) two-qubit gates.
2. Importantly, each Toffoli gate will rely on executing a number of so-called T-gates, which is a native quantum phase-shift gate.
3. The main issue is that the T-gate, and in turn therefore also the Toffoli gate, is not native to the surface code implementation (the code that provides error correction), and it is therefore very expensive to execute each Toffoli gate. To do this “T-gate factories” are needed, and around 2/3 of all physical qubits in a future million-qubit QPU will be used to execute T-gates in such factories.

• The number of gates needed to execute the surface code will also contribute to the total gate count, cf. above. This is because each time a Toffoli gate is executed, the noise will go up in the logical qubits, and the surface code will then have to clean that up to avoid accumulating errors.
• A large number of Toffoli gate executions are needed to converge the chemical problem towards a solution, and the overhead of this is more costly than keeping the logical qubits “alive”, i.e., execution of the error-correction code to reduce the noise accumulated when the Toffoli gates are executed using the T-gate factory.
• Finally, the circuit clock cycle is obviously important, which differs dramatically from platform to platform. In the paper a 1-μs surface-code cycle time is assumed (i.e., 1 million cycles per second).

Specific resource examples

While more technical details can be found in the paper on these aspects, we here provide a short summary for the resources needed to solve the ground state energy calculations for the cytochrome P450 enzyme:

• Already for just 10 orbitals (a limited active space of the chemical problem), the number of logical qubits required was found to be around 200-300, depending on how the quantum walk protocol is implemented. The number of logical quantum gates required was found to be on the order of 100 millions (counted as the number of Toffoli gates required, which is the most time consuming gate in execution). Add to this that in order to execute each Toffoli gate a number of lower-level gate operations must be executed as well, roughly five 2-qubit gates as mentioned above, and that included in these are the T-gates executed in a T-gate factory.
• For 40 orbitals (a more complete active space), the number of logical qubits exceeded 1,000 and the number of Toffoli gates required exceeded 1 billion.
• The number of physical qubits were estimated for some of the cases, and in the model with the largest active space around 5 million qubits were needed when the physical qubit error rate was 0.1%, and with a QPU runtime of around 70 hrs assuming 1-μs cycle times (using reasonable estimates from state-of-the-art superconducting qubits).

In a similar study, Google together with collaborators from Columbia University, Macquarie University, and University of Washington, investigated the FeMo-cofactor of the nitrogenase enzyme [2]. This so-called FeMoCo molecule is important for understanding the mechanism of biological nitrogen fixation. They found that it can be simulated using about four million physical qubits and under 4 days of runtime, assuming 1-μs cycle times and physical gate-error rates no worse than 0.1%. This is just shy of one trillion clock-cycles.

Conclusion

Based on these reflections, there is no doubt that in order to execute such refined quantum chemical calculations on real problems, it imposes massive requirements on the quality and scalability of the quantum computer, which must be operated in a fault-tolerant mode in order for the problem to converge.

• While the enormous advantage of exponential scalability of quantum computers implies that even with just a few 100s of logical qubits even a large, complex chemical problem can be solved accurately, the cost of operating these logical qubits is large: executing the quantum logical gates needed to solve the problem requires enormous “gate factories”, necessitating on the order of millions of physical qubits, because the required quantum logical gates are not easily executed in the framework of the error correction code.
• Cleaning up the errors from each execution is, in turn, a minor part of the QPU run time.

There is currently no path for a NISQ computer to be able to faithfully execute on the order of millions-billions of Toffoli gates. The long-term aim must therefore be to develop a fault-tolerant quantum computer with on the order of millions of physical qubits with on the order of 100-1,000 logical qubits. At the same time, any improvements on the algorithm side to implement and solve the chemical problems in a smarter and more efficient way will lead to huge reductions in requirements on the hardware part.

When will we have such a large-scale fault-tolerant quantum computer? We could expect to have a scalable qubit platform ready in the next decade, clearing the path towards access to 100s or even 1,000s of logical qubits.

References

[1] J. J. Goings et al., “Reliably assessing the electronic structure of cytochrome P450 on today’s classical computers and tomorrow’s quantum computers”, PNAS 119, e2203533119 (2022), https://doi.org/10.1073/pnas.2203533119, https://arxiv.org/abs/2202.01244

[2] J. Lee et al., “Even more efficient quantum computations of chemistry through tensor hypercontraction”, PRX Quantum 2, 030305 (2021), https://doi.org/10.1103/PRXQuantum.2.030305, https://arxiv.org/abs/2011.03494