Schrödinger Cat Codes: Correcting Single Photon Loss

Hello! Welcome to our next lesson on recent advances in quantum error correction.

In our last session, we built the foundational language for continuous-variable (CV) systems. We introduced harmonic oscillator operators, key states like Fock and coherent states, and the Wigner function as a powerful tool for visualizing them in phase space. We even caught a glimpse of a cat state's Wigner function, noting its two distinct "blobs" and the characteristic interference fringes between them.

Today, we'll move from that visual intuition to a rigorous analysis. Our focus is on this lesson's learning outcome: Analyze the structure of Schrödinger cat codes and derive their mechanism for correcting single photon loss errors. We will define these "cat states" mathematically, construct a logical qubit with them, and then derive precisely how this encoding protects against the most common source of error in many bosonic systems.

This type of code, built from the states of a harmonic oscillator, is known as a bosonic code. They are an area of intense research because they can be more "hardware-efficient" than conventional qubit-based codes, packing a protected logical qubit into a single physical system, like a microwave cavity.

1. The Structure of Cat States

The name "Schrödinger cat state" is an analogy: just as Schrödinger's hypothetical cat was in a superposition of two macroscopically distinct states (alive and dead), these quantum states are superpositions of coherent states with macroscopically distinct phases.

Let's begin by formally defining the building blocks of these codes.

Two-Component Cat States

As the paper details, the simplest cat states are the two-component even and odd states, defined as:

where ${\mathcal{N}}_{\pm }$ are normalization constants and $\alpha$ is a real number representing the amplitude of the coherent states. For large $\alpha$, the constituent states $|\alpha ⟩$ and $|-\alpha ⟩$ are nearly orthogonal.

The crucial property of these states is their photon number parity. Recall that a coherent state $|\alpha ⟩$ is a superposition of all Fock states: $|\alpha ⟩=e^{-|\alpha {|}^2/2}{\sum }_{n=0}^{\infty }\frac{{\alpha }^n}{\sqrt{n!}}|n⟩$. By expanding $|\alpha ⟩$ and $|-\alpha ⟩$, you can verify that $|{\text{cat}}_e⟩$ contains only even Fock state components ($|0⟩,|2⟩,|4⟩,\dots$) and $|{\text{cat}}_o⟩$ contains only odd components ($|1⟩,|3⟩,|5⟩,\dots$). They are eigenstates of the parity operator $\hat{\Pi }=e^{i\pi {\hat{a}}^{†}\hat{a}}$ with eigenvalues +1 and -1, respectively. This property is the key to detecting errors.

Four-Component Cat Codes

To encode a logical qubit, we need two orthogonal states to serve as our logical $|0_L⟩$ and $|1_L⟩$. While we could use $|{\text{cat}}_e⟩$ and $|{\text{cat}}_o⟩$, they live in different parity subspaces. A more robust construction places the logical basis states within the same parity subspace. This leads to the four-component cat code.

The standard choice for the logical basis, as defined in Eq. (2) of the paper, is:

Notice that both $|0_L⟩$ and $|1_L⟩$ are even-parity states. They are constructed from coherent states pointing along the real and imaginary axes in phase space. The space spanned by these two states is the codespace. Any state in this codespace, $|{\psi }_L⟩=c_0|0_L⟩+c_1|1_L⟩$, has even photon number parity.

An error will be detectable if it kicks the state out of this codespace into an orthogonal subspace, particularly one with a different parity.

2. Deriving the Error Correction Mechanism

The dominant error process in many physical implementations of bosonic codes (like superconducting microwave cavities) is the loss of a single photon. In our formalism, this corresponds to the action of the annihilation operator, $\hat{a}$. Let's derive how this error affects an encoded logical state.

The key insight, as we saw in the last lesson, is that coherent states are eigenstates of the annihilation operator: $\hat{a}|\beta ⟩=\beta |\beta ⟩$.

