Average-computation benchmarking for local expectation values in digital quantum devices

This paper introduces a benchmarking scheme for digital quantum devices that assesses the quality of entire computations by averaging the target circuit with specific gate ensembles to generate classically solvable correlation functions, thereby enabling noise detection beyond the Clifford regime without altering the circuit's architecture or depth.

The Gist

The Big Problem: The "Black Box" of Quantum Computers

Imagine you have a brand new, incredibly complex machine (a quantum computer) that is supposed to solve a difficult puzzle. You turn it on, and it gives you an answer. But here's the catch: You don't know the right answer yet.

In the world of quantum computing, we are entering an era where these machines are doing things that are too hard for even the world's most powerful supercomputers to check. This is called "Quantum Advantage."

The problem is: How do you know the machine isn't broken?

• If you check every single gear (every single logic gate) in the machine, you might find they are all working perfectly. But when you put them all together, the machine might still produce garbage because of how they interact.
• If you try to simplify the machine to make it easier to check (like removing some gears), you aren't testing the real machine anymore. The noise and errors might behave differently in the simplified version.

The Solution: The "Average" Experiment

The authors of this paper propose a clever new way to test the machine without simplifying it and without needing to know the answer in advance. They call it "Average-Computation Benchmarking."

Here is how it works, using a Baking Analogy:

1. The Original Recipe (The Hard Problem)

Imagine you are trying to bake a very complex, multi-layered cake (the quantum computation). You want to know if the final cake tastes right. But you can't taste it yet because you don't have a "perfect" cake to compare it to.

2. The Old Way (Testing Individual Ingredients)

Usually, chefs would taste the flour, the eggs, and the sugar separately to make sure they are good. But tasting the ingredients doesn't tell you if the baking process ruined the cake.

3. The New Way (The "Randomized Batch")

Instead of baking just one cake, the authors suggest you bake many, many versions of the same cake, but with a twist:

• You keep the exact same recipe (circuit architecture) and the exact same oven temperature (circuit depth).
• However, for every single cake, you randomly swap out specific ingredients with very similar alternatives.
  • Example: Instead of using exactly 1 cup of sugar, you randomly use a mix of 1 cup of sugar, 1 cup of sugar + a pinch of salt, 1 cup of sugar + a drop of vanilla, etc.
• You bake 100 of these slightly different cakes.

4. The Magic Trick: The "Average" Taste

Here is the genius part:

• Individually: Each of these 100 cakes is still a complex, hard-to-predict mess. You can't easily calculate what they should taste like using a calculator.
• Collectively: If you take all 100 cakes, mash them up, and taste the average, something magical happens. The random variations cancel each other out in a specific way.
• The Result: The "average cake" becomes simple enough that a human (or a classical computer) can easily calculate exactly what it should taste like.

Why This is a Game Changer

1. It tests the whole machine, not just parts.
Because you are baking the full cake with the full recipe, you are testing how the ingredients interact in the real oven. If the machine has a hidden flaw (noise), the "average taste" of your experimental cakes will be different from the calculated "average taste."

2. It catches "Silent" Errors.
Old testing methods (called Clifford benchmarking) are like checking if a car engine runs on a flat surface. They miss problems that only show up when the car goes uphill.
The authors show that their method can detect coherent errors—subtle, consistent mistakes (like a T-gate that is rotated slightly wrong) that other methods miss completely. It's like detecting that the engine is slightly out of tune even though it starts fine.

3. It doesn't require extra hardware.
You don't need to add extra sensors or "ancilla" qubits to the machine. You just run the same circuit, but with a random shuffle of gates, and average the results.

The "Space-Time" Secret Sauce

How do they make the math work? They use a concept called Space-Time Channels.

Imagine a movie of the cake baking.

• Time: The cake goes from raw batter to baked cake.
• Space: The cake has layers (left, middle, right).

Usually, physics treats time and space differently. But the authors found a way to design their random gate swaps so that the "movie" of the baking process looks the same whether you watch it forward in time or sideways in space.

When this symmetry happens, the complex math of the "average cake" collapses into a simple multiplication problem. It's like realizing that if you walk in a perfect circle, you end up exactly where you started, no matter how many steps you took. This allows them to calculate the expected result instantly on a normal computer.

The Bottom Line

This paper gives us a new quality control checklist for quantum computers.

• Before: We could only check if the parts worked, or if the machine worked on simple, fake problems.
• Now: We can run the real hard problem, randomize it slightly, and mathematically predict what the "average" result should be. If the real machine's average result doesn't match the prediction, we know the machine is noisy and needs fixing.

It's a way to trust a black box by shaking it, listening to the average sound it makes, and knowing exactly what a healthy box should sound like.

Technical Summary

1. Problem Statement

As quantum devices approach the "quantum advantage" regime, they face a critical bottleneck: benchmarking.

• Limitations of Current Methods:
  • Single-Operation Testing: Techniques like gate tomography or randomized benchmarking assess individual gates but fail to capture the cumulative error and noise correlations of an entire circuit, especially at moderate depths.
  • Simplified Circuit Verification: Existing verification schemes often rely on running simplified circuits (e.g., Clifford circuits, smaller depths, or matchgates) that are classically simulable. However, altering the circuit architecture changes the noise behavior, making the benchmark an unreliable proxy for the target computation.
  • Unknown Outputs: Many near-term algorithms (e.g., quantum simulation) produce outputs where the ideal result is unknown, rendering standard verification impossible.
