GIF
Wigner evolution: vacuum → cat state with two lobes and fringes. Full two-mode model settles near α² = 4.41 photons in ~1 µs.
Γ_X vs α²: one bit flip every 2.6 s at α = 2.1. Liouvillian eigenvalues match time-domain fits to 10⁻⁸ where both run.
SNR vs P_flip for square, bang-bang, and cos pulses. Resonant cos reaches 0.65% readout error; right: optimized pulse shape.
Weak drive (ε_Z = 0.05 g₂) gives opposite Re⟨b⟩ for |+α⟩ vs |−α⟩. Both signals settle within 1% from 0.968 µs.
Memory overshoots to 6.9 photons at 0.23 µs, then rings down. Buffer too slow for the effective single-mode model.

Alice & Bob Challenge: Von Neumann's Ghosts

DuQuantum 2026 · Standard track Team: Pranav Reddy, Harshit Aggarwal, Halo Kwok, Xuanyu (Philip) Zhu

Try it: Live app https://66-42-119-3.sslip.io/ · Code https://github.com/pkarakala/duquantum-cat-qubit (physics: main, app: integrated)

Elevator pitch

Cat qubits that resist bit flips for seconds but read out in microseconds: we modeled the full two-mode system, extracted error rates via Liouvillian eigenvalues, built a readout pulse that beats square drives by up to 1.7×, and turned it all into a live interactive course, Cat Qubit Academy.

Inspiration

Cat qubits are built around a simple but powerful idea: make one kind of error vanishingly rare while keeping the other manageable. That biased noise means a simple repetition code can replace a full surface code, which is why Alice & Bob's hardware needs far fewer physical qubits.

We wanted to go beyond the textbook picture. The challenge's two-mode model (memory plus a lossy buffer) is slow, leaky and messy in ways a single-mode "effective" model hides. We set out to simulate that full system honestly: stabilize a cat, measure how long it really lives, figure out how to read it out without destroying it, and then make that physics learnable by anyone.

What it does

Section 1: stabilize and characterize

Builds a cat from vacuum in the full memory–buffer model and tracks the Wigner function as it forms
Proves numerical convergence across a 49-point Fock-space grid, using trace distance rather than photon number alone
Identifies the prepared state as a partially decohered even cat and measures parity and coherence decay
Prepares a definite logical state |0_L⟩ = |+α⟩ by displacing, then stabilizing, reaching 99.88% fidelity in 0.41 µs

Section 2: errors and readout

Maps the bit-flip rate Γ_X from α = 0.8 to 2.5. At α = 2.1 there is one flip every 2.6 seconds
Maps the phase-flip rate Γ_Z and shows a 1.3×10⁶ bias over bit flips at α = 2.1
Simulates buffer readout and confirms the contrast formula Re⟨b⟩ = ∓ε_Z/(2αg₂)
Designs a better readout pulse (a resonant cosine drive) that cuts readout error from 1.12% to 0.65%, beating square pulses by up to 1.7× in SNR per flip (1.26–1.71× across settings)

Everything is reproducible with ./run_all.sh, and every headline number is saved as JSON.

