Bridge of $Ψ$'s: Quantum Circuit Optimization with Schrödinger Bridges

AI summary

Overview

Research area: Quantum compilation and quantum circuit optimization, combined with generative machine learning (Schrödinger bridge / diffusion models).

Technical level: Advanced. The paper assumes familiarity with quantum circuits, unitaries, the Clifford+T gate set, diffusion models, and transformer architectures.

Scope: The paper introduces BOPS (Bridge of Ψ's), a source-conditioned Schrödinger bridge model with a custom U-shaped diffusion transformer denoiser that learns to map a quantum circuit to an equivalent, lower-cost circuit, and benchmarks it against nine existing optimizers on generated Clifford+T circuits.

What This Paper Is About

Quantum circuit optimization rewrites a circuit into an equivalent one with fewer gates and lower depth, which reduces execution cost and error. Existing tools rely on fixed rewrite libraries, local heuristics, or restricted search spaces, so they cannot generalize across the many interacting objectives a compiler faces. The authors ask whether a generative model can learn this circuit-to-circuit transformation directly from examples, treating optimization as a transport problem from a source circuit distribution to a distribution of equivalent optimized circuits.

Key Contributions

1. Circuit optimization as a conditional Schrödinger bridge. The authors formulate optimization as continuous transport from a source circuit to an optimized equivalent, with no fixed rewrite library and no equivalence-preserving search space imposed at inference time. Because the source circuit is the starting endpoint rather than Gaussian noise, the target unitary is specified compactly and a valid implementation is always available to start from.

2. Exact training pairs from reverse rewrites. Training data is built by drawing small random circuits, reducing them under a rule set, then applying rewrite rules backwards (including nested rewrites) to expand them into harder source circuits. Since every rule is verified in advance as dense unitaries up to global phase, pairs are equivalent by construction, which removes unitary construction and equivalence checking from the training loop.

3. A denoiser adapted to circuit grids. The authors modify U-DiT (Tian et al., 2024) to downsample the time axis only, preserving full qubit resolution, add permutation equivariance through a learned qubit-identity table, and use grouped attention whose cost grows linearly with depth rather than quadratically. This denoiser shortens 88.9% of evaluation circuits, versus 76.2% for plain U-DiT and 40.6% for a U-Net (Table 4).

4. An optimizer that beats all nine baselines. One trained BOPS model outperforms every baseline in gate count and depth reduction and reaches the known target nearly 3× as often as the strongest baseline. Inference uses a fixed number of network evaluations per fixed-grid input rather than size-dependent rewrite or search trajectories, and every reported output is exactly verified.

Main Findings

• Headline result on 8 × 64 circuits. On held-out 8 qubit × 64 depth Clifford+T circuits (n = 2,686), BOPS reduces gate count by 2.46× and depth by 2.45× in geometric mean, versus 2.11× and 2.11× for QUESO, the strongest baseline. BOPS reaches the known target in 77.2% of cases against 26.1% for QUESO (Table 1).

• A measurable headroom gap motivated the work. In the pair construction described in Section 3.2, the strongest of nine baseline optimizers reaches the reduction of the starting optimized circuit for only 40.7% of pairs.

• Generalization to unseen circuit structures. BOPS was not trained on large structured or arithmetic circuits, yet it remains competitive on circuit benchmarks, indicating that learned optimizations transfer beyond the training distribution (Table 5).

• Off-the-shelf diffusion backbones fail. Standard vision/text diffusion backbones perform poorly on this task (Table 4); the gains come from the customized denoiser architecture and training regimen, not from applying an existing model unchanged.

• Scaling works through finetuning. Circuit space grows superexponentially with qubit count (Lemma C.2), but finetuning the 8 × 64 model to 16 × 192 improves 98.4% of larger inputs under windowed inference (Table 3). These rates are lower bounds, because candidates left undecided by the tiered equivalence checker are never accepted.

• Cheap conditioning compared with unitary compilation. A dense 8-qubit unitary has 65,536 complex entries, whereas an 8 × 64 circuit grid has 512 token positions. In prior three-qubit unitary-compilation experiments cited by the authors, 1,024 samples are drawn per target from noise; BOPS starts from a valid source and draws 64.

Methodology in Plain English

The authors encode a circuit as a grid: one row per qubit, one column per timestep, and nine channels per cell representing a gate token (the five one-qubit gates H, S, S†, T, T†, a separate control token and target token for CX, and an empty cell). Decoding assigns each cell the token with highest cosine similarity to its vector; a grid is a valid circuit only if every control has exactly one target in its column and vice versa.

They then use a paired Schrödinger bridge, a diffusion variant that transports between two arbitrary data distributions instead of starting from pure noise. In their setup, the "noisy" endpoint x₁ is the source circuit and the clean endpoint x₀ is its optimized equivalent. Training samples a random time, draws an intermediate state in closed form from the paired endpoints, and trains the denoiser to predict the noise separating it from the optimized circuit, with the source concatenated along the channel axis so the network always knows what it is optimizing.

The denoiser is a U-shaped transformer. Its key departures from image diffusion are: only the time axis is downsampled (because qubit rows are arbitrary labels and pooling them would impose locality the circuit does not have), rotary position embeddings are indexed by absolute circuit timestep so a cropped grid is the prefix of a full one, a learned table injects qubit identity to break unwanted permutation symmetry, and grouped attention keeps attention cost linear in depth.

Generation runs from t = 1 (the source) to t = 0 over 128 of 256 discretized steps, then decodes and verifies candidates. Because the loop runs over the noise schedule rather than over gates or cells, a candidate costs those 128 denoiser evaluations regardless of circuit contents. Sixty-four candidates are drawn per source and ranked by gate count, and the first that passes verification is accepted; a circuit with no accepted candidate is reported at its source length.

Data is generated in reverse: draw a small random circuit (including motifs such as Toffoli decompositions, parity ladders, and phase gadgets, sometimes repeated across qubit groups), reduce it under a large rule set to obtain the target, then expand it with a smaller set of reverse rewrites to obtain the source. The expansion set has 86 rules (36 handwritten and 50 solver-mined), 83 of which shorten circuits; the reduction set has 2,763 rules. Reversing an expansion rule adds 3.9 gates on average versus 1.35 for a mined rule, and added gates may be dispersed up to eight positions past gates on disjoint qubits.

Correctness at inference is checked exactly up to 10 qubits by building both unitaries and computing τ = Tr(U(C)†U(C′))/2^Q, requiring |τ| = 1. At 16 qubits the matrix would have 2^32 entries, so a tiered ZX-diagram pipeline (PyZX rewriting first, then diagram closure) is used, with a 120-second wall-clock limit and undecided pairs never accepted.

Why This Matters

The paper is the first demonstration, by the authors' account, of a generative model matching or outperforming state-of-the-art hand-coded and search-based circuit optimizers on gate count and depth. If the approach holds up, it opens the quantum compilation stack to learned, data-driven optimization along multiple objectives at once, rather than relying on libraries of hand-written rewrites and local heuristics.

Real-world applications:

• Near-term noisy hardware execution: fewer gates and lower depth directly lower error rates and execution cost on noisy processors.
• Fault-tolerant compilation: each logical gate becomes a multi-qubit, multi-cycle gadget, so gate and depth reductions translate into large resource savings.
• Compiler pipeline integration: BOPS reads and writes OpenQASM 2 and is designed to serve as a stage inside existing compilation pipelines such as those built around Qiskit and tket.
• Multi-objective and noise-aware compilation: the authors frame learned optimization as a route toward jointly handling gate count, depth, execution time, connectivity, latency, and heterogeneous fault-tolerance cost models, which current tools handle poorly in combination.

Industry relevance: the work targets the automated compilation layer of the quantum software stack, which vendors of superconducting and other quantum processors must build out to scale applications. It also suggests a way to replace slow search-based optimization passes with a fixed-cost neural inference pass, which matters for compilation latency.

Future Directions

• Scaling beyond 16 qubits. The mechanism demonstrated is finetuning from 8 × 64 to 16 × 192; how far this extends, and whether retraining or architectural changes are needed beyond the 64-row qubit-identity table, remains open.
• Stronger exact equivalence checking. At 16 qubits the pipeline can return undecided within a 120-second budget, so reported rates are lower bounds; the authors sketch GPU-parallel stabilizer-decomposition simulation as a faster conclusive checker.
• Learned multi-objective optimization. Extending the bridge to targets other than gate count and depth, such as two-qubit gate count, connectivity constraints, or device-specific noise and cost models, is not reported and is a natural next step.
• Banking on data generation and architecture. The training distribution is shaped by reverse rewriting with 86 expansion rules and motif choices; how much further the denoiser architecture (time-only downsampling, grouped attention, permutation equivariance) can be improved for longer or structured circuits is left open.

Target Audience

Quantum compilation and computer architecture researchers; machine learning researchers interested in scientific applications of diffusion and Schrödinger bridge models; graduate students and practitioners working on fault-tolerant resource reduction, T-count/T-depth optimization, and circuit synthesis; and quantum software engineers evaluating learned passes as replacements or supplements for rewrite-based compiler stages. Readers need comfort with Clifford+T circuits and unitaries, but the paper's framing of the problem is accessible to ML researchers without a quantum background.

Authors’ abstract

Quantum circuit optimization replaces a circuit with an equivalent one of fewer gates and lower depth, reducing execution cost and error rate. We ask whether a generative model can learn this transformation directly from examples, rather than selecting from a fixed rewrite library or rigid algebraic routines. We present Bridge of $Ψ$'s (BOPS), a generative model based on Schrödinger bridges, using a custom denoiser architecture, that learns a transformation from a source circuit into an equivalent optimized circuit. We train it on data constructed to be hard for existing optimizers, by applying rewrite rules backwards so that each input has a known lower-cost target. On held-out 8 qubits $\times$ 64 depth Clifford+$T$ circuits, BOPS reduces gate count by $2.46\times$ and depth by $2.45\times$ in geometric mean, outperforming all nine baseline optimizers. This constitutes the first generative model bridging quantum circuits and frontier machine learning methods, opening up the quantum compilation stack to learned optimization along multiple axes.