⚛️ quantum physics

Compilation Pipeline for Predicting Algorithmic Break-Even in an Early-Fault-Tolerant Surface Code Architecture

This paper presents a compilation pipeline for mapping logical algorithms to physical surface code circuits using lattice surgery, demonstrating through classical simulation that algorithmic break-even for QAOA and QPE can be achieved with near-term hardware containing approximately 1,700 to 2,500 physical qubits at error rates between $5\times 10^{-4}$ and $10^{-3}$ .

Original authors: Tianyi Hao, Joseph Sullivan, Sivaprasad Omanakuttan, Michael A. Perlin, Ruslan Shaydulin

Published 2026-11-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Tianyi Hao, Joseph Sullivan, Sivaprasad Omanakuttan, Michael A. Perlin, Ruslan Shaydulin

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that are currently impossible for even the most powerful supercomputers, from designing new medicines to optimizing complex global systems. However, the delicate particles that carry information in these machines are incredibly fragile. A tiny vibration or a stray electromagnetic wave can corrupt the data, causing the calculation to fail. To overcome this, scientists use a method called quantum error correction, which spreads information across many physical particles so that if one fails, the others can step in to save the day. One of the most promising ways to do this is using a grid-like structure known as the surface code, where qubits are arranged in a two-dimensional pattern and constantly checked against their neighbors. For years, researchers have known that if they could build a machine large enough with high enough quality, these error-correcting codes would eventually make the computer more reliable than the raw hardware itself. This tipping point, where the correction system actually improves the result rather than just adding overhead, is known as algorithmic break-even.

Until now, figuring out exactly when this break-even would happen has been difficult because the tools used to design these computers were built for a distant future where space and resources were unlimited. These older designs assumed there would be vast, separate factories dedicated solely to creating the special states needed for calculations, ignoring the reality that early machines will be cramped and must share every available inch. A new study by researchers at JPMorgan Chase addresses this gap by creating a complete, end-to-end software pipeline that translates a quantum algorithm directly into the physical instructions needed for a realistic, early-stage machine. Instead of assuming unlimited space, their system treats the computer as a tight, shared workspace where data, error-checking, and special state preparation must all fit together efficiently.

The researchers built this pipeline to compile two specific types of quantum algorithms: one used for estimating values in complex simulations and another designed to solve difficult optimization puzzles. They fed these algorithms into their system, which then broke them down into the smallest possible steps required by the surface code. A key innovation in their work was how they handled the "magic states"—special, high-quality quantum states required to perform certain calculations that cannot be done directly. Previous methods assumed these states were made in large, separate factories and then shipped over to where they were needed, a process that wasted time and space. The new pipeline uses a technique called cultivation, where these states are grown and injected directly into the calculation area as needed, eliminating the need for long-distance shipping and saving valuable space.

To see if this approach actually worked, the team ran massive classical simulations of the physical circuits their pipeline produced. They tested how these circuits would perform under different conditions, specifically varying the number of physical qubits and the rate at which errors occurred in the hardware. The simulations revealed that for a five-qubit version of the optimization algorithm, the system reaches the break-even point with 2,517 physical qubits if the hardware error rate is one in a thousand. If the hardware is slightly better, with an error rate of five in ten thousand, the break-even point drops to just 1,737 physical qubits. These numbers represent the exact moment where the error-corrected version of the algorithm performs better than running the same algorithm on a machine without any error correction at all.

The study also looked at the phase estimation algorithm, a common tool used in many quantum applications, and found similar results. In these simulations, the error-corrected version of the algorithm outperformed the uncorrected version once the machine reached a specific size and quality threshold. The researchers found that by carefully managing the trade-offs between the number of qubits, the code distance (which determines how many errors the system can catch), and the quality of the hardware, they could pinpoint the exact requirements for success. Their work demonstrates that achieving a useful, error-corrected quantum computer does not require waiting for a machine with millions of qubits; instead, it is possible with a few thousand, provided the software is designed to work within the strict physical limits of early machines.

This research challenges the long-held assumption that we must wait for a future era of abundant resources before quantum error correction becomes practical. By simulating the entire process from the high-level algorithm down to the physical movements of individual qubits, the team showed that the path to a working, fault-tolerant quantum computer is shorter than previously thought. They did not build a physical machine in this study; instead, they used advanced computer simulations to model how a real machine would behave. The results suggest that with the right compilation strategies, the next generation of quantum devices, which are currently being built with hundreds of qubits, could soon be scaled up to the thousands needed to cross the threshold into useful, error-corrected computation. The work provides a clear roadmap for engineers and scientists, showing exactly what hardware specifications are needed to make the first truly reliable quantum algorithms a reality.

Technical Summary: Compilation Pipeline for Predicting Algorithmic Break-Even in Early-Fault-Tolerant Surface Code Architectures

Problem Statement

Recent experimental progress in realizing surface code on hardware has advanced the prospects for fault-tolerant quantum computation (FTQC), particularly with demonstrations of break-even logical memory. However, there is a critical gap in compilation workflows capable of targeting the next generation of devices with thousands of physical qubits. Existing compilation techniques are often ill-suited for the "early-fault-tolerant" (EFT) era because they assume abundant physical resources, fixed logical qubit layouts, and dedicated magic state factories. In the EFT regime, physical space is a premium; resources must be shared between data qubits, ancillas, and magic state production, and dedicated factory regions are unaffordable. Furthermore, traditional resource estimation often stops at the lattice surgery layer or relies on simplified volume counting, failing to provide accurate physical-level resource estimates and fidelity predictions required to determine when quantum error correction (QEC) actually improves algorithm performance (algorithmic break-even).

