Implementing Jastrow--Gutzwiller operators on a quantum computer using the cascaded variational quantum eigensolver algorithm

The Gist

Imagine you are trying to find the perfect recipe for a complex dish, like a soufflé. You know the basic ingredients (the atoms), but the secret to a great soufflé lies in how those ingredients interact with each other while baking. If you ignore those interactions, your dish will be flat and bland.

In the world of quantum physics, scientists are trying to find the "perfect recipe" for the lowest energy state of a system (like electrons in a material). This is called the "ground state."

Here is a simple breakdown of what this paper does, using everyday analogies:

1. The Problem: The "Non-Unitary" Chef

Quantum computers are like incredibly fast, but very fragile, chefs. They can explore a massive number of possibilities (Hilbert spaces) that classical computers can't handle. However, there's a catch.

To get the best recipe, scientists want to use a special tool called a Jastrow–Gutzwiller operator. Think of this tool as a "flavor enhancer" that adds complex, multi-ingredient interactions to the mix.

• The Issue: This flavor enhancer is "non-unitary." In quantum language, this means it's like a recipe step that breaks the rules of the kitchen. You can't just press a button on a standard quantum computer to do it; it's like trying to bake a cake by un-baking it first. It's mathematically difficult to implement directly.

2. The Solution: The "Cascaded" Assembly Line

The authors propose a new way to use this tool called the Cascaded Variational Quantum Eigensolver (CVQE).

Instead of trying to force the quantum computer to do the impossible "non-unitary" step all at once, they break the process into two parts, like an assembly line:

• Part A (The Unitary Chef): The quantum computer does the standard, rule-abiding cooking. It rearranges the ingredients into a good starting shape (using something called a "Thouless operator").
• Part B (The Flavor Enhancer): The "non-unitary" flavor enhancer (the Jastrow–Gutzwiller operator) is handled differently. Instead of trying to bake it into the quantum circuit, the authors move the heavy lifting of this specific part to a classical computer (a regular laptop).

