Compressed Sensing for Efficient Fidelity Estimation of GHZ States

This paper proposes a compressed sensing protocol that leverages the inherent sparsity of Greenberger-Horne-Zeilinger (GHZ) states to drastically reduce measurement overhead for fidelity estimation, demonstrating its high accuracy and robustness in noisy environments through simulations and experiments on Quantinuum's trapped-ion hardware.

The Gist

Imagine you are trying to verify that a massive, intricate sculpture made of glass (a quantum computer's "GHZ state") is perfect. If you try to inspect every single tiny crack and dust particle on every piece of glass, you would need to take millions of photos. This is like Quantum State Tomography, the standard method described in the paper. It's so expensive and time-consuming that for large sculptures, it's practically impossible.

The authors of this paper propose a clever shortcut using a technique called Compressed Sensing. Here is how they did it, explained simply:

1. The "Sparse Signal" Trick

The authors realized that the "noise" or "signal" coming from these quantum states isn't a chaotic mess; it's actually very organized. Think of it like a radio station. Even though the airwaves are full of static, the music you want is just one specific frequency.

In their case, the "music" is the quantum state's stability (fidelity). Because the signal is so "sparse" (it only exists at one specific frequency), they don't need to take millions of photos. Instead, they can take just a handful of random snapshots. Using a mathematical algorithm (like a detective piecing together a puzzle from a few clues), they can reconstruct the entire picture of the sculpture's quality from these few random samples. This reduces the work from a mountain of data to a small pebble.

2. The "Flag Qubit" Security Guards

Building a large glass sculpture is dangerous; if one piece breaks, the whole thing might shatter. In quantum computing, errors happen easily. To catch these errors before they ruin the experiment, the team used Flag Qubits.

Imagine you are building a tower of blocks. Instead of checking the whole tower at the end, you place a tiny, sensitive "flag" (a special sensor) on specific blocks. If a block wobbles or breaks during construction, the flag immediately flips up.

• The Strategy: The team used a smart computer algorithm to figure out exactly where to place these flags so that they could watch the most critical parts of the tower.
• The Result: If a flag flips, they know something went wrong, and they throw that specific attempt away (a process called "post-selection"). They only keep the attempts where all the flags stayed down. This ensures that the final group of sculptures they analyze are the cleanest, highest-quality ones.

3. Testing the Theory

The team didn't just do this on paper; they tested it in two ways:

• In a Simulator: They ran the experiment on a super-fast computer that mimics a quantum computer. They found that even with "noise" (simulated errors), their method of taking few random snapshots and using flags worked perfectly. It accurately told them how good the state was.
• On Real Hardware: They ran the experiment on a real quantum computer made by Quantinuum (which uses trapped ions, like atoms floating in a magnetic field).
  • They successfully created large entangled states (up to 50 qubits).
  • They found that using the "flag" security guards significantly improved the quality of the states they kept.
  • They also discovered that while the flags helped catch random errors, the extra steps needed to check them sometimes introduced a slight "twist" (phase error) in the state. However, their math was smart enough to correct for this twist and still report the true quality of the entanglement.

4. Cleaning Up the Mess (Error Mitigation)

Even with flags, real-world quantum computers have other issues, like "reading errors" (the computer misreading a 0 as a 1) or "drifting" (the atoms getting slightly out of sync while waiting).

• The Fix: They applied two extra "cleaning" techniques:
  1. Readout Correction: A mathematical filter that fixes the computer's tendency to misread the final result.
  2. Dynamical Decoupling: A technique of tapping the atoms rhythmically while they wait, keeping them from getting "distracted" or losing their focus.
• The Outcome: Combining the flags with these cleaning techniques gave them the most accurate results possible on the noisy hardware.

The Bottom Line

The paper proves that you don't need to check every single detail of a complex quantum state to know if it's good. By using Compressed Sensing (taking few, smart samples) and Flag Qubits (strategic error detectors), you can verify large, complex quantum states quickly and accurately, even on imperfect, noisy machines. This makes it much easier to test and improve future quantum computers.

Technical Summary

1. Problem Statement

The creation and verification of large-scale Greenberger-Horne-Zeilinger (GHZ) states are fundamental to quantum computing, serving as benchmarks for hardware performance and resources for applications like quantum secret sharing and metrology. However, verifying these states faces two critical challenges:

• Scalability of Verification: Standard Quantum State Tomography (QST) and Direct Fidelity Estimation require resources that scale exponentially or linearly with the number of qubits ($N$), making them prohibitively expensive for large $N$. Even parity oscillation methods, which are more efficient, typically require $O(N)$ or $2N$ measurement points to satisfy the Nyquist-Shannon sampling theorem, which is still costly for large systems.
• Noise Sensitivity: Large GHZ states are extremely sensitive to experimental imperfections. Errors in preparation (e.g., gate infidelities) propagate rapidly, and standard verification often fails to distinguish between stochastic errors and coherent phase shifts without excessive overhead.

2. Methodology

The authors propose a hybrid framework combining Compressed Sensing (CS) for efficient signal reconstruction and Flag Qubit-based Error Detection for noise mitigation.

A. Compressed Sensing for Parity Oscillation

• Sparsity Exploitation: The parity oscillation signal of an $N$-qubit GHZ state, $P(\phi)$, is a sparse signal in the frequency domain. It can be modeled as $C \cos(N\phi + \theta)$, containing only a single dominant frequency component ($N$) and its conjugate.
• Measurement Reduction: Instead of measuring at $2N$ equally spaced angles (Nyquist requirement), the protocol measures parity at $M$ randomly chosen angles, where $M \ll 2N$.
• Reconstruction Algorithm:
  1. Support Detection: The authors use an $L_1$-regularized least squares optimization (Lasso) to identify the dominant frequency $n_{rec}$ from the sparse measurement data.
  2. Parameter Refinement: Once the frequency is identified, an unregularized Ordinary Least Squares (OLS) fit is performed on the specific frequency components to estimate the amplitude ($C$) and phase ($\theta$) without the bias (shrinkage) introduced by Lasso.
• Theoretical Guarantee: Based on the Restricted Isometry Property (RIP), the number of measurements required scales logarithmically with system size ($M \propto \log N$), offering an exponential improvement over standard parity oscillation.

B. Flag Qubit Error Detection

• Strategy: To mitigate errors during state preparation, the authors employ "flag qubits" (ancilla qubits) to perform parity checks on subsets of data qubits.
• Optimization: The placement of these flags is optimized using a greedy algorithm to maximize "coverage." Coverage is defined as the fraction of the preparation circuit's error propagation paths (from leaf qubits to the least common ancestor in the CNOT tree) that are monitored by a flag.
• Post-Selection: Experimental shots where a flag qubit indicates an error (measures '1') are discarded. This "heralded" selection yields a state with significantly higher fidelity.
• Hardware Adaptation: The protocol is adapted for Quantinuum's trapped-ion hardware, which features all-to-all connectivity. This allows for the preparation of GHZ states in $O(\log N)$ depth and simplifies the selection of qubit pairs for parity checks, reducing the overhead of extra operations.

C. Error Mitigation (QEM)

The study also integrates classical post-processing techniques:

• Readout Error Mitigation (REM): Corrects measurement bias using an inverse confusion matrix.
• Dynamical Decoupling (DD): Inserts identity-equivalent gate sequences (XX pairs) during idle times to suppress low-frequency dephasing.

3. Key Contributions

1. Logarithmic Scaling Verification: Demonstrated that compressed sensing can reconstruct GHZ state fidelity with $O(\log N)$ measurements, drastically reducing the experimental overhead compared to $O(N)$ or exponential methods.
2. Robust Hardware Implementation: Successfully tested the protocol on Quantinuum's H2-1 trapped-ion processor (up to 50 qubits) and simulators, proving viability in noisy environments.
3. Integrated Error Detection: Showed that combining CS with flag-based error detection significantly improves the fidelity of heralded states, particularly by filtering stochastic bit-flip errors.
4. Insight into Error Types: Provided a detailed analysis distinguishing between stochastic errors (filtered by flags, improving coherence) and coherent errors (accumulated phase offsets $\theta$). The authors highlight that while flags improve the "rotated fidelity" (structural entanglement), they can inadvertently increase the global phase offset due to extra gate operations, lowering the "standard fidelity" against the ideal state.

4. Experimental Results

• Simulation Accuracy: Numerical simulations for $N \in [5, 40]$ showed that the CS estimator maintains high accuracy with $M \approx 5 \ln N$ random samples. The probability of correctly identifying the oscillation frequency converges to ~100% once $M$ exceeds a heuristic threshold (e.g., $M=15$ for $N=42$).
• Fidelity Improvement:
  • In simulations ($N=10$), increasing the number of flag pairs from 0 to 2 (increasing coverage from 0% to 90%) resulted in a marked increase in post-selected fidelity.
  • Hardware (Quantinuum H2-1): For a 50-qubit GHZ state, adding flag qubits improved the rotated fidelity (which accounts for phase shifts) and population, confirming the detection of stochastic errors.
  • Error Mitigation: On the H2-2E emulator, Readout Error Mitigation (REM) provided the most significant boost to fidelity, correcting the large classical bias inherent in multi-qubit readout. Dynamical Decoupling (DD) showed modest gains, likely because the emulator's noise model lacked the correlated low-frequency drifts present in physical hardware.
• Phase Offset Trade-off: The experiments revealed that adding flag checks introduces additional two-qubit gates and ion transport, leading to coherent over-rotations. This accumulates into a global phase offset $\theta$, which suppresses the standard fidelity ($F = \frac{1}{2}(P + C\cos\theta)$) even as the underlying coherence ($C$) improves.

5. Significance

This work provides a practical, scalable pathway for benchmarking next-generation quantum processors. By leveraging the sparsity of GHZ signals and the error-detection capabilities of all-to-all connected architectures, the authors demonstrate that:

• Efficiency: High-fidelity verification is possible without the resource explosion of full tomography.
• Robustness: The combination of compressed sensing and heralded error detection is viable for large-scale entangled states in noisy intermediate-scale quantum (NISQ) devices.
• Future Directions: The paper suggests that the flag placement problem is a submodular maximization task that could be solved more efficiently using tree-dynamic programming, and that the single-frequency recovery problem connects to broader classical signal processing techniques (e.g., sparse Fourier transforms) for further optimization.

In summary, the paper establishes a new standard for verifying large entangled states, balancing measurement efficiency with noise resilience, and offering critical insights into the trade-offs between stochastic error filtering and coherent error accumulation in trapped-ion systems.