⚛️ quantum physics

Performance and scaling analysis of variational quantum simulation

This paper presents an empirical analysis demonstrating that variational quantum simulation (VQS) exhibits superior scaling in circuit depth compared to Trotterized time evolution for simulating quantum systems, thereby identifying a potential advantage region for VQS when considering both system size, simulation time, and classical complexity.

Original authors: Mario Ponce, Thomas Cope, Inés de Vega, Martin Leib

Published 2026-04-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mario Ponce, Thomas Cope, Inés de Vega, Martin Leib

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Simulating the Unseeable

Imagine you want to predict how a complex machine works—like a swarm of bees, a chemical reaction, or a new material. To do this on a regular computer, you have to calculate the position and energy of every single particle. As the system gets bigger, the math explodes. It's like trying to count every grain of sand on a beach, then every grain on every beach on Earth, all at once. Regular computers hit a wall and give up.

Quantum computers are special because they speak the same language as nature (quantum mechanics). They can simulate these systems naturally. However, current quantum computers are like "noisy, fragile prototypes." They can't run long, complex programs without making mistakes (due to "noise" and short memory).

This paper asks a simple question: What is the best way to make a quantum computer simulate time passing without it breaking down?

The authors compare two methods:

Trotterization: The "old school" method.
VQS (Variational Quantum Simulation): The "new, adaptive" method.

The Two Competitors

1. The "Brick-by-Brick" Method (Trotterization)

Imagine you are walking across a river by stepping on stones.

How it works: You take tiny, fixed steps. To cross the river (simulate time), you just keep stepping.
The Problem: If the river is wide (long simulation time), you need thousands of steps. Each step adds a "brick" to your path. If you have too many bricks, the path gets too tall and wobbly, and you fall in (the computer makes errors).
The Paper's Finding: This method is reliable for short trips, but as the trip gets longer, the path gets impossibly deep and unstable.

2. The "Smart Navigator" Method (VQS)

Imagine you are driving a car across that same river, but you have a GPS that constantly adjusts your route.

How it works: Instead of taking fixed steps, the car (the quantum computer) has a flexible suspension (a "parametrized circuit"). It looks at where it is, checks the map (the physics), and adjusts its wheels (parameters) to stay on the best path.
The Advantage: It doesn't need a million tiny steps. It can take a few big, smart turns to get across.
The Catch: The GPS needs to do a lot of math on a regular computer to tell the car how to steer. This is the "hybrid" part (Quantum + Classical).

The Race: Who Wins?

The authors ran a simulation race to see which method required the "deepest" path (circuit depth) to get a good result.

The Results:

Short Trips: The "Brick-by-Brick" method (Trotter) is fine. It's simple and works well.
Long Trips: The "Smart Navigator" (VQS) wins big. As the simulation time gets longer, the Brick method needs to build a skyscraper of steps. The Navigator method just adjusts its steering and keeps the path relatively flat.

The Analogy:
If you want to walk 100 miles:

Trotter says: "I will take 100,000 tiny steps." (Tiring, high risk of tripping).
VQS says: "I will take 500 smart strides, adjusting my balance as I go." (Less tiring, stays stable longer).

The paper shows that for long simulations, VQS requires significantly fewer "steps" (circuit depth) than Trotter. This is crucial because current quantum computers can only handle short paths before they get "tired" (lose their quantum information).

The Hidden Cost: The "Co-Pilot" Problem

There is a twist. The "Smart Navigator" (VQS) needs a co-pilot (a classical computer) to do heavy math to figure out how to steer.

The Concern: What if the co-pilot does so much math that it defeats the purpose? What if it's cheaper to just use a supercomputer to do the whole job?
The Finding: The authors did the math. They found a "sweet spot."
- For small systems, a regular computer is faster.
- For medium-to-large systems, the VQS method (Quantum + Classical Co-pilot) is actually cheaper than trying to simulate the whole thing on a regular computer.
- It creates a "corridor" where VQS is the winner: big enough to be hard for regular computers, but small enough that the quantum computer can handle the steering without breaking.

The Conclusion: Why This Matters

We are currently in the "NISQ era" (Noisy Intermediate-Scale Quantum). Our quantum computers are fragile. They can't run the deep, long programs required by the old "Brick" method (Trotter).

This paper suggests that the "Smart Navigator" (VQS) is our best bet for the near future.

It allows us to simulate longer times without the computer crashing.
It opens the door to simulating things that settle into a steady state or behave chaotically over time—things we couldn't see before.

In a nutshell: The paper proves that while the "Smart Navigator" (VQS) needs a bit of help from a regular computer, it is the only way to drive a quantum car across a long, bumpy road without falling off the edge. It identifies the specific conditions where this new method beats the old one, giving us hope for practical quantum simulations sooner than we thought.

1. Problem Statement

The paper addresses the challenge of simulating the real-time evolution of quantum systems ( $\frac{d}{dt}|\Psi(t)\rangle = -iH|\Psi(t)\rangle$ ) on Near-Term Intermediate Scale Quantum (NISQ) devices.

The Bottleneck: Traditional methods, specifically Trotterization (product formulas), require circuit depths that scale linearly or polynomially with simulated time and system size. On NISQ hardware, circuit depth is strictly limited by qubit coherence times ( $T_1$ ). Consequently, long-time simulations using Trotterization are often infeasible due to excessive depth requirements.
The Alternative: Variational Quantum Simulation (VQS) is proposed as a noise-resilient, hybrid quantum-classical alternative. However, while theoretical bounds exist, there is a lack of empirical data regarding VQS's scaling performance compared to Trotterization, specifically regarding the minimum circuit depth required to achieve a target fidelity.

