Assessing non-Gaussian quantum state conversion with the stellar rank

This paper introduces the approximate stellar rank as an operational measure of non-Gaussianity to establish bounds and no-go results for approximate and probabilistic Gaussian state conversion, while providing an open-source Python library to facilitate these assessments.

The Gist

Imagine you are trying to build a complex, magical sculpture out of a very specific type of clay. In the world of quantum computing, this "clay" is a quantum state, and the "sculpture" is a useful resource needed to perform powerful calculations.

Some types of clay are easy to work with and cheap to get (these are called Gaussian states). They are like smooth, uniform playdough. You can stretch, squeeze, and mix them easily using standard tools. However, there's a catch: if you only use this smooth playdough, you can never build a sculpture complex enough to do "quantum magic" (like solving problems faster than a supercomputer). To get that magic, you need a special, rare ingredient: non-Gaussian states. These are like clay with strange textures, spikes, or glitter—harder to make, but essential for the job.

The big question scientists have been asking is: Can we turn the easy, smooth clay into the special, textured clay using only our standard tools?

The Problem: The "Perfect" vs. The "Good Enough"

Previously, scientists had a ruler to measure this. They could say, "You cannot turn a smooth ball of clay into a spiky star." But this ruler was too strict. It only worked if you demanded a perfect transformation.

In the real world, experiments are messy. You might not be able to make a perfect spiky star, but you can make one that looks 99% like it. The old ruler couldn't measure this "99% good enough" scenario. It was like trying to judge a painting by only accepting it if it was pixel-perfect, ignoring the fact that a slightly blurry version might still be a masterpiece.

The New Tool: The "Stellar Rank" and the "Approximate" Version

The authors of this paper invented a new, smarter ruler called the Approximate Stellar Rank.

• The Original Ruler (Stellar Rank): Imagine a ladder. At the bottom rung (Rank 0), you have the smooth, boring clay (Gaussian states). As you go up the ladder, the clay gets more complex and "spiky" (higher non-Gaussianity). To get to a high rung, you need to add more "magic dust" (non-Gaussian operations).
• The New Ruler (Approximate Stellar Rank): This new ruler asks a different question: "How close can we get to a high rung if we are allowed to be a little bit sloppy?"

If you want a perfect Rank 5 sculpture, you might need 5 units of magic dust. But if you are willing to accept a sculpture that is just slightly imperfect (within a tiny margin of error), maybe you only need 3 units of dust. This new ruler calculates exactly how much "magic dust" you need to get close enough to your goal.

What They Discovered

Using this new ruler, the team found several important things:

1. You Can't Cheat the Ladder: Even if you allow for a little bit of imperfection, you still can't turn a low-rank clay into a high-rank one if you don't have enough "magic dust." The paper provides a set of rules (bounds) that tell you exactly when a conversion is impossible, no matter how hard you try or how lucky you get with your measurements.
2. The "No-Go" Signs: They found specific scenarios where scientists had hoped to convert one state to another, but the new ruler proved it was impossible. It's like having a map that says, "You can't drive from here to there, even if you take a shortcut," saving researchers from wasting time trying the impossible.
3. Better Recipes: For the conversions that are possible, the ruler helps scientists see how efficient their current recipes are. If a recipe uses 10 units of magic dust to get a result, but the ruler says you only need 6, the scientists know they can improve their process to save resources.

The "Star Map"

To make this easy to calculate, the authors created a digital tool (a Python library) that acts like a Star Map.

• Imagine every quantum state has a "stellar function," like a unique star pattern.
• The tool looks at your starting star pattern and your target star pattern.
• It then calculates the "distance" between them and tells you: "To get from here to there with your current tools, you need at least X amount of effort. If you try to do it with less, you will fail."

Why This Matters

This work is like giving quantum engineers a better blueprint. Before, they were guessing if they could build a complex quantum computer part using only standard tools. Now, they have a precise calculator that tells them:

• "Yes, you can do this, but you need at least 3 copies of your starting material."
• "No, you can't do this, even if you try a million times."
• "Your current method is wasteful; you can do it with half the resources."

By understanding the limits of what can be built with "easy" tools, scientists can design better quantum computers that actually work in the real, messy world, rather than just in perfect theory.

Technical Summary

1. Problem Statement

In continuous-variable (CV) quantum information, Gaussian operations (displacements, squeezing, phase shifts, and linear optics) are experimentally accessible but classically simulatable, meaning they cannot provide a quantum computational advantage on their own. To achieve universal quantum computation, non-Gaussian resources (states or operations) are required.

A critical challenge in quantum state engineering is determining whether a specific non-Gaussian target state can be generated from a given resource state using only Gaussian operations. Previous theoretical frameworks relied on resource theories and monotones (like Wigner negativity or exact stellar rank) to bound state conversions. However, these existing bounds had two major limitations:

1. Exactness: They primarily addressed exact state conversion, whereas experimental protocols are inherently approximate (producing states within a certain fidelity or trace distance of the target).
2. Probabilistic Nature: They often failed to provide tight constraints for probabilistic (post-selected) protocols, which are common in quantum optics (e.g., heralded state preparation).