• The Goal: Develop a benchmarking scheme that tests the entire computation (preserving the original circuit's architecture, depth, and gate set) without requiring prior knowledge of the ideal output, while still allowing for classically efficient calculation of specific metrics.

2. Methodology: Average-Computation Benchmarking

The authors propose a novel scheme where the target circuit is replaced by an ensemble of randomized variants. The core idea is that while individual realizations remain classically hard to simulate, the average of these realizations yields a channel that is classically tractable.

Core Mechanism

1. Ensemble Construction: Each two-qubit gate $U_i$ in the target circuit is replaced by a random selection from an ensemble $\{U_{i,\alpha}\}$ chosen according to a distribution $p_i$.
2. Space-Time Channels: The ensemble is constructed such that the average channel $\mathcal{E}_i = \sum p_i U_{i,\alpha}(\cdot)U_{i,\alpha}^\dagger$ satisfies specific unitality conditions in both space and time directions.
   • 4-way Unital Channels: Satisfy trace preservation and unitality in both time and spatial directions.
   • 3-way Unital Channels: Satisfy trace preservation and unitality in time, plus unitality in one spatial direction.
3. Classical Tractability: These "space-time channels" allow the calculation of local correlation functions (expectation values of few-body observables) to be reduced to simple matrix multiplications (transfer matrices) of dimension 4 (for qubits), independent of the system size.
4. Quantum Execution: The user runs multiple "rounds" of the randomized circuit on the quantum device. The experimental average $\langle O \rangle_Q$ is compared against the classically computed average $\langle O \rangle_C$.

Specific Constructions

The paper provides explicit ensembles for arbitrary brickwork circuits:

• 4-way Averaging (Reflection Strategy): For a gate parameterized by angles $\vec{\theta}$, the ensemble consists of four variants where the angles are flipped ($\pm \delta_x, \pm \delta_y$) around a dual-unitary point. This preserves the original gate in the ensemble.
• 4-way Averaging (Pauli Twirling): Applying random single-qubit Pauli gates before and after the target gate. This works for any unitary.
• 3-way Averaging: Applying Pauli twirling to only one output leg of the gate, or combining dephasing with specific unitary reflections.

3. Key Contributions

• Architecture Preservation: Unlike previous methods, this scheme does not simplify the circuit into Clifford gates or reduce its depth. It tests the exact hardware execution of the target algorithm's structure.
• Classical Efficiency via Space-Time Channels: The authors leverage the theory of space-time channels (previously introduced in Quantum 7, 1020) to show that averaging over specific ensembles transforms the non-unitary evolution into a form where local observables are efficiently computable.
• Systematic Search via SDP: The paper introduces a Semidefinite Programming (SDP) framework to systematically search for new averaging ensembles. This allows researchers to find strategies that maximize the preservation of the original circuit's information (Pauli coefficients) while ensuring the resulting channel is space-time unital.
• Noise Sensitivity: The method is shown to be sensitive to coherent errors (e.g., incorrect rotation angles) that standard Clifford-based benchmarking often misses.

4. Results and Evidence

• Coherent Noise Detection: The authors simulated a brickwork circuit with a systematic T-gate rotation error. Standard Clifford benchmarking failed to detect this error, whereas the average-computation scheme showed a clear deviation between the experimental and theoretical expectation values.
• Sample Complexity: Numerical simulations indicate that the variance of the expectation values across different circuit realizations is small. Consequently, only a limited number of shots (circuit realizations) are required to estimate the average with high precision, making the method experimentally feasible.
• Decay of Correlations: The benchmarking signal (correlation) decays exponentially with circuit depth. The decay rate is determined by the eigenvalues of the transfer matrices. While this limits the method to low-to-mid-depth circuits (typical of near-term devices), the signal remains detectable for relevant depths.
• Noise Modeling: The framework can also be used to benchmark specific noise models (e.g., Pauli noise) by incorporating the noise channel into the classical calculation, allowing for direct comparison with experimental data.

5. Significance and Impact

• Bridging the Gap: This method fills a critical gap between single-gate testing and full-circuit verification. It provides a "gold standard" for assessing the quality of complex, non-simulable quantum computations without needing to know the answer in advance.
• Hardware Characterization: It offers a powerful tool for diagnosing hardware performance, specifically detecting coherent errors that are often overlooked by randomized benchmarking.
• Algorithm Validation: It allows researchers to gain confidence in the results of quantum simulations (e.g., many-body dynamics) where classical simulation is impossible, by verifying that the device behaves consistently with the theoretical average of the randomized ensemble.
• Scalability: The method is applicable to arbitrary digital quantum circuits and can be generalized to higher dimensions (qudits and 2D lattices) and different noise models.

In summary, the paper introduces a robust, architecture-preserving benchmarking protocol that leverages the mathematical properties of space-time channels to make the verification of complex quantum computations classically feasible, offering a significant step forward in validating near-term quantum devices.