Inspiration
Quantum computers ultimately produce ordinary measurements—zeros and ones—but the probabilities behind those measurements come from amplitudes that can reinforce or cancel through interference.
The Duke Quantum Hackathon challenged us to estimate out-of-time-order correlators, or OTOCs, for increasingly large quantum circuits. These measurements are used to study quantum scrambling: how a small, local disturbance spreads through an entangled system.
The experiment works like an echo. A system evolves forward, receives a deliberate disturbance called a butterfly operation, and then evolves backward. If the disturbance has spread, reversing the evolution will not perfectly restore the starting state.
For each circuit, we needed to estimate the Z expectation of a designated qubit:
$$ \langle Z_q\rangle=P(q=0)-P(q=1) $$
We wanted to do more than produce a list of numbers. We wanted to understand why the problem becomes difficult, compare classical simulation strategies, document the approaches that failed, and explain the entire journey to people who are new to quantum computing.
That became Chasing the Echo: a classical simulation project and an interactive field report about our attempt to predict quantum echoes.
What it does
Chasing the Echo combines a quantum-simulation workflow with a long-form educational website.
The simulation workflow processes seven circuit families ranging from 4 to 38 qubits. It selects different methods depending on the size and structure of each circuit:
- Exact statevector simulation for circuits small enough to retain every amplitude
- Cloud-based exact simulation for larger circuits within BlueQubit's exact backend limit
- Matrix product state simulation for compressed representations of larger states
- Pauli-path simulation for propagating the requested observable instead of the complete state
- Structural models for estimating how a disturbance spreads through the circuit geometry
For the most difficult problem, G4, the workflow tries increasingly fine Pauli-path truncation cutoffs. If a cutoff would exceed the backend's memory limit, it automatically falls back to the next supported setting. Every result is saved with its circuit ID, simulator settings, job ID, status, and cost.
The accompanying website presents the work as a guided story. It explains:
- Qubits, amplitudes, phase, and measurement
- Constructive and destructive interference
- Entanglement and quantum gates
- Quantum echoes and butterfly operations
- Exact versus approximate simulation
- Statevector, MPS, and Pauli-path methods
- Approaches that worked and approaches that failed
- The results we achieved and their limitations
- Papers, tutorials, and source material used during the project
The deployed website contains no per-circuit answer CSV files. It reports only aggregate results and the scientific process behind them.
How we built it
We began with the smallest open circuits so that we could verify our interpretation of the task before attempting the hidden problems.
For S1 and S2, we downloaded the supplied QASM circuits and simulated them locally with Qiskit Statevector. We retained every amplitude, applied every gate, and calculated each requested expectation from the final probabilities. We independently checked the results with Qiskit Aer and verified that the state remained normalized.
For S3 and G1, the statevectors were too large for our small local environment. A 30-qubit state contains more than one billion amplitudes. We therefore used BlueQubit's cloud CPU statevector simulator and requested the Z expectations directly.
G2, G3, and G4 exceeded the available exact statevector limit. We then explored approximate and structural methods.
For G2, our strongest saved result used a simplified model of information spreading based on distance from the butterfly qubit.
For G3 and G4, we investigated Pauli-path simulation. Instead of storing the full state, this method propagates the observable backward through the circuit as a collection of Pauli terms. Terms below a chosen truncation cutoff are discarded to control memory use.
We tested progressively smaller cutoffs:
0.0010.00010.000020.0000150.00001250.00001where the backend permitted it
We also tested different circuit transpilation levels because mathematically equivalent compilations can accumulate different approximation errors.
To manage the experiments, we created Python controllers that:
- Saved every job immediately
- Resumed interrupted sweeps
- Prevented duplicate jobs
- Enforced the one-GPU-job platform limit
- Checked the account balance before paid work
- Preserved a minimum credit reserve
- Recorded actual charges instead of estimates
- Used larger cutoffs only after memory validation rejected tighter settings
- Built complete result vectors from new simulations and verified fallbacks
- Avoided duplicate submissions
- Stopped new work before the competition deadline
We used Codex to help inspect the inherited project, write and debug the controllers, monitor cloud jobs, compare simulator behavior, research relevant papers, organize the findings, secure the repository, and turn the work into an educational website.
The website itself uses semantic HTML, responsive CSS, and lightweight JavaScript. It is packaged in a small Docker container served by Nginx and prepared for deployment on Vultr.
Challenges we ran into
The main challenge was exponential growth.
A general 38-qubit state contains:
$$ 2^{38}=274,877,906,944 $$
complex amplitudes. Storing that state alone would require multiple terabytes of memory, before accounting for working buffers and gate operations. The exact statevector backends available to us supported at most 34 qubits, so G4 could not be calculated directly.
Matrix product states offered compression, but the grid-based echo circuits generated substantial entanglement. Affordable bond dimensions lost important correlations, while larger bond dimensions quickly became too expensive or were rejected by the platform.
Pauli-path simulation introduced a different challenge. Its cutoff does not simply round the final answer. It discards small mathematical contributions throughout the calculation. Those contributions can still matter when larger paths nearly cancel through interference.
We also discovered that accuracy was not monotonic. A smaller cutoff did not guarantee that every estimate moved smoothly toward the exact answer. Some values changed significantly or even changed sign. We therefore avoided claiming convergence solely because a simulation used a finer cutoff.
Operational limits also shaped our solution. The hackathon backend allowed only one active GPU job at a time. An attempted parallel sweep was rejected, so we replaced it with a resumable sequential controller.
Finally, we learned how important provenance is. One strong saved result did not have enough information to confidently identify its precise producing configuration. After that, we treated simulator settings and job metadata as part of every result rather than optional notes.
Accomplishments that we're proud of
We earned full scores on all four problems that we could simulate exactly:
- S1: 100/100
- S2: 100/100
- S3: 100/100
- G1: 300/300
Our approximate and structural methods also produced:
- G2: 534/600
- G3: 795/800
- G4: a best verified snapshot of 197/1000
For G4, we improved the score from only 1 point to 197 by moving from early structural guesses to increasingly fine GPU Pauli-path simulations.
We completed several full 38-circuit sweeps while maintaining job provenance and respecting the computation budget. The final workflow handled memory rejections, temporary failures, checkpointing, duplicate prevention, submission limits, and credit reserves automatically.
We are also proud that the final project is more than a scoreboard. The Chasing the Echo website turns a difficult quantum-simulation experiment into a story that a beginner can follow.
The public-facing site does not expose the private per-circuit answer files. It focuses on the science, engineering decisions, limitations, and lessons from the project.
What we learned
We learned that simulation does not automatically mean approximation. A statevector simulation can calculate a circuit without intentionally discarding information, while methods such as MPS and Pauli paths make controlled compromises to handle larger systems.
We learned to choose a simulator based on more than qubit count. The correct method also depends on:
- The requested observable
- Circuit depth
- Connectivity
- Entanglement structure
- Available memory
- Whether exact reference values exist
- The type of approximation error we can tolerate
We learned that exact sample circuits are essential calibration tools. S3 allowed us to compare approximate results against known answers before applying the same methods to hidden circuits. However, success on one circuit family did not guarantee accuracy on another.
We learned that correlation and numerical accuracy are different. The competition rewarded squared correlation, so a result could follow the correct pattern without matching every exact magnitude.
We learned that convergence requires evidence. A tighter cutoff is useful, but it is not proof by itself. Confidence should come from stabilization across settings, agreement between independent methods, or comparison against exact reference values.
We also learned that computational research depends heavily on engineering. Checkpoints, job identifiers, validation rules, budget checks, resumable workers, and honest method notes were as important as the simulation algorithms themselves.
Most importantly, we learned that failed approaches are useful results. Low-bond MPS, structural guesses, rejected cutoffs, and alternative transpilation levels each showed us something about where the problem's difficulty came from.
What's next for Chasing the Echo
Our immediate next step is deploying the educational walkthrough on Vultr with a custom domain and HTTPS.
We also plan to:
- Add interactive demonstrations of amplitudes, phase, and interference
- Create an animation of forward evolution, the butterfly disturbance, and reverse evolution
- Visualize how Pauli terms grow as the cutoff decreases
- Add diagrams comparing statevector, MPS, and Pauli-path representations
- Convert saved experiments into reproducible manifests
- Improve the provenance record for the strongest G3 result
- Explore structure-aware operator methods for future echo circuits
- Add automated deployment from GitHub to Vultr
- Publish a sanitized source repository whose history has never contained private answer files
- Expand the site into a beginner-friendly learning path for quantum simulation
Chasing the Echo began as an attempt to estimate a difficult set of quantum observables. It became a record of how exact computation gives way to approximation—and how much can be learned from the boundary between them.
Log in or sign up for Devpost to join the conversation.