Optimal Stabilizer Testing and Learning with Limited Quantum Memory

arXiv:2607.02444 · quant-ph, cs.CC, cs.DS, cs.IT, cs.LG, math.IT · Submitted 2026-07-02 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Optimal Stabilizer Testing and Learning with Limited Quantum Memory".

Mira: As a fastidious researcher, I have meticulously analyzed both provided summaries of the arXiv paper, "Optimal Stabilizer Testing and Learning with Limited Quantum Memory." The information is dense, technical,

Kai: First, who's behind it and why it matters.

Paper summary: Kai: So, we're looking at this paper titled "Optimal Stabilizer Testing and Learning with Limited Quantum Memory," which basically tackles the challenge of estimating unknown stabilizer states when you only have a limited amount of coherent quantum memory between measurements. The core thesis seems to be that even with this restriction, there's a fundamental trade-off between testing and learning.

Mira: Exactly, Kai; the paper shows that for unrestricted memory, we already saw results like Gross, Nezami and Walter showing how testing can be done using just six copies regardless of the dimension of the state GNW21. But when we introduce this constraint—keeping only k qubits coherent between measurements—that separation between testing and learning gets lost.

Lev: From a hardware standpoint, that means if we want to run this on actual quantum hardware, the required sample complexity changes significantly based on how much memory we actually have available.

Kai: Right, Lev? So what's the specific claim about how much data is needed for each task under these constraints according to this work?

Mira: Well, they establish two distinct lower bounds for sample complexity: for testing an unknown stabilizer state in this k-qubit memory framework, the required copies are (n - k). They also show that learning the unknown stabilizer state non-adaptively requires (n squared / k) copies <ref:2607.02444#pg1>.

Lev: That n two/k term for learning sounds substantial, especially when we consider the physical overhead of storing and manipulating those qubits coherently on a real chip <ref:2607.02444#pg0>.

Kai: So, the main point they're driving home is that the availability of coherent memory really dictates how much data you need to get what you want in terms of testing versus learning.

Mira: Precisely, and this paper highlights how memory fundamentally alters the required sample complexity compared to scenarios where you have unlimited storage <ref:2607.02444#pg2>. It sets a new benchmark for understanding these resource limitations.

Conclusion: Kai: Thinking about the title, "Optimal Stabilizer Testing and Learning with Limited Quantum Memory," it really captures the essence of what this paper is exploring, which is how memory constraints impact state estimation problems in quantum systems. The authors are essentially quantifying exactly where those limits lie when you can't just keep everything you measure.

Mira: I think their main implication is demonstrating that the testing and learning tasks don't remain cleanly separable under memory limitations, especially when k isn't very large relative to n. This suggests that in practical implementations with limited coherent workspaces, we need to approach both tasks with a more unified resource accounting.

Lev: If we were designing an error-correction protocol for a near-term device, this paper tells us exactly how much overhead we're looking at just to distinguish between testing and learning the state correctly under those memory limitations.

Kai: It really forces us to think about the practical engineering realities of building these systems and what sample sizes are actually achievable on current or near-future hardware. The findings from this paper give us concrete numbers for those limitations.

Mira: Ultimately, it frames coherent quantum memory not just as a storage device, but as a critical resource that defines the complexity of quantum information tasks like state estimation <ref:2607.02444#pg2>. It shows how restricting the workspace directly affects the required data samples for both testing and learning.

Lev: So, for researchers looking to implement these algorithms, this paper provides a very clear roadmap regarding the sample complexity you'll need to budget for depending on your memory constraints.

Srinivasan Arunachalam, Louis Schatzki

IBM Research · Dahlem Center for Complex Quantum Systems

quant-ph, cs.CC, cs.DS, cs.IT, cs.LG, math.IT

Submitted: 2026-07-02

Updated: 2026-10-05

Comments: 67 pages, 5 figures. Fixes to typos and small errors from v1

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: As a fastidious researcher, I have meticulously analyzed both provided summaries of the arXiv paper, "Optimal Stabilizer Testing and Learning with Limited Quantum Memory." The information is dense,

Key concepts