Cat Qubit Academy (live: https://66-42-119-3.sslip.io/)

"Code.org for quantum." Eight prediction-gated levels take a beginner from a photon in a box to designing this exact readout. Level 8 is Task 2.4 as a game: shape a pulse and beat the square drive. Every level runs predict → play → check, with a "show the code" view of the real dynamiqs model. Simple levels simulate in the browser (validated against dynamiqs); the full two-mode physics runs on our server.

Vultr: hosts the live dynamiqs physics API, and ran our 189+ cloud sweeps
Gemini: the tutor "Schrö". It must run our simulator (function calling) before quoting a number, and a guard strips any number that didn't come from a run
ElevenLabs: Schrö's voice agent ("Talk"), which receives the learner's level and failed checks as dynamic variables
Backboard: long-term tutor memory of each learner's misconceptions across levels
Tiger Data: every learner run is logged to a TimescaleDB hypertable, and a continuous aggregate powers the live class chart and leaderboard
Solana: a soulbound course credential plus an on-chain hash of our verified results (devnet demo mode)
Cursor + Grok (SpaceXSI): built with parallel Cursor agent lanes and a Grok bot

How we built it

We built a modular Python codebase on dynamiqs (open-system quantum simulation), with a shared model in src/ and task scripts in tasks/ and research/s2/.

Two methods, always cross-checked. At large α, brute-force time evolution can't reach the bit flips, since a single flip takes seconds. So we also solved the Liouvillian eigenvalue problem, using parity symmetry to split it into even and odd blocks, and got Γ_X at α = 2.1 in under a minute. Where both methods reach, they agree to 10⁻⁸.

Cloud-scale sweeps. The large parameter grids (189+ jobs for Section 2 and the 49-point truncation grid for Section 1) ran on Vultr via cloud/vultr_batch.py, with results archived under results/.

Better readout. We derived the RWA resonant terms and ran a full ATS circuit simulation, retuning the pump by −23 MHz to restore pairing. We then used JAX autodiff through dynamiqs to optimize pulse shapes for SNR − μ·P_flip.

Product layer. A Vite + TypeScript site with an in-browser solver, a FastAPI + dynamiqs server on Vultr, Gemini, ElevenLabs and Backboard for the tutor, Tiger Data for analytics, and Solana for credentials.

AI as a force multiplier, not a crutch.

Claude Code: planning, most of src/ and tasks/, and the write-ups
Codex: Section 1 validation, convergence analysis, brute-force Task 2 runs
Gemini: independent physics review via tools/ai_review.py
Cursor + Grok: the product layer, built in parallel agent lanes

No AI output went in unchecked. Every number has a hand prediction, a second method, or a convergence test behind it.

Challenges we ran into

Timescales that fight each other. At α = 2.1 a bit flip takes about 2.6 s, but stabilization finishes in about 1 µs and readout rings on a timescale of about 0.3 µs. No single simulation strategy covers all three, so we matched the method to the physics.

The buffer is not instant. The effective single-mode model assumes κ_b ≫ g₂, but the supplied parameters give ε_d/κ_b = 1.29. The memory overshoots to 6.9 photons before settling, with visible ringdown. That transient made truncation and convergence much harder than the steady state alone would suggest.

Convergence is subtle. Photon number can look converged while the coherences are not. We built a trace-distance metric over a 36-pair cutoff grid, and found that capturing the inflation transient needs larger Fock cutoffs in both modes than the steady state does.

Readout is a trade-off. Signal (SNR) and back-action (P_flip) both scale as ε_Z², so harder driving buys nothing at fixed cat size: only the pulse shape helps.

Infrastructure hiccups. Our first Vultr batch was mis-sized and 61 jobs failed, so we re-ran them with corrected job lists. We also caught numerical noise (about 10⁻⁴) in the truncation monitors, caused by default solver tolerances, which could have masked real truncation problems.

Accomplishments that we're proud of

Full challenge coverage: Section 1 (stabilize, converge, prepare) and Section 2 (bit flips, phase flips, readout, better readout), with documented methods and figures
Sub-1% readout error: 0.65% with a resonant cosine pulse at α = 2.1, explained by the buffer acting as a damped oscillator at 2g₂α
1.3×10⁶ error bias: quantified, with the bit-flip rate explained by two escape routes (direct photon loss, and a round trip out of and back into the code space)
Rigorous numerics: a 49-point truncation grid, independent QuTiP cross-checks, and Liouvillian vs time-domain agreement to 10⁻⁸
Logical-state preparation: displacing then stabilizing reaches over 99% fidelity with ±35° phase tolerance, against ±2.7° without stabilization
A live learning product: Cat Qubit Academy, deployed on Vultr with seven sponsor integrations
Fully reproducible: ./run_all.sh regenerates every figure and JSON result

What we learned

The effective model lies (a little). The single-mode picture gets steady-state occupation right, but misses the inflation overshoot, the ringdown, and the slower logical-state preparation. For anything transient (readout, initialization, pulses), the full two-mode model matters.

Eigenvalues beat waiting. When observables decay over seconds, Liouvillian spectral methods aren't a shortcut; they're the only practical path. Symmetry (even/odd parity blocks) makes the problem tractable.

Resonance is the readout insight. The buffer and memory form an underdamped oscillator. Driving at 2g₂α rings the buffer up, amplifying the signal without a proportional rise in back-action. Both the SVD-optimal and the gradient-optimized pulses rediscovered this shape.

AI accelerates, humans verify. AI tools wrote much of our code and prose, but the physics only held because we checked every claim against an analytic result, a second solver, or a convergence sweep.

Cat qubits are Von Neumann's ghosts made real. The Wigner fringes, the parity decay and the million-to-one error bias are measurable signatures of a qubit engineered to haunt one error channel while exorcising the other.

What's next

Circuit-level readout with loss: extend the ATS simulation beyond 150 ns to include κ_a and κ_b, and compare against the Lindblad model
Higher-α bit-flip rates: push Γ_X past α = 2.5 with adaptive truncation and better shift-invert tuning (it currently diverges around α = 2.6)
Closed-loop pulse optimization: feed measured SNR and P_flip back into the JAX optimizer for hardware-calibrated pulses
Error-correction layer: feed our Γ_X(α) and Γ_Z(α) into a biased-noise decoder (a cat-qubit repetition code) to get logical error rates
Academy: real (non-demo) Solana credentials, more levels (gates, repetition codes), and classroom dashboards

Built with

python · dynamiqs · jax · qutip · scipy · fastapi · vite · typescript · vultr · gemini · elevenlabs · backboard · tigerdata · solana · cursor · grok · claude · codex

Sponsor tracks: why each tool, and how it made the project better

We planned the sponsor stack before writing code, around one rule: every tool had to do a job the physics or the learner actually needed, with nothing bolted on. We wrote a shared interface contract and let parallel agent lanes build each integration against it. That's how a 4-person team shipped a research pipeline and a live product in 24 hours.

🟦 Vultr: the physics engine in the cloud

Why: our simulations need double precision on CPU, and JAX can't run in a browser, so a real server was unavoidable.
How it helped:
- It ran 189+ parameter-sweep jobs for Section 2 and the 49-point convergence grid. That was hours of compute we couldn't fit on laptops overnight.
- It now hosts the live dynamiqs API behind HTTPS (https://66-42-119-3.sslip.io/), so every learner runs real Alice & Bob physics.
Why it's the best use: the same cloud box powers both the research and the product, so the numbers learners see come from the same engine as our results.

✨ Gemini: a tutor that has to run the experiment before it answers

Why: AI tutors that guess are dangerous in physics, and the challenge itself warns about LLM mistakes such as a missing 2π or a wrong sign.
How it helped:
- "Schrö" uses function calling to run our simulator, look up verified records, and check answers.
- A number guard strips any number that didn't come from a tool result.
- It gives Socratic hints (predict, then where to look, then a contrasting case, then one worked step) rather than handing out answers.
- Separately, Gemini served as an independent physics reviewer of our code via tools/ai_review.py, and its review caught a coherence-normalization issue.
Why it's the best use: it turns an LLM into a careful lab partner, grounded in real simulations, which is exactly the AI-use standard the challenge asks for.

🔊 ElevenLabs: Schrö gets a voice

Why: voice makes the course accessible and makes "ask the cat" feel natural, which keeps beginners engaged.
How it helped:
- An ElevenAgents voice agent ("Talk") knows the learner's level, their failed checks, and their Backboard memory recap, all passed as dynamic variables.
- Narrated concept cards.
Why it's the best use: voice is tied to the learning state, not a generic chatbot, so each learner gets a personal tutor out loud.

🧠 Backboard: memory across the whole course

Why: good tutors remember what you got wrong.
How it helped: each learner gets a persistent thread. Wrong predictions are stored as misconception tags (for example "losing a photon causes a bit flip"), and Schrö opens later levels with a targeted nudge.
Why it's the best use: we kept the core tutor's Gemini calls direct and used Backboard for exactly what it's best at, stateful memory, so each sponsor does its specialty.

🐯 Tiger Data: a live laboratory notebook for the whole class

Why: learner experiments are naturally time series.
How it helped:
- Every simulation run goes into a TimescaleDB hypertable.
- A continuous aggregate powers a live chart of "what cat size is the room choosing", plus the Level 8 leaderboard. The server recomputes scores, so they can't be faked.
Why it's the best use: this is the exact Timescale pattern (hypertables plus real-time continuous aggregates) applied to a real classroom dashboard.

◎ Solana: verifiable learning and verifiable science

Why: our project's core value is that every number is traceable. Solana extends that provenance to a public, tamper-evident record.
How it helped:
- A soulbound (non-transferable) Metaplex Core credential for finishing the course.
- An on-chain hash of our verified results file, so anyone can check the published numbers weren't changed.
- Shown in devnet demo mode: no real funds, built behind the production interface.
Why it's the best use: it's not a token gimmick. It's provenance for science and for learning.

🚀 Cursor + Grok (SpaceXSI): how we built it so fast

Why: 24 hours, four people, two products.
How it helped:
- Cursor agent lanes built the product layer in parallel (server, solver, levels, blocks, tutor, data, chain), each in its own worktree, with review gates before every merge.
- A Grok bot helped automate QA across the lessons.
Why it's the best use: this parallel-agent workflow is what made a research submission plus a deployed app possible in one weekend.

⚛️ Alice & Bob: the heart of it

dynamiqs (Alice & Bob's open-source simulator) is the engine behind every number in the research and in the Academy. The Academy teaches their cat qubit, end to end.

How we planned it

Research first: we verified every sponsor's current API, credits and limits before building.
One contract: a frozen interface spec, so the integrations plugged in without collisions.
Parallel lanes with review gates: a spec review, then a physics review, before every merge.
Graceful fallbacks: every network feature degrades to an offline mode, so the demo can't hang.
Security: keys stay server-side only, and a full secret audit across every branch came back clean.