Tensor-based phase difference estimation on time series analysis

This paper proposes a scalable and accurate tensor-network-based phase difference estimation algorithm for time series analysis that combines algorithmic error mitigation and iterative circuit optimization, achieving high precision in noiseless simulations and demonstrating significant progress on IBM Heron devices for models up to 52 qubits.

The Gist

Imagine you are trying to figure out the exact distance between two specific notes on a piano. In the world of quantum physics, this "distance" is called an energy gap, and knowing it helps scientists understand how materials behave, how medicines work, or how new batteries might function.

The problem? Calculating this distance on a regular computer is like trying to count every grain of sand on every beach on Earth—it takes too long and requires too much power. Quantum computers promise to do this quickly, but they are currently very "noisy" (prone to errors) and can't handle very complex tasks yet.

This paper presents a clever new recipe for using today's imperfect quantum computers to measure these energy gaps accurately, even for very large systems. Here is how they did it, broken down into simple concepts:

1. The Problem: The "Deep" Circuit

Usually, to measure energy, a quantum computer has to run a very long, complex sequence of instructions (a "circuit"). Think of this like trying to walk across a room while blindfolded. If the path is short, you might make it. But if the path is long (deep), you will likely trip, fall, and get lost before you reach the end. Current quantum computers trip over themselves if the instructions are too long.

2. The Solution: "Squishing" the Instructions (Tensor Networks)

The authors used a mathematical trick called Tensor Networks. Imagine you have a giant, tangled ball of yarn representing a complex quantum calculation. Instead of trying to untangle the whole thing at once, this method "squishes" the ball into a flat, neat strip (like a matrix product state) that keeps all the important information but removes the unnecessary bulk.

• The Analogy: It's like taking a complex 3D sculpture and flattening it into a 2D blueprint. The blueprint is much easier to handle, but if you know how to read it, you can still rebuild the sculpture perfectly.
• The Result: This allowed them to run the experiment on quantum chips with up to 52 qubits (the basic units of quantum info), which is a massive jump from previous attempts that could only handle about 8 or 9.

3. The Strategy: Listening to the "Echo" (Time-Series Analysis)

Instead of trying to get the answer in one giant, perfect shot, they used a technique called Time-Series Analysis.

• The Analogy: Imagine you are in a canyon and you clap your hands. You don't need to see the canyon walls to know how far away they are; you just listen to the echo. The longer the echo takes to return, the farther away the wall is.
• How it works: They let the quantum system evolve over time and took "snapshots" (measurements) at different moments. By looking at how the signal changed over time, they could mathematically "listen" to the energy gap, just like listening to an echo. This allowed them to use much shorter, simpler circuits that current noisy computers can actually handle.

4. Fixing the Mistakes: The "Noise-Canceling Headphones"

Even with shorter circuits, the quantum computer still makes mistakes (noise). The authors introduced two smart fixes:

• Algorithmic Error Mitigation (AEM): Imagine you are trying to hear a song on a radio with static. Instead of just turning up the volume, you play the song at three different speeds and mix them together. The static cancels out, and the music becomes clear. They ran their calculation with slightly different settings and combined the results to cancel out the errors.
• Iterative Optimization (Building a Better Map): Sometimes the starting point of the experiment isn't perfect. They used a "try, fix, try again" approach. They optimized the starting state, merged it with a mathematical model, and repeated the process. It's like a sculptor chipping away at a block of stone, checking the shape, and refining it step-by-step until it looks exactly right.

5. The Big Win

They tested this on real quantum computers made by IBM (specifically the "Heron" chips).

• They successfully measured energy gaps for systems as large as 52 qubits.
• They proved that even with the noise of today's machines, their "squishing" and "echo-listening" techniques could get results with very high accuracy (within about 1% to 5% of the true value).

Why Does This Matter?

This is a huge step forward. It shows that we don't have to wait for "perfect" quantum computers (which might be 10 years away) to do useful science. By using smart math to "compress" the work and "clean up" the errors, we can start solving real-world problems—like designing better solar panels or new drugs—on the noisy machines we have right now.

In a nutshell: They figured out how to make a wobbly, noisy quantum computer do a complex job by simplifying the instructions, listening to the results over time, and using math to cancel out the mistakes. It's a bridge between the quantum computers of today and the powerful ones of the future.

Technical Summary

Here is a detailed technical summary of the paper "Tensor-based phase difference estimation on time series analysis."

1. Problem Statement

Quantum Phase Estimation (QPE) is a fundamental algorithm for calculating energy eigenvalues and gaps in chemical and physical models. However, standard QPE requires deep circuits with controlled operations, making it intractable for current Noisy Intermediate-Scale Quantum (NISQ) devices.

• The Challenge: Existing time-series-based QPE approaches (which avoid controlled operations) still suffer from deep circuits for state preparation and time evolution, leading to high error rates on noisy hardware.
• Specific Bottlenecks:
  1. Circuit Depth: Implementing accurate time evolution and state preparation for large systems (e.g., Hubbard models) requires circuits too deep for current hardware.
  2. Optimization Cost: Compressing these circuits into Matrix Product States (MPS) and Matrix Product Operators (MPO) leads to exponential growth in classical computational cost as circuit depth increases.
  3. Accuracy: Noise (depolarizing errors) and approximation errors (Trotterization, tensor compression) degrade the fidelity of the extracted energy gaps.

2. Methodology