The Analogy: Imagine you are building a house. The quantum computer is the robot arm that lays the bricks perfectly. The "flavor enhancer" is the paint and wallpaper. Instead of trying to make the robot arm paint while it lays bricks (which it can't do well), the robot lays the bricks, and then a human painter (the classical computer) comes in to apply the paint based on the measurements the robot took. They work together in a loop to get the perfect house.

3. The Test: The "Hubbard Model"

To prove this works, the team tested their method on a famous physics puzzle called the Hubbard model.

• What is it? Think of it as a grid of tiny islands (sites) where electrons (the guests) can hop around. Sometimes, two guests try to sit on the same island, which causes a "crowding" problem (interaction).
• The Setup: They tested this on two shapes: a square and a triangle, each with four spots.
• The Goal: They wanted to find the lowest energy state for these electrons, specifically when the grid is "half-filled" (two guests on four spots).

4. The Results: Real Hardware vs. Simulation

They ran their experiment on a real quantum computer called IBM Q Lagos (which has 7 qubits, or "quantum bits").

• The Challenge: Real quantum computers are noisy. It's like trying to hear a whisper in a windy room. The data they got was "noisy," meaning the results weren't perfectly sharp.
• The Trick: To make the results clearer, they used a clever shortcut. Since the electrons have "spin" (up or down), they ran the quantum computer for only the "spin-up" electrons and simulated the "spin-down" ones on a classical computer. This cut the number of required quantum bits in half, reducing the noise significantly.
• The Outcome:
  • Their method (the green and orange lines in their charts) got very close to the "exact" answer (the red dashed line), which is what you would get if you could solve the math perfectly on a supercomputer.
  • Even with the noise from the real machine, their approach worked better than just guessing.
  • They showed that by moving the complex "flavor enhancer" part to the classical computer, they could get accurate results without needing extra, complicated quantum hardware.

Summary

The paper demonstrates a new way to teach a quantum computer how to handle complex interactions between particles. Instead of forcing the quantum computer to do a mathematically forbidden move, they split the job: the quantum computer does the physical rearranging, and a regular computer handles the complex correlation math. They proved this works on a real, noisy machine by solving a puzzle about electrons on a small grid, getting results that were surprisingly close to the perfect theoretical answer.

Technical Summary

Technical Summary: Implementing Jastrow–Gutzwiller Operators on a Quantum Computer using the Cascaded Variational Quantum Eigensolver

Problem Statement
Quantum computers offer the potential to access exponentially large Hilbert spaces to determine the ground states of quantum systems, a task often intractable for classical computers. While variational algorithms like the Variational Quantum Eigensolver (VQE) are promising for near-term devices due to their short circuit depth, they rely heavily on the choice of an ansatz. A powerful approach to improve variational states is the use of Jastrow–Gutzwiller operators, which add many-body correlations (specifically density-density correlations and restrictions on doubly occupied orbitals) to a trial state. However, the Jastrow–Gutzwiller operator is non-unitary. This non-unitarity presents a significant challenge for direct implementation on quantum computers, which inherently operate via unitary evolution. Existing methods often require auxiliary qubits or approximations to handle this non-unitarity, which can increase circuit depth and complexity beyond the capabilities of current hardware.

Methodology
The authors propose a novel implementation of the Jastrow–Gutzwiller operator using the Cascaded Variational Quantum Eigensolver (CVQE) algorithm. The core of their method is an ansatz of the form $\hat{A}(\theta) = \hat{G}(\theta)\hat{U}$, where:

• $\hat{U}$ is a unitary Thouless operator that performs a change of basis in the one-body Hilbert space (e.g., transforming a Fock state into a Fermi sea).
• $\hat{G}(\theta)$ is the non-unitary Jastrow–Gutzwiller operator, defined as $\hat{G}(\theta) = \exp(-\sum_{qq'} \theta_{qq'} \hat{n}_q \hat{n}_{q'})$, where $\hat{n}_q$ are number operators and $\theta_{qq'}$ are variational parameters.

The key innovation lies in how the expectation value of the energy, $E(\theta) = \frac{\langle \Psi_n | \hat{G}(\theta) \hat{H} \hat{G}(\theta) | \Psi_n \rangle}{\langle \Psi_n | \hat{G}^2(\theta) | \Psi_n \rangle}$, is computed. Because $\hat{G}(\theta)$ is diagonal in the occupation number basis, the authors demonstrate that the exponential terms in the operator product can be evaluated classically based on measurement outcomes, rather than requiring the expansion of the exponential into a sum of Pauli strings on the quantum computer.

The procedure involves:

1. State Preparation: Preparing an initial state $|\Psi_n\rangle = \hat{U}|\Phi_n\rangle$ using a quantum circuit composed of elementary single- and two-qubit gates derived from the decomposition of the unitary operator $\hat{f}$.
2. Measurement: Measuring the system in the computational basis (or a rotated basis for kinetic terms) to obtain occupation numbers.
3. Classical Post-Processing: Using the measured occupation numbers to evaluate the diagonal exponential factors of $\hat{G}(\theta)$ and $\hat{G}^2(\theta)$ classically. This avoids the need for additional qubits or deep circuits to simulate the non-unitary operator.
4. Optimization: Varying the parameters $\theta$ classically to minimize the energy expectation value.

Key Contributions

• Non-Unitary Operator Implementation: The paper presents a method to implement non-unitary Jastrow–Gutzwiller operators on quantum hardware without adding auxiliary qubits or approximating the operator, leveraging the CVQE framework.
• Efficient Measurement Scheme: By mapping the problem such that number operators remain diagonal, the authors show that the exponential terms can be inserted directly into the energy calculation based on measurement results, significantly reducing the measurement overhead compared to expanding the operator into Pauli strings.
• Spin-Species Decoupling: The method allows for the evaluation of the circuit for only a single spin species on the quantum computer, with the other species handled classically. This effectively halves the number of required qubits for the demonstration.
• Experimental Demonstration: The method is demonstrated on the IBM Q Lagos quantum processor (a 7-qubit device) for a four-site Hubbard model on both square and triangular lattices with periodic boundary conditions at half-filling.

Results
The authors applied their method to the Hubbard model with kinetic energy parameter $k$ and interaction strength $d$.

• Energy Minimization: They successfully minimized the energy expectation value $E(\theta)$ with respect to the Gutzwiller parameter $\theta$.
• Comparison: The results were compared against exact diagonalization (the exact ground state energy) and noise-free classical simulations of their method.
• Noise Analysis:
  • When running the full calculation (both spin-up and spin-down electrons) on the quantum device, noise introduced errors in the energy expectation values.
  • When running only a single spin species on the quantum device (with the other simulated classically), the error was significantly reduced.
  • The error in the energy expectation value remained relatively constant as a function of interaction strength $d$, and in some cases slightly decreased as $d$ approached $k$.
• Optimization: The optimal parameter $\theta^*$ was found by locating the minimum of the energy curve, and the resulting optimized energies tracked the exact ground state energy closely, particularly in the single-spin-species configuration.

Significance and Claims
The paper claims that this approach allows for the implementation of the Jastrow–Gutzwiller ansatz on near-term quantum hardware without the resource overhead of auxiliary qubits or the approximation errors associated with other non-unitary implementations. By moving the evaluation of the non-unitary exponential factors to the classical computer, the method decouples the optimization of variational parameters from the need to re-run quantum circuits for every parameter update. Furthermore, the ability to simulate only one spin species on the quantum device while handling the other classically reduces the qubit count requirement by half, making the approach more feasible for current devices with limited connectivity and coherence times. The demonstration on the IBM Q Lagos device validates the feasibility of this "cascaded" approach for fermionic systems, specifically the Hubbard model, providing a pathway to incorporate strong correlation effects into variational quantum algorithms.