In the NISQ (Noisy Intermediate-Scale Quantum) era of quantum computing, we are constantly battling a fundamental limit: The Curse of Circuit Depth.
We know the reality: once your quantum circuit exceeds a certain depth—often around 50 to 100 two-qubit gates—the signal-to-noise ratio plummets. Coherence times run out, and gate errors compound until your result is indistinguishable from random noise.
The standard approach to simulating quantum systems (Hamiltonian simulation) has been Trotterization. While mathematically rigorous, standard Trotterization is expensive. It requires applying every term in your Hamiltonian for every time step. For a system with many interactions, the circuit depth explodes quadratically, hitting the “noise wall” long before you finish your simulation.
We are introducing a new workflow in Divi that works to mitigating this problem. By combining the QDrift protocol with our new TimeEvolution module, and scaling it via the Qoro Cloud, we can execute meaningful algorithms on sizes that were previously unreachable. We can also combine it for optimization problems, where accuracy is less important due to the heuristic nature.
What is QDrift?
QDrift (Quantum Drift) is a randomized compiling strategy that trades circuit depth for shot count.
Instead of applying every term of the Hamiltonian
in a single time step, QDrift interprets the interaction coefficients as probabilities. In every step, we sample just one (or a small budget of) interaction term and apply it.
- Standard Trotter: Deep circuits, deterministic, high gate error on hardware.
- QDrift: Shallow circuits, stochastic, requires more shots (samples) to average out the variance.
For modern QPUs, where gate fidelity is the bottleneck but shot repetition is fast, QDrift is a game changer. It allows us to compress a circuit that could be 1,000s of gates deep into one that is only a fraction of gates deep, keeping it comfortably within the coherence window.
Workflow: Local to Cloud to QPU
At Qoro, we believe in a seamless development cycle. You shouldn’t have to rewrite your code to move from a laptop to a supercomputer.
- Local: Prototyping and debugging.
- Cloud Simulator: Scaling up using Tensor Networks/MPS on Qoro’s Maestro clusters.
- QPU: Execution on real hardware.
We show how we apply this workflow in practice for two use cases: 1) Optimization with QAOA and 2) Time Evolution. Let’s look at the two practical examples using Divi and QDrift.
1. Optimization: Taming QAOA Depth for MPS simulation
The Quantum Approximate Optimization Algorithm (QAOA) is a prime candidate for QDrift. As problem graphs get denser, the mixing Hamiltonian requires more gates.
Here is how we set up a QDrift-enabled QAOA run in Divi. We define a sampling_budget (how many terms to apply) and a keep_fraction (always keep the strongest terms).
import networkx as nx
from divi.qprog import QAOA, GraphProblem, QDrift
from divi.backends import ParallelSimulator
# 1. Define the Problem (MaxCut)
G = nx.random_regular_graph(N, E, seed=1997)
# 2. Define the QDrift Strategy
# We only sample 2 terms per step, drastically reducing depth.
# We take multiple samples (n_hamiltonians) to average the gradient.
drift_strategy = QDrift(
keep_fraction=0.5, # Always keep top 50% strongest terms
sampling_budget=3, # Sample only 3 terms from the rest
n_hamiltonians_per_iteration=3,
sampling_strategy="weighted"
)
# 3. Run Locally
backend = ParallelSimulator(shots=1000, track_depth=True)
qaoa = QAOA(
problem=G,
graph_problem=GraphProblem.MAXCUT,
trotterization_strategy=drift_strategy,
backend=backend,
n_layers=1
)
qaoa.run()
print(f"Average Depth: {backend.average_depth()}")
# Result: Depth is constant and shallow, regardless of graph connectivity!To validate this, we benchmarked the two strategies on Qoro’s Maestro MPS simulator with a fixed bond dimension of 16. The results, summarized in the dashboard below, reveal a critical breaking point.
The MPS Crash at N=40
The tables tell the real story. Look at the Ratio column (Approximation Ratio vs. Classical Best):
- Exact Trotter: At N=16, it works perfectly (Ratio 1.0). But as we scale to N=40, the ratio collapses to 0.136 (marked in red). The circuit generates so much entanglement that the MPS simulator forces severe truncation to fit within the memory limit, destroying the computation.
- QDrift: At N=40, despite the inherent algorithmic noise, QDrift maintains a ratio of 0.530.
By keeping the individual circuits shallow and sparse, QDrift stays within the “entanglement budget” of the simulator. We trade a single, high-entanglement failure for an ensemble of approximate, manageable successes.
2. Time Dynamics: Surviving the Hardware
Simulating how a quantum system changes over time is the “killer app” for quantum computers. With Divi’s new TimeEvolution module, we can compare strategies directly. Simulating how a quantum system changes over time is the “Hello World” of physics simulation, but it is also where the curse of depth hits hardest.
To demonstrate this, we ran a 16-qubit Heisenberg simulation (domain wall relaxation) using Divi’s new TimeEvolution module coming in our next version deployment. We compared a standard “Exact” Trotterization against QDrift, first on the a simulator and then on real hardware.
The Setup
# Configuration: N=16, 16-qubit Heisenberg Model
# We compare Exact Trotter vs QDrift (Ensemble size = 20)
# 1. Exact Trotter (Simulator Only)
# Depth: ~189 gates. Too deep for high-fidelity hardware results.
exact_run = TimeEvolution(..., strategy=ExactTrotterization())
# 2. QDrift (Hardware Execution)
# Depth: ~48 gates. Shallow enough to survive.
# We average over 20 random trajectories (ensemble_size=20) to smooth the noise.
qdrift_run = TimeEvolution(..., strategy=QDrift(), backend=qpu_backend)The Results: Trading Precision for Signal
The results highlight the critical trade-off QDrift offers.
1. Massive Depth Reduction The standard Trotter circuit required a depth of 189. By switching to QDrift, we compressed this to ~48—a 74% reduction in gate depth.
2. Signal vs. Noise Look at the rightmost panel (Hardware). The “Total Error” is 50.3%, which sounds high. However, look at the heatmap itself. The physical structure—the “melting” of the domain wall as the spin excitation propagates—is clearly visible.
If we had run the depth-189 Exact circuit on current hardware, the result would likely have been pure speckle (random noise) due to decoherence. QDrift allowed us to “tunnel” through the noise barrier. We accepted a known algorithmic error (36%) to lower the physical error enough to see the physics.
| Metric | Exact Trotter (sim) | QDrift (Hardware) | Impact |
| Circuit Depth | 189.0 | 48.7 | 74% Reduction |
| Ensembles used | 1 (Deterministic) | 20 (Stochastic) | Trade depth for shots |
| Error | 0% Baseline | 50.3% | Physics is visible |
Why This Matters
This result validates the QDrift hypothesis for the NISQ era: A slightly biased answer is infinitely better than a perfectly calculated random number.
By using Divi’s TimeEvolution with ensemble_size=20, we effectively spread the cost. Instead of one impossibly deep circuit, we run 20 shallow ones and average the results. This workflow is now native to Divi, allowing users to seamlessly transition from local simulation, to cloud based simulation, right toquantum computers in the cloud.
Qoro’s cloud orchestration automatically applies advanced transpiling and error mitigation methods to extract the best performance. With QDrift on top, we can get usable results.
Conclusion
The “Curse of Depth” is the defining challenge of our time. By integrating QDrift into Divi, we give you a tool to bypass this wall. You can now:
- Reduce Depth: Turn a scaling depth into a constant depth.
- Scale Effortlessly: Move from local laptop debugging to massive cloud simulations to quantum with one line of code.
- Run for Real: Execute algorithms on QPUs that were previously too deep to yield results.
Get started with the new features today at qoroquantum.github.io/divi.
