Preparing Schrodinger Cat States in a Microwave Cavity Using a Neural Network

In 1935, Erwin Schrodinger published an idea in a paper exploring the paradoxes of quantum mechanics. This idea is now known as Schrodinger's Cat. Here's how it goes: imagine a cat sealed inside a steel box, along with a tiny piece of radioactive material, a Geiger counter, a vial of poison, and a hammer. The setup is rigged so that if even one atom in that radioactive sample decays, the Geiger counter triggers the hammer to break the vial, releasing the poison and killing the cat. Since it's a small sample of material there's an equal probability that none of the atoms decay, or that at least one of them does. So, what's going to happen? According to quantum mechanics, before you open the box and make an observation, the atoms in the radioactive sample don't have a definite state. They exist in a superposition: a mathematical combination of both possibilities at once. So it's true that an atom of the material has decayed, and it is also true that no atom has decayed. And since the cat's fate depends on that outcome, the cat must be both alive and dead at the same time. It is only when you open the box that the wavefunction "collapses" into one of those two possibilities. The cat goes from being both alive and dead to one of the two.

Schrodinger didn't propose this as a real experiment. He meant it as a thought experiment: a way to expose how absurd quantum mechanics seems when you apply it to everyday objects. But that same logic is what underlies quantum computing today. Superpositions are real. The qubit is based on that concept, and quantum computers depend on keeping such superpositions stable and controllable for as long as possible. Why? So they can encode and manipulate information that's both 0 and 1 at once. So, why did I just tell you that? Because in this paper, the authors are preparing actual Schrodinger-cat states in a superconducting microwave cavity using a neural network.

What?

Okay, bear with me. They're creating a physical version of that "alive-and-dead-at-once" paradox. Not with a cat, but with microwave radiation trapped inside a tiny superconducting cavity (a tiny metal box). Inside this chamber, there's an electromagnetic field that bounces back and forth, forming what physicists call a cavity mode. Normally, that field would just behave like a small, well-defined wave, it could be strong or weak, but it would have one definite amplitude and one definite phase.

What the authors do instead is prepare the field in two opposite conditions at the same time. In one, the wave's electric field points in one direction; in the other, it points in the exact opposite direction. Rather than being forced to choose between those two possibilities, quantum mechanics allows the field to occupy both simultaneously: a "superposition" of two coherent light states. That's what they mean by a Schrodinger-cat state: the electromagnetic field inside the cavity exists in a blend of two macroscopically different configurations at once.

The hard part is getting there. You can't just flip a switch and tell the field to be in two states. The field has to be driven there with microwave pulses sent into the cavity, and a nearby superconducting qubit that's coupled to it. The qubit acts like a controllable intermediary, an artificial atom that can exchange energy with the field and imprint quantum information onto it. "Coupled", in this context means the two systems are linked strongly enough that what happens to one instantly affects the other, allowing the qubit to steer the field's state. (This ability emerges from quantum entanglement, but that's a story for another day.) Anyway, the microwave pulses must have exactly the right shape and timing so that the qubit and the field interact in a way that leaves the field suspended between those two opposite states. And that's where the neural network comes in: it learns how to generate those control pulses automatically, finding the sequence that produces a perfect quantum "cat" faster than traditional optimization methods ever could.

So how did they do it? Well, they built a neural network that takes just two parameters as input: the amplitude of the cat state and the relative phase. The network's job is to figure out how to drive the system (the qubit and the cavity together) so that the final electromagnetic field matches that specific cat state. To do that, it outputs a set of numbers that define the control pulses, split between the signals sent to the cavity and those sent to the qubit.

But, they're not telling the network to generate every voltage value at every microsecond. That would be too large and noisy. Instead, the network works in a compressed space, using something called B-splines. These are smooth, overlapping basis functions that can be combined to form continuous pulse shapes. You can think of them as adjustable curve segments, each one described by a simple polynomial. By changing the weight of each segment, you can bend the overall curve into the exact shape you need. The neural network only has to pick those weights (a few dozen numbers in total) and from that, the full control pulse emerges. The B-splines they use are cubic, meaning each segment is a third-degree polynomial. They have about a dozen of these basis functions spanning the full control window of a couple microseconds. But they exclude the first and last ones to ensure pulses always start and end at zero amplitude. That leaves them with nine basis functions per control field, so nine coefficients to specify how much of each basis function to include.