2. Methodology

The authors conducted an empirical scaling analysis comparing VQS against a second-order Trotter-Suzuki product formula.

System Model:
- Hamiltonian: A 1D nearest-neighbor Transverse-Field Ising Model with random coefficients: $H = \sum a_k X_k + \sum b_{i,j} Z_i Z_j$ .
- Instances: 50 random instances of Hamiltonian coefficients and initial states were generated for robustness.
- System Size ( $n_q$ ): Ranged from 2 to 10 qubits.
- Simulated Time ( $t_f$ ): Ranged from 1 to 14 time units.
Algorithms Compared:
1. VQS:
  - Ansatz: A problem-specific Hamiltonian Variational Ansatz (HVA) where layers correspond to the Pauli strings of the Hamiltonian. The structure mimics a product formula but with trainable parameters.
  - Update Rule: Uses McLachlan's variational principle to solve a linear system of ODEs ( $A\dot{\theta} = C$ ) for parameter updates.
  - Classical Solver: Uses a least-squares solver (NumPy lstsq) with Tikhonov regularization to handle the ill-conditioned Quantum Fisher Information (QFI) matrix $A$ .
  - Integration: Adaptive Runge-Kutta 45 (SciPy) for time integration.
2. Trotterization:
  - Used a second-order Strang splitting formula.
  - Depth increases monotonically with time steps to maintain accuracy.
Benchmarking Protocol:
- Metric: Minimum Circuit Depth required to achieve a state fidelity $> 0.95$ (error $< 0.05$ ) compared to an exact classical solution (QuTiP).
- Adaptive Process: The number of layers in the VQS ansatz was increased iteratively until the fidelity threshold was met.
- Scaling Scenarios:
  1. $t_f = n_q$ (Time scales linearly with system size).
  2. Fixed $n_q$ , varying $t_f$ (Long-time evolution).

3. Key Contributions

Empirical Scaling Analysis: Provides the first detailed empirical study of VQS scaling against Trotterization for time evolution, moving beyond theoretical error bounds.
Identification of Advantage Regions: Defines specific regimes (in terms of system size and time) where VQS requires significantly lower circuit depth than Trotterization.
Classical Complexity Assessment: Analyzes the classical computational cost of the VQS hybrid loop (matrix inversion) versus purely classical simulation, establishing a "feasibility corridor" where VQS outperforms both Trotterization and classical simulation.

4. Results

The study yielded several critical findings regarding circuit depth scaling:

Scaling with System Size ( $n_q$ ):
- When $t_f = n_q$ , VQS consistently required a lower minimum depth than Trotterization across the tested range (2–10 qubits).
- Fitting Function: The depth $D$ $D$ was fitted to a power law $D(n_q, t_f) = a n_q^b t_f^c$ $D (n_{q}, t_{f}) = a n_{q}^{b} t_{f}^{c}$ .
  - VQS: $b \approx 1.0$ (linear scaling with qubits), $c \approx 0.74$ (sub-linear scaling with time).
  - Trotter: $b \approx 0.45$ (sub-linear scaling with qubits), $c \approx 1.29$ (super-linear scaling with time).
- Implication: While Trotter scales better with system size, VQS scales significantly better with simulated time.
Scaling with Simulated Time ( $t_f$ ):
- For fixed system sizes, the depth requirement for Trotterization grows rapidly (super-linearly) as time increases.
- VQS exhibits a slower, sub-linear growth rate with respect to time.
- Conclusion: For long-time simulations, VQS becomes increasingly advantageous over Trotterization, potentially enabling simulations that would otherwise exceed coherence limits.
Classical Cost vs. Quantum Advantage:
- The classical cost of VQS is dominated by inverting the QFI matrix ( $O(m^3)$ , where $m$ is the number of parameters).
- The authors derived a threshold where the classical cost of VQS remains lower than a full classical simulation ( $O(k 2^{n_q})$ ).
- Result: There exists a "corridor" of system sizes where VQS is superior to both Trotterization (due to lower depth) and classical simulation (due to lower classical cost). This corridor widens as simulated time increases.

5. Significance and Outlook

NISQ Relevance: The results suggest that VQS is a viable candidate for long-time quantum dynamics on current hardware, where Trotterization fails due to depth constraints. This is crucial for studying phenomena like steady states or chaotic behavior that require long simulation times.
Quantum Advantage: The paper identifies a concrete scenario for quantum advantage: simulating long-time dynamics of local spin systems where the hybrid VQS approach outperforms both standard quantum algorithms (Trotter) and classical methods.
Limitations & Future Work:
- The results are empirical; a full theoretical proof of scaling is still lacking.
- Numerical Instability: The VQS algorithm relies on inverting the QFI matrix, which can be ill-conditioned, leading to numerical instability.
- Noise: The study used noiseless simulations. Future work must address how measurement noise affects the parameter updates and the robustness of the overlap estimation.
- Cost: The total computational cost includes the number of circuits required to estimate the QFI matrix, which scales with the number of parameters.

In summary, the paper demonstrates that while VQS may not offer a depth advantage for short-time simulations, its superior scaling with respect to simulated time makes it a promising strategy for long-duration quantum dynamics on NISQ devices, provided the classical overhead and numerical stability are managed.