⚛️ quantum physics

Bosonic quantum error-correcting codes with finite stellar rank

This paper utilizes stellar rank as a resource measure to demonstrate that finite non-Gaussian preparation costs necessitate a trade-off between ideal error correction and practical feasibility, leading to optimized bosonic codes with noise-adapted structures that can surpass the break-even point even at low stellar ranks.

Original authors: Rui Wang, Adithi Udupa, Timo Hillmann, Ulysse Chabaud, Alessandro Ferraro, Giulia Ferrini

Published 2026-07-08

📖 4 min read🧠 Deep dive

CC0 1.0

Original authors: Rui Wang, Adithi Udupa, Timo Hillmann, Ulysse Chabaud, Alessandro Ferraro, Giulia Ferrini

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a super-secure vault to protect a tiny, fragile piece of information (a "logical qubit"). In the world of quantum computers, this vault is often built using light waves or sound waves in a container, known as a "bosonic mode."

The problem is that these waves are naturally messy. They lose energy (like a spinning top slowing down) or get confused about their timing (like a clock losing its rhythm). To fix this, scientists use special "codes" to protect the information. But here's the catch: the best codes require building very complex, strange shapes out of light that nature doesn't give us for free. Creating these shapes requires a lot of "effort" or "resources."

This paper introduces a new way to measure that effort, called Stellar Rank. Think of Stellar Rank as a "complexity score."

Rank 0: A simple, smooth wave (easy to make).
Rank 1: A wave with one little "bump" or twist (a bit harder).
Rank 10: A wave with ten complex twists and turns (very hard to make).

The paper asks: How complex does our vault need to be to actually work, given that we can only build vaults up to a certain complexity score?

The Main Discovery: The "Perfect" isn't always the "Best"

The researchers looked at two famous types of vaults:

Cat Codes: These look like a wave that is in two places at once (like Schrödinger's cat being both alive and dead).
GKP Codes: These look like a grid of tiny dots in a field, very precise and regular.

In a perfect world where we have infinite resources, we would build the most complex, perfect version of these vaults. But in the real world, we are limited. We can only build vaults with a low "Stellar Rank" (low complexity).

The Surprise: The paper found that the "perfect" vault design doesn't always win when you are limited on resources.

Imagine trying to draw a perfect circle. If you only have a few crayons (low Stellar Rank), trying to draw a giant, perfect circle might look like a messy blob.
However, if you draw a smaller, simpler circle with those same few crayons, it might look much cleaner and actually protect your secret better.
The Lesson: Sometimes, a "simpler" version of a code that is easier to build performs better than a "perfect" version that is too hard to build accurately.

The Trade-Off: Energy vs. Protection

The researchers tested these codes against two types of noise:

Photon Loss: Like a bucket with a hole, where water (energy) leaks out.
Dephasing: Like a spinning top that starts wobbling and losing its direction, but doesn't fall over.

They found a fascinating trade-off:

For Leaking Buckets (Photon Loss): The best codes looked like grids (like the GKP codes). They needed to be structured and precise, but not too "energetic" (too much water), or the hole would drain them too fast.
For Wobbling Tops (Dephasing): The best codes looked like rotating wheels (like the Cat codes). They needed to be spread out and symmetrical to resist the wobbling.

The "Break-Even" Point

In engineering, "break-even" is the moment your invention starts working better than doing nothing at all.

The paper showed that you don't need a super-complex vault (high Stellar Rank) to beat doing nothing.
For the "wobbling" problem, even a very simple vault (Stellar Rank 2) was enough to win.
For the "leaking" problem, you needed a slightly more complex vault, and the more the bucket leaked, the more complex the vault had to be.

The "Custom-Built" Vault

Finally, the researchers didn't just test existing designs; they tried to design new vaults from scratch specifically for the limited resources they had.

They used a computer to search for the best possible shape for a vault with a fixed "complexity score."
The Result: The computer invented new shapes that looked like grids for leaking buckets and rotating wheels for wobbling tops. These custom-built vaults performed better than the standard, pre-made ones, proving that tailoring the code to the specific noise and the available resources is the key to success.

Summary in One Sentence

This paper proves that when building quantum vaults, you don't need the most complex, perfect design to win; instead, you need a simpler, custom-built design that matches the specific type of trouble your system faces and the amount of "effort" you can afford to spend building it.

Technical Summary: Bosonic Quantum Error-Correcting Codes with Finite Stellar Rank

Problem Statement
Bosonic quantum error correction (QEC) offers a promising route to encoding logical qubits into the infinite-dimensional Hilbert space of a bosonic mode, utilizing continuous-variable states like cat codes and Gottesman–Kitaev–Preskill (GKP) codes to suppress dominant noise such as photon loss and dephasing. However, these encodings are intrinsically non-Gaussian, requiring resources beyond standard Gaussian operations (e.g., displacement and squeezing). In practical experimental settings, particularly in photonic systems, non-Gaussian resources are limited and costly to prepare. The central problem addressed is how finite non-Gaussian resources constrain the preparation accuracy of bosonic codewords and, consequently, their logical error-correction performance. Specifically, it remains unclear what minimal resource cost is required to surpass the "break-even" point (outperforming an unencoded qubit) and whether ideal codewords remain optimal when preparation constraints are imposed.

Methodology
The authors introduce stellar rank ( $r^\star$ ) as a resource measure, defined as the minimal number of photon additions required to generate a single-mode non-Gaussian state given arbitrary Gaussian operations. They utilize stellar fidelity ( $f^\star_k$ ) to quantify the quality of approximating a target state with a bounded stellar rank $k$ .

The study proceeds in two main phases:

Approximation of Fixed Code Families: The authors analyze standard cat codes and GKP codes. They numerically optimize the stellar fidelity of these target states under finite stellar rank constraints by optimizing over Gaussian unitaries (displacement and squeezing). They then benchmark the resulting approximate codewords under photon loss and dephasing noise channels using optimal recovery (computed via semidefinite programming) to determine the logical channel fidelity.
Direct Optimization of Encodings: Moving beyond fixed target states, the authors directly optimize bosonic encodings within variational classes constrained by a fixed stellar rank $k$ . To ensure computational tractability, they use Petz-recovery fidelity as a surrogate objective function during the search, while the final performance is benchmarked using optimal recovery. The optimization involves jointly tuning Gaussian parameters and the coefficients of a "core" state in the Fock basis.

Key Contributions and Results

Trade-offs in Fixed Code Families:
- For cat codes, the study reveals that higher coherent amplitudes ( $\alpha$ ) require higher stellar ranks to achieve high stellar fidelity due to the increased phase-space separation of components. The convergence to unit fidelity is non-monotonic in practice due to optimization landscapes, with "plateau" regions appearing where finite-rank approximations capture only partial rotational structures.
- For GKP codes, less damped states (smaller regularization parameter $\Delta$ ), which are closer to the ideal infinite-energy limit, require significantly higher stellar ranks to approximate accurately.
- Break-even Analysis: Finite-rank approximations can surpass the break-even threshold before exact preparation is achievable. For cat codes, the required stellar rank to break even increases with amplitude $\alpha$ . For GKP codes under photon loss, break-even is achieved at low stellar ranks ( $k=3$ to $4$) even for states with stellar fidelities far from unity. However, under dephasing, finite-rank GKP approximations fail to surpass break-even within the studied rank range.
- Suboptimality of Ideal Codes: A critical finding is that codewords optimal in the infinite-resource limit (e.g., less damped GKP states with smaller $\Delta$ ) can become suboptimal under finite-rank constraints. The preparation error of a highly non-Gaussian target may outweigh its intrinsic error-correction properties, making a more easily preparable, "worse" ideal state perform better in practice.
Optimized Encodings:
- Direct optimization of encodings at fixed stellar rank reveals noise-adapted code structures.
- Under photon loss, optimized encodings evolve from localized low-rank structures toward grid-like Wigner functions (resembling GKP states) as $k$ increases.
- Under dephasing, optimized encodings develop approximate rotation-symmetric structures (resembling cat codes), favoring broader phase-space separation.
- Resource Thresholds: For dephasing noise, a stellar rank of $k=2$ is sufficient to surpass break-even for all considered noise strengths. Under photon loss, the required stellar rank increases with the loss rate.
- Performance Comparison: At a fixed stellar rank ( $k=4$ ) and loss rate ( $\kappa t = 10^{-2}$ ), the optimized encoding achieved a lower channel infidelity ( $1.99 \times 10^{-4}$ ) compared to both the finite-rank approximation of a standard cat code ( $3.41 \times 10^{-4}$ ) and a binomial code ( $2.9 \times 10^{-3}$ ).

Significance
The paper establishes stellar rank as an operationally meaningful resource measure for bosonic QEC, bridging non-Gaussian resource theory with practical state-preparation constraints. It demonstrates that the "best" code is not necessarily the one with the best ideal error-correction properties, but rather the one that balances intrinsic code quality against the cost of preparation. The results provide concrete resource thresholds for achieving error-correction advantages and highlight that noise-adapted optimization can yield superior performance within a fixed non-Gaussian resource budget compared to approximating pre-defined ideal codes. This framework is particularly relevant for experimental platforms where non-Gaussian operations are limited, such as photonic systems.