The paper addresses the gap in assessing approximate Gaussian state conversion (both deterministic and probabilistic) and provides a rigorous framework to determine the feasibility and resource costs of such conversions.

2. Methodology

The authors introduce a new theoretical framework centered on the $\epsilon$-approximate stellar rank.

A. The Approximate Stellar Rank

The stellar rank ($r_\star$) is a measure of non-Gaussianity where a state has rank $r$ if its stellar function (a holomorphic representation of the state) is a polynomial of degree $r$ multiplied by a Gaussian.

• Definition: The $\epsilon$-approximate stellar rank, $r_\star^\epsilon(\rho)$, is defined as the minimum stellar rank of any state $\tau$ that is $\epsilon$-close to the target state $\rho$ in terms of fidelity ($F(\rho, \tau) \geq 1-\epsilon$).
• Properties: The authors prove that $r_\star^\epsilon$ is a valid resource monotone under Gaussian protocols. Crucially, they demonstrate that it satisfies a sub-additivity property (Lemma 1), allowing bounds to be derived for multi-copy scenarios ($k$ copies of a state).

B. Stellar Fidelities

To compute the approximate stellar rank efficiently, the authors utilize stellar fidelities ($f_n^\star$), defined as the maximum fidelity achievable between a target state and any state of stellar rank $\leq n$.

• Computation: For pure states, computing $f_n^\star$ reduces to an optimization over Gaussian unitary operations (squeezing, displacement, and passive linear optics). This allows for efficient numerical evaluation.
• Mixed States: For mixed input states, the authors introduce pure stellar fidelities as a lower bound, enabling the assessment of conversions involving noisy or mixed resources.

C. Derivation of Bounds

Using the monotonicity of the approximate stellar rank, the authors derive families of bounds for:

1. Deterministic Protocols: Conversions that must succeed with probability 1.
2. Probabilistic Protocols: Conversions that succeed with non-zero probability (post-selection).
3. Approximate Conversions: Conversions where the output is $\delta$-close (in trace distance) to the target.

The core logic is that if a conversion is possible, the approximate stellar rank of the input must be greater than or equal to that of the output (adjusted for the approximation error $\delta$). Violating these bounds proves the conversion is impossible.

3. Key Contributions

1. Introduction of $\epsilon$-Approximate Stellar Rank: A robust, operational measure of non-Gaussianity that bridges the gap between theoretical exactness and experimental approximation.
2. General Conversion Bounds: The derivation of new, parameterized bounds (Theorems 3, 4, and 5) that apply to:
   • Exact and approximate conversions.
   • Deterministic and probabilistic (post-selected) protocols.
   • Pure and mixed input states.
3. New No-Go Theorems: The framework yields stronger "no-go" results than previous methods (e.g., Wigner Logarithmic Negativity). Specifically, it proves that converting a state of finite stellar rank to a state of infinite stellar rank (e.g., a Cat state or GKP state) is impossible via Gaussian protocols, even with post-selection, regardless of the success probability.
4. Open-Source Tooling: The authors provide a Python library (stellar-rank-numerics) to compute stellar fidelities and evaluate these bounds, making the framework accessible for experimental benchmarking.

4. Results

The authors applied their framework to several benchmark scenarios from the literature:

• Exact Conversion Limits: They showed that converting a Fock state $|1\rangle$ to $|2\rangle$ is impossible deterministically, a result stronger than what Wigner negativity alone could determine.
• Approximate Conversion (Cat to GKP): In "cat breeding" protocols (converting multiple cat states to a GKP state), the bounds delineate a clear "infeasibility region." They showed that as the amplitude of the cat state increases, the non-Gaussianity increases, shrinking the region where conversion is impossible.
• Probabilistic Conversion (Fock to Cat): For protocols converting $k$ copies of a single-photon Fock state ($|1\rangle$) to an even Cat state, the bounds revealed that existing protocols (e.g., in [46]) are far from optimal for high-amplitude targets. The bounds indicate the minimum number of copies required for a given precision, showing that current protocols use significantly more resources than theoretically necessary.
• Mixed State Inputs: The framework successfully assessed conversions from mixed states (e.g., a mixture of vacuum and single-photon states) to pure Cat states, demonstrating that the resource cost increases with the noise in the input state.

5. Significance

This work provides a unified and rigorous toolkit for the quantum optics community to evaluate the efficiency of non-Gaussian state preparation. Its significance lies in:

• Resource Optimization: It allows experimentalists to determine the theoretical lower bound on the number of resources (copies of input states) required to achieve a specific target fidelity, preventing the pursuit of impossible or inefficient protocols.
• Bridging Theory and Experiment: By explicitly handling approximation errors ($\epsilon$ and $\delta$), the theory directly addresses the realities of noisy quantum hardware.
• Scalability: The ability to compute these bounds for mixed states and multi-copy scenarios makes it applicable to complex quantum computing architectures based on bosonic codes (like GKP codes).
• Computational Complexity: The results reinforce the link between stellar rank and classical simulatability, suggesting that the approximate stellar rank could serve as a metric for the classical hardness of simulating approximate bosonic computations.

In summary, the paper transforms the stellar rank from a static classification tool into a dynamic, operational metric for assessing the feasibility and efficiency of non-Gaussian quantum state engineering.