Sample Complexity
This refers to the minimum number of measurements or copies required by an algorithm to reliably test or learn an unknown quantum state. The paper quantifies this complexity based on the available memory qubits (k) and the total number of qubits (n).
Coherent Quantum Memory
This is a limited resource where only k qubits can be stored between measurements. The paper proves that having this memory allows for a clear separation between the testing process and the learning process, which is lost when memory constraints are severe.
Testing vs. Learning Separation
The study demonstrates that testing (distinguishing a state from a known one) and learning (determining an unknown state) have different scaling behaviors with respect to memory. This separation is crucial because it shows how limited memory changes the required resources for each task.

Terminology

Summary

As a fastidious researcher, I have meticulously analyzed both provided summaries of the arXiv paper, Optimal Stabilizer Testing and Learning with Limited Quantum Memory. The information is dense, technical, and relates to fundamental limits in quantum state estimation under resource constraints (limited coherent quantum memory).

Here is the comprehensive, detailed synthesis of the paper's findings:


This research investigates the fundamental limits on testing and learning unknown stabilizer states (FStab(psi) = 1) when constrained by a limited coherent quantum memory, specifically allowing only k qubits to be retained between sequential measurements. The paper establishes crucial separations between the complexity of these two tasks and demonstrates how the availability of coherent quantum memory fundamentally alters the required sample complexity compared to single-copy measurement scenarios.

The central findings establish distinct lower bounds for testing and learning under different memory constraints:

  1. Stabilizer State Testing (Adaptive Protocol):
  • The sample complexity required for an adaptive protocol using k qubits of coherent memory is (n - k) copies.

  • Theorem 1.1 provides the optimal lower bound: any such tester requires (n - k) copies to distinguish between a true stabilizer state and one with error at most epsilon.

  1. Stabilizer State Learning (Non-Adaptive Protocol):
  • The sample complexity required for a non-adaptive learning algorithm using k qubits of memory is (n squared / k) copies.

  • Theorem 1.2 establishes the optimal lower bound: any such learner requires (n squared / k) copies to recover the unknown stabilizer state.

A key contribution of this work is demonstrating that coherent quantum memory enables a clear separation between the testing task and the learning task.

  • General Case: Even when k is relatively large (e.g., 0.99n), the required sample complexity for both tasks converges to (n) copies, suggesting that for high memory utilization, testing and learning become asymptotically equivalent in terms of copy requirements.

  • The Power of Memory: The paper shows that coherent quantum memory is the resource enabling this separation.

The paper meticulously analyzes how the sample complexity scales with respect to k:

  • Single-Copy Measurement (k=0): Testing requires (n) samples, whereas the best known learning algorithm requires O(n 2) samples. This highlights a significant gap when no memory is available.

  • Growth of k: As k increases towards n, the sample complexity for learning decreases much faster than that for testing.

  • Constant Memory Fraction (k = c times n, 0 < c < 1): When the memory fraction is a constant fraction of the total qubits, both stabilizer testing and learning become asymptotically hard, requiring (n) copies.

The paper provides rigorous proofs for both the upper bounds (achievable protocols) and lower bounds (necessary requirements).

  • Upper Bound: The optimal adaptive tester achieves a sample complexity of O((n - k)/epsilon) copies. This is achieved by employing a partial Bell sampling subroutine that reveals a prefix of the Pauli label, which is linked to the hidden shift problem.

  • Lower Bound: The lower bound proof relies on considering an ensemble of random degree-2 phase states and using likelihood ratios, showing that t = (n - k) copies are necessary to distinguish a random degree-two phase state from the maximally mixed state.

  • Upper Bound: The non-adaptive learner achieves a sample complexity of O(n squared / k) copies. This is proven by partitioning the qubits into blocks of size at most k, performing Bell sampling on these blocks, and subsequently using Gaussian elimination to recover the unsigned stabilizer group matrix.

  • Lower Bound: The lower bound proof considers an ensemble of real degree-2 phase states and shows that T(k+1) = (n 2), leading directly to the (n squared / k) lower bound for non-adaptive algorithms.

The paper also draws connections between its results and related problems, specifically Purity Testing:

  • Purity Testing Lower Bound: Distinguishing a Haar random state from the maximally mixed state requires t = (n - k) samples.

Improvements for AI systems

