The theory of variational hybrid quantum-classical algorithms

If you want to simulate a molecule quantum mechanically, you need a quantum computer. If you need a quantum computer, you need one that is error-free and millions of qubits deep. If you need that, you'll be waiting decades. Unless — and this is the move — you're willing to rethink what a quantum algorithm is allowed to look like. That's the problem McClean, Romero, Babbush, and Aspuru-Guzik set out to solve. Their paper extends the theory of variational hybrid quantum-classical algorithms, building on the variational quantum eigensolver, abbreviated as VQE, first demonstrated by Peruzzo and colleagues in 2014. The core insight behind VQE was almost defiant in its simplicity: even minimal quantum resources could be useful when paired with classical optimization routines. You don't need a perfect machine. You need a clever loop. Here's how that loop works. You pick a set of parameters, run a short quantum circuit that prepares a trial state depending on those parameters, and then measure the energy of that state. The energy here is the expectation value of the Hamiltonian, which is the operator that encodes everything about the system's physics. Then a classical optimizer looks at that energy and proposes new parameters, aiming lower. You repeat this process until the energy bottoms out. The conceptual anchor is the variational principle: for any trial state you can prepare, the measured energy is guaranteed to be an upper bound on the true ground-state energy. You can never accidentally measure something lower than the actual ground state. So the best parameters you find give you the tightest upper bound your circuit family can produce. That guarantee is what makes the whole scheme trustworthy even on noisy hardware. Measuring the energy in practice is done through what the authors call Hamiltonian averaging. Any Hamiltonian can be written as a weighted sum of simpler operators — specifically, tensor products of Pauli matrices. You measure each term separately on copies of the prepared state, multiply each result by its coefficient, and add everything up. The statistical cost of reaching a target precision scales roughly as one over precision squared, so pushing for higher accuracy gets expensive fast. This is exactly why the paper spends so much effort on ways to reduce that cost. Now, the loop is only as good as the states it can reach. This is where McClean et al. make their most substantial theoretical contributions, developing two concrete strategies for building trial states — what the field calls ansätze. The first is a variational adiabatic ansatz. Adiabatic quantum computing works by slowly interpolating a Hamiltonian from something easy to solve toward the problem you actually care about, ensuring the system stays in its ground state throughout. The trouble is, doing this slowly enough is expensive — it can require very long quantum evolution times. McClean et al. turn the schedule itself into a variational object. Instead of committing to a fixed linear interpolation, you parameterize the path through Hamiltonian space with a small set of numbers — in their demonstration, a two-parameter cubic spline — and then optimize those parameters to minimize the final energy. In a one-qubit avoided-crossing example with perturbation size set to 0.1, the variationally optimized spline naturally slowed near the minimum gap without any prior knowledge of where that gap was, and achieved comparable ground-state preparation while cutting the required evolution time by roughly a factor of ten compared to a standard linear schedule. The second ansatz is unitary coupled cluster, abbreviated as UCC — a method borrowed from quantum chemistry and adapted for quantum hardware. The UCC state is prepared by applying the exponential of an anti-Hermitian operator to a reference state: take the cluster operator T, subtract its Hermitian conjugate, and exponentiate. The resulting operator is unitary by construction, which makes it natural to implement on a quantum device. To actually run this on hardware, you use a technique called Trotterization — breaking the single large exponential into a product of many smaller exponentials, each of which is easier to implement as a quantum gate sequence. Here's the key insight the authors add: if you allow each Trotter step to have its own independent parameters rather than treating the decomposition as a fixed approximation, you're no longer approximating UCC — you're defining a new, more expressive ansatz. McClean et al. show that at second order in the cluster expansion, this relaxation is powerful enough to realize an arbitrary two-qubit unitary on any pair of qubits. This means second-order UCC with Trotterization yields a universal gate set. It's a concrete bridge from a physically motivated chemistry method to the full power of quantum computation. With better ansätze in hand, the paper turns to a question that matters enormously for any near-term device: what happens to errors? The answer McClean et al. offer is one of the more surprising ideas in the paper. On a noisy, pre-threshold device — before full quantum error correction is available — the variational loop itself can suppress certain errors for free. The logic runs like this. Many hardware errors push the prepared state into higher-energy regions of the variational space. Because the classical optimizer is already penalizing energy, it will steer the parameters away from those regions, naturally correcting for the error. The authors formalize this as quantum variational error suppression, defining an error as suppressible if a small adjustment to the parameters can undo its effect. Not all errors are suppressible this way. Symmetry-violating errors — ones that break physical conservation laws the ansatz is supposed to respect — cannot be fixed by parameter shifts alone. For those, McClean et al. introduce an auxiliary Lagrangian: you add penalty terms to the cost function that push the optimizer to respect the desired symmetries. Measure whether the state violates a symmetry, penalize violations, and the optimizer learns to avoid them. In the limit of large penalty weights, the symmetries are exactly enforced. The critical point is that this costs almost no additional hardware resources. Just a few extra measurements and some classical bookkeeping. Compare that to full quantum error correction, which requires enormous qubit overhead. Variational error suppression is not a replacement, but it's a practical path for the devices we have right now. The final piece of the paper is the most immediately practical, and it produces the most striking number. McClean et al. benchmark two categories of cost reduction: smarter measurements and better classical optimization. On the measurement side, they study truncation — ordering Hamiltonian terms by their maximum possible contribution and simply dropping the smallest ones. The trick is balancing the bias introduced by dropping terms against the variance you're now allowed on the retained terms, keeping the total mean-square error within the desired precision. Combined with grouping commuting Pauli terms so they can be measured on the same state preparation — saving expensive circuit runs — these strategies can cut measurement costs substantially. A good grouping, the paper illustrates, reduced cost by nearly a factor of two compared to measuring all terms individually. On the classical optimization side, the savings are far more dramatic. The objective function in VQE is stochastic — every energy measurement is noisy — which makes gradient-based optimizers unreliable. The original VQE implementation used the Nelder-Mead simplex algorithm because of its robustness to noise, but McClean et al. benchmark Nelder-Mead against several TOMLAB algorithms — GLCLUSTER, LGO, and MULTIMIN — on a hydrogen molecule test case encoded to four qubits with simulated measurement noise. The TOMLAB methods not only reached higher energy accuracy; they required up to one thousand times fewer function evaluations than Nelder-Mead. Three orders of magnitude. A factor of a thousand. Given that each function evaluation requires running and measuring a quantum circuit, this is not an abstract algorithmic detail — it's the difference between an experiment that is feasible and one that isn't. McClean et al. are careful not to overclaim. They don't argue that these hybrid methods beat classical computers at everything. What they present is a coherent strategy for the pre-fault tolerant era: better ansätze that reach physically relevant states efficiently, error suppression that requires no additional hardware, measurement strategies that cut circuit runs, and classical optimizers that reduce the number of those runs by orders of magnitude. Each piece addresses a real bottleneck. Together, they form a practical agenda. The honest question the paper leaves open is whether this hybrid approach is a bridge to something larger — a stepping stone toward fault-tolerant quantum advantage — or whether it will prove to be a destination in its own right. The authors don't resolve that. But they make a strong case that waiting for the perfect machine before doing useful quantum chemistry is a choice, not a necessity. This lecture was created by ennepō. Go to https://ennepo.ai to Discover, Create and Follow the latest research in your field. Read when you can. Listen when you want to.