O3LS: Optimizing Lattice Surgery via Automatic Layout Searching and Loose Scheduling

Abstract: Toward the large-scale, practical realization of quantum computing, quantum error correction is essential. Among various quantum error-correcting codes, the surface code stands out as a leading candidate, and lattice surgery based on surface codes has emerged as a promising technique for fault-tolerant quantum computation (FTQC). However, implementing quantum algorithms using lattice surgery introduces both resource and time overhead. Existing approaches typically focus on large layout designs, with compiler passes aimed primarily at optimizing time overhead. This often overlooks the trade-off between rotation bottlenecks and movement distance, which leads to inefficient resource utilization and prevents further reduction of the quantum computation failure rate. To address these challenges, we introduce O3LS, a framework for optimizing lattice surgery through automatic layout search and loose scheduling. O3LS achieves an optimal balance by automatically generating squeezed data layouts to reduce space requirements and employing loose scheduling algorithms combined with circuit synthesis techniques to reduce time overhead, thereby effectively minimizing overall logical error rates. Numerical results indicate that O3LS can reduce space overhead by 28.0% over standard layouts and 46.7% over sparse layouts without increasing the number of time steps, leading to suppression of logical error rates by up to 16% relative to larger data layout designs. O3LS can also achieve time overhead reductions of 36.07% and 24.76% in compact and standard data layout designs, respectively. It suppresses logical error rates by up to an order of magnitude compared to prior compilers that focus primarily on maximizing parallelism.

• The paper introduces a modular compiler framework (O3LS) that integrates automated layout search, Y-synthesis, loose scheduling, and edge-aware mapping to optimize lattice surgery for fault-tolerant quantum computation.
• It achieves significant resource reductions with up to 46.7% area savings, 36.07% improvements in time steps, and reductions in logical error rates by up to 93.95% in specific benchmarks.
• Comprehensive evaluations on diverse quantum circuits confirm competitive compilation times and near-ground-truth optimality under realistic surface-code parameters.

O3LS: Automated Optimization of Lattice Surgery Layouts and Scheduling

Introduction

This paper introduces O3LS, a compiler framework targeting optimization of lattice surgery for surface-code-based fault-tolerant quantum computation (FTQC). O3LS addresses central bottlenecks impeding efficient lattice surgery—namely, the tension between time overhead (circuit execution depth) and spatial footprint (qubit count), as well as inadequacies in prior compiler routines that employ rigid scheduling and unguided layout assignment. The framework consists of four modules: automatic data layout search, advanced Pauli operator synthesis (with emphasis on Y-operator cancellation), loose scheduling strategies, and edge-aware initial mapping. Comprehensive numerical results demonstrate significant reductions in logical error rates (LER), compilation time, and qubit resource utilization compared to state-of-the-art compilers.

Lattice Surgery Compilation: Motivation and Background

Surface codes, with high error thresholds and planar architectures, are the predominant platform for scalable FTQC. Lattice surgery is a universal gate protocol that merges and splits code patches, suitable for 2D qubit arrays found in superconducting and trapped-ion devices. However, space-time resource overhead remains a critical barrier—physical qubits necessary per logical operation are vast, exacerbated by circuit depth increases induced by suboptimal layout and scheduling.

While existing quantum compilers focus on maximizing schedule parallelism or predefine layouts (compact, sparse, standard), these strategies neglect integration of routing/rotation costs, result in unnecessarily large ancilla footprints, and fail to exploit opportunities for operator cancellation. O3LS identifies and explicitly targets these trade-offs via an automated, modular approach.

O3LS Compilation Pipeline

O3LS's main pipeline is composed of four tightly integrated modules:

1. Automatic Data Layout Search: Employs an iterative scoring-function-driven optimizer to generate "squeezed" logical qubit arrangements. The score rewards increased routing-edge availability and penalizes excessive connectivity or fragmentation, promoting both compactness and operational accessibility. Post-placement one-step optimization further refines the configuration. This automated search is computationally efficient, with scaling $\mathcal{O}(n|B|)$, where $n$ is the number of qubits and $|B|$ is the layout area.
2. Y-Synthesis and Pauli Operator Cancellation: Provides a two-tier Y-decomposition and synthesis algorithm that systematically transforms Y-Pauli rotations in physical space where both X and Z operator access is often unavailable. The decomposition scheme identifies partitionings that maximize opportunities for the cancellation of Pauli operators across the circuit, leveraging a Pauli Directed Acyclic Graph (PDAG) intermediate representation to track dependencies. The result is substantial schedule compression, especially critical for resource-constrained boards.
3. Loose Scheduling: Implements a flexible, context-aware scheduler that, rather than relying on prescriptive patterns, dynamically assigns and rotates patches only when justified by measurement requirements. Scheduling candidates are scored by expected LER reduction, routing overhead, and operation parallelizability. The approach ensures minimal redundant patch movement and better routing utilization.
4. Edge-aware Initial Mapping: Utilizes data derived from PDAG analysis to allocate logical qubits with high expected rotation frequency to patches adjacent to both X and Z ancilla edges. This approach is particularly advantageous for nontrivial layouts and leads to further reduction in rotation-induced latency.

Numerical Evaluation and Results

O3LS was benchmarked on a diverse set of FTQC circuits—Hamiltonian simulation, quantum arithmetic (e.g., modular adders), QFT, and quantum machine learning modules. Benchmarks and layouts were sourced or constructed to match those used in leading prior compilers (SPC, LAPBC, SPARO).

Key Results:

• Space Overhead Reduction: O3LS achieves up to 28% (versus standard) and up to 46.7% (versus sparse) reductions in logical patch board area without increasing circuit depth.
• Time Overhead Improvement: On compact and standard layouts, O3LS reduces time steps by 36.07% and 24.76%, respectively, compared to SPC.
• Suppression of Logical Error Rates: Maximum LER suppression reaches 16% compared to large-layout baselines; in comparisons with parallelism-focused compilers (LAPBC), O3LS yields up to an order of magnitude improvement (up to 93.95% reduction in specific benchmarks).
• Resource Savings: On a representative $d=9$ surface code and large benchmark, O3LS saves up to 7000 physical qubits (44% reduction) compared to fixed-layout compilers.
• Compilation Time and Optimality: Compilation time remains competitive (scaling polynomially), with optimality-gap for small-scale instances at 4.2% (near-ground-truth performance for small systems).

Sensitivity and Ablation Analyses

Experiments confirm effectiveness across code distances $d$ and physical error rates, with gains stable under realistic surface code parameter regimes. Ablation studies identify that each module—Y-synthesis, loose scheduling, and edge-aware mapping—contributes substantially and cumulatively to the achieved speedup and LER suppression.

Implications and Future Development

The modularity and scalability of O3LS highlight its potential as a core quantum compiler technology as device sizes grow and error budgets become even tighter. Automated squeezed layout generation and context-efficient scheduling offer resource reductions essential as FTQC hardware moves beyond prototype regime.

Integrations with orthogonal strategies—e.g., QEC code heterogeneity, physical-device-aware mapping, or multi-level magic-state factories—can potentially boost O3LS's practical impact. O3LS's IR and dependency management further make it amenable to downstream hardware-aware optimization passes.

Conclusion

O3LS establishes a new state of the art for lattice surgery compilation by coupling automated layout design, advanced operator synthesis/cancellation, and dynamic scheduling and placement strategies. This results in substantial reductions in execution time, space consumption, and logical error rates across a diverse range of circuits and layouts. Its composability and scalability suggest O3LS is primed to make a direct impact on the compilation and execution of future large-scale quantum applications.