Let's apply $\hat{a}$ to our logical basis states:

1. Action on $|0_L⟩$:

   $$\hat{a}|0_L⟩={\mathcal{N}}_{+}\hat{a}(|\alpha ⟩+|-\alpha ⟩)={\mathcal{N}}_{+}(\alpha |\alpha ⟩-\alpha |-\alpha ⟩)=\alpha {\mathcal{N}}_{+}(|\alpha ⟩-|-\alpha ⟩)$$

   The resulting state, $|\alpha ⟩-|-\alpha ⟩$, is proportional to an odd-parity cat state. Let's call it $|0_L^{\prime }⟩$. So, $\hat{a}|0_L⟩\propto |0_L^{\prime }⟩$.

2. Action on $|1_L⟩$:

   $$\hat{a}|1_L⟩={\mathcal{N}}_{+}\hat{a}(|i\alpha ⟩+|-i\alpha ⟩)={\mathcal{N}}_{+}(i\alpha |i\alpha ⟩-i\alpha |-i\alpha ⟩)=i\alpha {\mathcal{N}}_{+}(|i\alpha ⟩-|-i\alpha ⟩)$$

   The resulting state, $|i\alpha ⟩-|-i\alpha ⟩$, is also an odd-parity cat state. Let's call it $|1_L^{\prime }⟩$. So, $\hat{a}|1_L⟩\propto i|1_L^{\prime }⟩$.

The states $|0_L^{\prime }⟩$ and $|1_L^{\prime }⟩$ form a basis for an orthogonal, odd-parity subspace, which we can call the error space.

Now, consider an arbitrary logical state $|{\psi }_L⟩=c_0|0_L⟩+c_1|1_L⟩$. The effect of a single photon loss is:

This result is profound.

1. Error Detection: The initial state was in the even-parity codespace. After the error, it is in the odd-parity error space. A measurement of the photon number parity will yield 'odd', unambiguously signaling that a single-photon-loss error has occurred.
2. Error Correction: The error did not randomly scramble the logical information ($c_0,c_1$). Instead, it performed a specific, known transformation: $c_1\to i{c}_1$. This corresponds to a logical gate operation, specifically a phase gate $S=\left(\begin{array}{cc}1& 0\\ 0& i\end{array}\right)$. To correct the error, we simply need to apply the inverse gate, $S^{†}$, to the logical state.

This entire process is elegantly summarized in a landmark experimental paper.

As the paper and figure illustrate, the loss of a single photon (application of $\hat{a}$) causes the encoded qubit to "jump" from the even-parity codespace to the odd-parity error space, while simultaneously rotating the logical state by $\pi /2$ around the logical Z-axis. By continuously monitoring the parity, we can track these jumps and apply corrections to undo the rotations, thus protecting the quantum information.

Conclusion

In this lesson, we have dissected the structure and function of the Schrödinger cat code, a prime example of a hardware-efficient bosonic code.

Key Takeaways:

• Schrödinger cat codes encode a qubit in superpositions of coherent states, such as $|\alpha ⟩\pm |-\alpha ⟩$.
• The four-component cat code uses an even-parity subspace as its codespace, allowing it to detect errors that change the parity.
• Single photon loss, modeled by the annihilation operator $\hat{a}$, is the dominant error in many systems. This error flips the parity of a cat state.
• This parity flip serves as a detectable error syndrome. Crucially, the effect of the error on the encoded information is not random but is a predictable unitary rotation (a logical phase gate), which can be corrected.
• The code is tailored to correct single photon loss and is not inherently robust against higher-order loss events.

Preview of the next lesson:
The cat code is designed to combat photon loss errors, which are "subtractive" in nature. Next, we will explore another major bosonic code, the Gottesman-Kitaev-Preskill (GKP) code. We will see that GKP codes have a completely different structure in phase space, resembling a grid, which makes them naturally suited to correcting a different class of "additive" errors: small random displacements in position and momentum.