Methodology

The authors present a comprehensive, end-to-end compilation pipeline that translates logical quantum algorithms into physical circuits implementing lattice surgery on a 2D rotated surface code. The pipeline integrates and improves upon several open-source tools and recent innovations to address specific subproblems in the compilation chain:

Rotation Merging and Synthesis: Instead of the standard $R_Z$ -based workflow, the pipeline adopts a $U_3$ -based workflow. Continuous single-qubit rotations are merged into $U_3$ gates before being synthesized into Clifford+ $T$ sequences. This approach, utilizing the trasyn tool, minimizes the $T$ -gate count for a given synthesis error.
Execution-Error-Aware Synthesis: The pipeline moves beyond top-down error budgeting. It employs a bottom-up approach where the synthesis process considers the total execution overhead, including memory errors from idling logical qubits. By sampling gate sequences based on overall process fidelity (incorporating error channels for cultivation, injection, and idling), the compiler minimizes infidelity for each specific physical configuration (code distance $d$ and physical error rate $p$ ).
Magic State Cultivation and Injection: Replacing traditional distillation with dedicated factories, the pipeline utilizes magic state cultivation [26]. This protocol allows for in-place, on-demand magic state preparation on a single surface code patch ( $d \ge 7$ ). The pipeline implements an efficient consecutive injection scheme for $T_X T_Z$ sequences using round-robin access to neighboring qubit patches, eliminating routing overhead and excessive production requirements.
Direct Lattice Surgery Synthesis: The pipeline uses LaSsynth [62] to synthesize lattice surgery operations directly from the logic of Clifford subcircuits, rather than performing gate-by-gate translation. This approach treats data and ancilla qubits flexibly, avoiding fixed layouts and optimizing spacetime volume.
Physical Circuit Generation and Simulation: The pipeline converts lattice surgery operations into full physical circuits using the tqec tool. Crucially, it generates "Clifford proxy" circuits that exclude the magic state cultivation protocols; instead, magic state ( $|T\rangle$ ) inputs are replaced with $Z$ -basis ( $|0\rangle$ ) initializations to enable classical simulation. The authors developed a polynomial-time algorithm to compute correlation surfaces, a necessary step for recovering logical observables that was previously neglected or intractable.
Resource Estimation: The pipeline performs classical simulations of these physical circuits under realistic noise models (SI1000) to estimate logical error rates and infidelity. This allows for a direct comparison between fault-tolerant execution and unencoded execution.

Key Contributions

End-to-End Pipeline: The development of the first physical-level compilation and resource estimation pipeline for surface-code-encoded algorithms that integrates rotation merging, error-aware synthesis, cultivation, and direct lattice surgery synthesis.
Algorithmic Break-Even Prediction: A methodology to identify the specific hardware requirements (number of physical qubits, code distance, and physical error rates) needed to achieve algorithmic break-even, defined as the point where QEC improves algorithm performance over unencoded execution.
Optimized Compilation Strategies: The introduction of $U_3$ -based synthesis and execution-error-aware optimization, which reduce $T$ -gate counts and minimize overall process infidelity compared to previous $R_Z$ -based or fixed-threshold approaches.
In-Place Magic State Access: The verification and integration of magic state cultivation and round-robin injection, which significantly reduces the spatial footprint and eliminates the need for dedicated factory regions and routing overhead.
Correlation Surface Computation: The development of a polynomial algorithm to compute correlation surfaces for large-scale lattice surgery circuits, enabling accurate recovery of logical measurement outcomes in simulations.

Results

The pipeline was applied to two prominent algorithms: Quantum Phase Estimation (QPE) and the Quantum Approximate Optimization Algorithm (QAOA) applied to the 5-bit Low-Autocorrelation Binary Sequences (LABS) problem.

Break-Even Conditions:
- At a physical error rate of $p = 10^{-3}$ , algorithmic break-even is achieved with 2,517 physical qubits (surface code distance $d=11$ ).
- At a physical error rate of $p = 5 \times 10^{-4}$ , break-even is achieved with 1,737 physical qubits (surface code distance $d=9$ ).
Performance Comparison: Simulations of the compiled Clifford proxy circuits demonstrated that for the identified configurations, the infidelity of the fault-tolerant execution is lower than that of the unencoded execution running on the same hardware constraints (2D nearest-neighbor connectivity).
Resource Metrics: The study provided detailed spacetime volumes, code cycles, and $T$ -gate counts for various code distances and error rates (Table 2), showing that the pipeline produces adaptive circuits that minimize error for specific hardware constraints.

Significance

The paper claims that this work identifies concrete conditions for achieving algorithmic break-even with near-term quantum hardware. By moving beyond abstract resource estimates to full physical-level simulation, the authors demonstrate that surface codes with distance $d \ge 9$ are sufficient to run nontrivial algorithms beyond the break-even point. The work challenges the community to demonstrate these specific break-even conditions on near-term hardware. Furthermore, the pipeline paves the way for an end-to-end compiler for early-fault-tolerant surface code architectures, addressing the urgent need for compilation strategies that account for the resource constraints of the EFT era. The authors note that scaling to algorithms with tens of logical qubits will require further optimization of lattice surgery operations (e.g., "peephole" optimizations) and the development of dynamic programs to handle nondeterministic magic state preparation.