Each B-spline is a piecewise polynomial that's nonzero only in a limited time window. For their specific configuration, only a handful of B-splines are active at any given moment. And this matters for hardware: quantum controllers can only generate a limited number of simultaneous signals. But with this encoding scheme, you can stay within those limits. Plus, you can preload these basis functions onto a quantum controller and just send it the coefficients. That takes milliseconds instead of the hundreds of milliseconds needed to load thousands of individual voltage points.

Using B-splines also has a hidden benefit: it naturally limits the bandwidth of the control pulses. Finely controlling a system that's evolving rapidly requires pulses with high bandwidth. Fast oscillations, sharp features. By choosing a basis of smooth, bandwidth-limited functions, they indirectly prevent the network from finding solutions that would require enormous intermediate photon numbers in the cavity. Those high-photon-number states would be problematic because they'd cause nonlinear effects, the kind not captured by simple models, and they'd be more susceptible to loss.

The neural network itself is actually fairly straightforward: three hidden layers with a few dozen neurons in each layer. About 5,000 trainable parameters total. Nothing fancy architecturally. The trick is in how they train it.

The network sits at the beginning of a computational pipeline. It outputs those B-spline coefficients, which get converted into actual control pulse shapes. These pulses then drive a physics simulation that evolves the quantum state. Since the entire pipeline is differentiable, meaning you can calculate how changes in the network's outputs affect the final result, they can use standard gradient descent to train the network. Gradients flow backwards through the simulation, through the pulse construction, right back to the network weights. The network learns to map input parameters directly to control sequences.

And importantly: they do include decoherence effects in the simulation but they do it efficiently. Normally you'd need to evolve the full density matrix under a master equation that tracks all the ways quantum coherence can leak away (cavity photon loss, qubit energy decay, qubit dephasing, etc). That's computationally expensive, especially when you're simulating thousands of quantum trajectories during training. Instead, they solve the simpler Schrodinger equation to get the pure state evolution (as if there were no decoherence) then calculate a first-order correction to the fidelity based on how much decoherence you'd expect. For each decay channel, you can write down a formula that captures the leading-order effect without the computational overhead of full density matrix evolution. This approximation works well when decoherence is weak, which it is in this case.

During training, they use a coarser time grid (40 steps) to keep simulations fast and stable. But for testing, they increase the resolution to 200. The maximum photon number they track in the cavity also increases during training, starting smaller and ramping up as the network improves. This gradual increase in simulation fidelity parallels the gradual increase in task difficulty, letting the network learn the basics quickly before tackling the hard cases.

During training they gradually increase the difficulty. Starting with smaller cat-state amplitudes, which are easier to prepare faithfully. Then, as the network improves, they ramp up to larger amplitudes. They also sample the training data non-uniformly. Larger-amplitude cat states are sampled more frequently, because the network needs more practice with the challenging cases. But the phase is sampled uniformly since all phases are roughly equally difficult. This weighted sampling helps the network achieve good performance across the entire parameter space.

One interesting wrinkle: early in training, the network would sometimes get stuck in a local minimum where it learned not to drive the qubit at all. The cavity would end up in a coherent state instead of a cat state , technically a solution with decent fidelity for small amplitudes, but not what they wanted. Their solution was temporarily adding an artificial excitation process during early training simulations, essentially a fake pump that kicks the qubit out of the ground state. This is only during training, not in the actual experiment. Once training got going, they removed this crutch, and the network learned to actively use the qubit to engineer the cat state in the cavity.

So that's how their system works. But how well does it work?

Pretty well actually! For a cat state with modest amplitude, they measured a fidelity above 94%. For a larger cat state with double that amplitude, they got about 91%. And these fidelities include all the messy realities of the actual hardware: imperfect qubit initialization, residual thermal population in the cavity, decoherence during both state preparation and measurement.

This demonstration shows us that neural networks can learn quantum control across entire families of tasks, and generate near-optimal solutions once trained. The fidelities are within about 1% of what's achievable from the type of manual, tedious, painstaking optimization that takes much longer (and is far more expensive) to complete. For real-time feedback, adaptive error correction, or any application requiring rapid pulse generation, this approach could potentially be transformative.

If you want to see the full details of their B-spline construction, the specifics of their error budget analysis, or a rundown of their approach to dealing with two-level system dynamics, you'll definitely want to download the paper. There's a ton of implementation details we couldn't cover here but that definitely matter if you're trying to reproduce or extend this work in your own lab.