The authors propose a scalable Quantum Phase-Difference Estimation (QPDE) algorithm that combines tensor-network circuit compression with time-series analysis. The core workflow involves:

A. Circuit Architecture & Compression

• Single Ancilla Qubit: The algorithm uses only one ancilla qubit and system qubits, avoiding complex multi-qubit controlled gates.
• Brick-Wall Ansatz: Both the state preparation ($U_{prep}$) and time evolution ($U_{evol}$) circuits are compressed into "brick-wall" structures composed solely of nearest-neighbor gates.
• Tensor Network Compression:
  • $U_{evol}$ is optimized to approximate $e^{-iH\Delta t}$ by minimizing the Frobenius norm distance against a reference MPO.
  • $U_{prep}$ is optimized to prepare a superposition of ground and excited states ($\frac{1}{\sqrt{2}}(|0\rangle|\psi_g\rangle + |1\rangle|\psi_{ex}\rangle)$) approximated by MPS.
• Data Extraction: By measuring the circuit with four different phase gate settings ($\theta = 0, \pi/2, \pi, 3\pi/2$), the algorithm extracts a complex time signal $s_t$. This signal contains the energy gap information in the form of $s_t = \sum P_J e^{-i\Delta_J t}$.

B. Key Technical Innovations

To address the limitations of NISQ devices, the authors introduce two refinement techniques:

1. Algorithmic Error Mitigation (AEM):

   • Based on the dynamical multi-product formula, this technique mitigates approximation errors (e.g., Trotter errors and tensor compression errors).
   • It constructs a refined density matrix $\mu(t) = \sum c_i(t) \rho_i(t)$, where $\rho_i(t)$ are density matrices generated by time evolution operators with varying accuracy (different numbers of Trotter slices or optimization sweeps).
   • Coefficients $c_i(t)$ are optimized classically to minimize the error against a precise reference, effectively canceling out systematic errors.

2. Iterative Circuit Optimization for Overlap Enhancement:

   • Directly optimizing a deep circuit to maximize the overlap with a target MPS is classically expensive (exponential cost).
   • Solution: An iterative approach where the circuit is built layer-by-layer. In each iteration $k$, a shallow circuit $U^{(k)}_{prep}$ is optimized to maximize overlap with a target state. This optimized circuit is then "merged" into the MPS, creating a new target state for the next iteration.
   • This allows the construction of deep circuits ($d_{prep} \approx 24$) while keeping the classical optimization cost manageable, significantly improving the initial state overlap.

C. Classical Post-Processing

• The extracted time series data is processed using direct data fitting combined with the matrix pencil method to extract eigenvalues (energy gaps).
• Depolarizing noise is modeled as an amplitude decay factor $(1 - p_{dep}(t))$, which does not affect the frequency (gap) extraction, only the signal-to-noise ratio.

3. Key Contributions

1. Scalable QPE-Type Algorithm: Demonstrated the largest-scale QPE-type algorithm to date, successfully running on 52-qubit models (36 system qubits + 1 ancilla + 15 virtual qubits in the mapping context, though the paper specifies 53-qubit circuits for 52 system qubits).
2. Novel Error Mitigation: Introduced a specific AEM framework tailored for tensor-compressed circuits, proving it can reduce energy gap errors significantly without requiring error-corrected hardware.
3. Efficient State Preparation: Developed an iterative merging strategy that overcomes the exponential classical cost barrier, enabling the preparation of high-overlap states for deep circuits.
4. Real Hardware Validation: Successfully executed the algorithm on IBM Heron devices using Q-CTRL's Fire Opal error suppression, handling circuits with over 4,000 two-qubit gates.

4. Results

• Simulation (Noiseless):
  • For an 8-qubit 1D Hubbard model, the algorithm achieved energy gap errors between 0.4% and 4.7% relative to the true gap, depending on the time-step size ($\Delta t$).
  • AEM reduced errors significantly, particularly when varying the number of optimization sweeps.
  • Overlap enhancement successfully increased the overlap from 0.76 (standard method at depth 12) to 0.81 (iterative method at depth 24).
• Real Hardware (IBM Heron):
  • 9-qubit model: Achieved an error of 0.001 with AEM (vs. 0.033 without), demonstrating the efficacy of error mitigation.
  • 37-qubit and 53-qubit models: Despite rapid signal decay limiting the number of time steps (19 and 11 steps respectively), the algorithm produced results where the zero-error line fell within the standard deviation error bars.
  • The method successfully handled circuits with 4,146 and 4,091 two-qubit gates, exceeding the limits of classical Full Configuration Interaction (FCI) benchmarks.

5. Significance

• Bridge to Fault Tolerance: This work represents a critical step toward practical quantum advantage. It demonstrates that QPE-type algorithms, traditionally reserved for fault-tolerant quantum computers (FTQC), can be adapted for near-term devices through tensor network compression and advanced error mitigation.
• Scalability: By reducing the circuit depth to nearest-neighbor gates and utilizing classical post-processing, the approach bypasses the depth limitations of current hardware.
• Practical Application: The ability to calculate energy gaps for systems larger than 46 qubits (the limit of classical FCI) on real hardware opens new avenues for simulating complex chemical and physical systems that were previously intractable.
• Future Outlook: The paper highlights that while current accuracy is limited by noise and signal decay, the framework is robust. With future improvements in gate fidelity and error correction, this approach is poised to become a standard tool for high-precision quantum simulation.