This paper presents theoretical lower bounds for testing and learning stabilizer states in the presence of limited coherent quantum memory, specifically showing that memory is a crucial resource enabling a separation between testing and learning complexities.

Here are specific improvements to AI systems that can be enabled by leveraging these theoretical results:


) 1. Enhanced Resource-Constrained Quantum Machine Learning (QCML):

The paper proves that for stabilizer states, the sample complexity for learning scales as approximately 1/k (i.e., scaling as the inverse of memory size, specifically with a factor of 2/k in Theorem 1.2: Sample Complexity is O(n 2/k)).

  • An AI system designed for quantum state tomography or learning stabilizer circuits could be optimized to use only a tiny coherent memory (small k) while still achieving near-optimal learning performance, provided the number of copies (samples) scales appropriately.

  • Systems can be designed where the required sample size is minimized by maximizing the coherent memory utilization. For example, if an AI needs to learn a quantum circuit’s stabilizer group representation, it can operate with minimal coherence while still achieving a complexity bound that is independent of the total number of qubits when k is large enough (i.e., k = cn).

) 2. Adaptive Quantum Property Testing for Real-Time Monitoring:

The paper demonstrates an adaptive testing protocol (Theorem 4.1) that uses limited memory to distinguish between stabilizer states and non-stabilizer states with a sample complexity of O((n-k)/ε).

  • AI systems can implement real-time monitoring of quantum processes (e.g., in fault tolerance or simulation). Instead of requiring full tomography, the system can use a fixed number of copies and minimal coherence to rapidly test if the evolving state remains close to a desired stabilizer manifold.

  • This allows for adaptive decision-making: if the initial tests suggest a high probability of being non-stabilizer (a bad prefix), the system can immediately reject or flag an error, saving computational resources that would be wasted on full learning.

) 3. Efficient Quantum State Verification and Classification:

The paper establishes a clear distinction between testing and learning complexity under memory constraints.

  • AI systems focused on verifying the properties of quantum states (e.g., checking if a generated state is a stabilizer state, or classifying its purity) can use this knowledge to choose the most efficient verification strategy. If quick testing is sufficient, they can employ the O(n-k) sample complexity tester; if full learning/classification is needed, they must accept the higher O(n 2/k) cost.

  • This leads to a smart verification pipeline that dynamically switches between low-cost testing and high-cost learning phases based on initial measurement outcomes.

) 4. Robust Quantum State Characterization in Noisy Environments:

The paper shows how to recover the full state information (including signs) with a fixed number of copies, provided the memory is used strategically (Theorem 6.4).

  • AI systems operating on noisy quantum hardware can use this technique to perform robust state characterization. By pre-committing to random Clifford branches and using random stabilizer measurements, the system can recover the full stabilizer description (group and signs) even when the coherence time is limited, relying only on the limited k-qubit memory for intermediate steps.

  • This provides a theoretical framework for designing quantum error correction or state estimation protocols that are robust against decoherence by strategically managing coherent versus incoherent operations.

Abstract

We study stabilizer state testing and learning with limited coherent quantum memory. Here an algorithm sequentially receives copies of an unknown n-qubit state, but may keep only k qubits of coherent quantum memory between measurements. With unrestricted memory, seminal work of Gross, Nezami and Walter showed how to test n-qubit stabilizer states using 6 copies, which is dimension independent, unlike the learning complexity of Θ(n). We show that this testing-vs-learning separation is lost under memory constraints. More concretely we show that (1) The sample complexity of testing stabilizer states in the k-qubit memory framework is Θ(n-k). Our upper bound goes via a novel connection to the hidden shift problem and the lower bound is proven using a novel approach to average case bounds on likelihood ratios via combinatorics of the stochastic orthogonal group. (2) The sample complexity of learning stabilizer states with k qubits of memory, in the non-adaptive framework, is Θ(n 2/k). As a further application of our techniques, we prove an exponential lower bound for purity testing even when the memory may be left coherent throughout the protocol. Our main results identify coherent quantum memory as the resource enabling the usual separation between stabilizer testing and learning. In particular, even with k=0.99n qubits of memory, there is no constant-copy stabilizer tester; furthermore for k=cn qubits of memory (for 0< c < 1), stabilizer testing is as hard as learning, with both requiring Θ(n) copies.

Sources

Related papers