Abstract: We study Clifford circuit synthesis as a reinforcement learning problem over the binary symplectic representation of stabilizer tableaus. We introduce a size-agnostic neural policy that is equivariant to qubit relabelings, so the same learned heuristic can be evaluated across qubit counts without circuit splicing or architecture changes. On six-qubit Clifford benchmarks, the largest setting with exact optimal references, the policy finds circuits within one CZ/CX-equivalent entangling gate of optimality in milliseconds per instance and reaches exact optima for 99.2% of instances with extended search. After continued training on 7–10 qubit targets, the same policy transfers to unseen tableaus up to thirty qubits, including targets generated by circuits with over one thousand Clifford gates, and produces markedly lower average entangling-gate counts than standard Qiskit Clifford synthesis baselines: on thirty-qubit targets it averages 323 entangling gates, versus 448 for Qiskit’s greedy synthesizer and 783 for Aaronson–Gottesman. The results suggest that symmetry-aware reinforcement learning can provide fast, reusable heuristics for quantum compilation tasks that sit between polynomial-time synthesis and expensive exact search. The trained policy is a self-contained synthesis tool: the model is only 1 MB, runs on a laptop CPU without a GPU, and is available as an interactive online demo.

Abstract: Fault-tolerant quantum circuits are often Clifford-dominated but not purely Clifford: a small number of non-Clifford operations can determine their correctness and resource costs. We present Clifft, an open-source compiler-backed exact simulator for near-Clifford fault-tolerant circuits. Clifft treats exact simulation of this regime as a compilation problem: the compiler makes the residual non-Clifford structure explicit and plans a small active subspace for execution. Clifft accepts Stim-compatible circuits extended with non-Clifford operations; lowers them to a Heisenberg intermediate representation (HIR) of virtual Pauli operations; applies algebraic optimization, Pauli localization, and active-subspace planning; and emits bytecode for a classical Schrodinger Virtual Machine (SVM). The SVM maintains a dense state vector only over the currently active virtual qubits, so its dominant dense work scales exponentially in the active dimension, rather than directly in the total number of physical qubits. As a software tool deep-dive, we describe the architecture, give compact lowering examples, summarize benchmarks of Clifft on near-Clifford and QEC-relevant circuits, and close with future extensions enabled by the compiler-backed infrastructure.

Abstract: Guppy is a quantum programming language that supports arbitrary classical computation at runtime, including measurement-dependent control flow. Recent quantum error correction (QEC) experiments run on Quantinuum Helios have been implemented in Guppy, demonstrating its practicality in the transition to the fault-tolerant era. These experiments were developed by QEC experts. In this submission, we present a framework that enables users with no QEC background to compile arbitrary Guppy programs to their choice of QEC architecture, among a collection developed by experts.

Abstract: We present quantum circuits for comparison and increment operations that achieve an asymptotically optimal gate count of O(n) and depth of O(log n) over the Clifford+Toffoli gate set, while using a provably minimal number of qubits. The constant factors in these bounds are small, making our circuit constructions not only asymptotically optimal but also highly practical. We extend these results to classical--quantum comparators, yielding an improved classical--quantum adder with an optimal qubit count. Given the ubiquity of these operations as algorithmic building blocks, our constructions translate directly into reduced circuit complexity for many quantum algorithms. As a notable example, they can be used to improve a space-efficient circuit for Shor's factoring algorithm, reducing circuit depth from O(n^3) to O(n^2 log^2 n) without increasing either the qubit count or the asymptotic gate complexity. Underpinning these results is a general theorem demonstrating how to trade ancilla qubits for control qubits with low overhead in both depth and gate count, providing a broadly applicable tool for quantum circuit design.

Abstract: Accurate resource estimates for fault-tolerant quantum computing depend on execution effects that are invisible to static gate counts. These effects include space costs induced by parallelization, efficient packing of operations into logical cycles, transient memory overheads, and the latency due to reactive basis updates. Previous analytical resource estimates approximate these effects using coarse memory reservations, throughput assumptions, or architecture-level heuristics rather than an explicit logical cycle schedule [2, 3]. In this paper, we introduce and evaluate an explicit logical-cycle scheduler for the Active Volume architecture [3] and use it to quantify execution effects in a fault-tolerant computation. We use our scheduler to show: (i) a qualitative change in predicted feasibility for qubitized Fermi--Hubbard phase-estimation circuits; (ii) a validation of two common assumptions used in analytic resource estimates; and (iii) a fitted bridge and stale-state overhead model that better matches scheduler data than the previously used fixed-percentage memory heuristic.

Abstract: In this work, we study how polyhedral compilation techniques can be applied to quantum programs. Concretely, we develop a compiler pass that constructs a polyhedral representation of quantum programs expressed in HUGR. We show the useful- ness of this abstraction through two case studies: First, we show how the model allows us to statically prove safety properties, in particular whether array accesses are in bounds and whether multi-qubit operations act on distinct qubits. Second, we show how to compute gate schedules that increase hardware parallelism, and develop a pass that resynthesises a HUGR program whose gates are emitted in the optimised order. Furthermore, we show how the scheduler can exploit commutation properties to enable additional reorderings and further increase parallelism.

Abstract: The ability to fault-tolerantly prepare CAT states, also known as multiqubit GHZ states, is an important primitive for quantum error correction. It is required for Shor-style syndrome extraction, and can also be used as a subroutine for doing fault-tolerant state preparation of CSS codewords. Existing approaches to fault-tolerant CAT state preparations have been found using computationally expensive heuristics involving SAT solving, reinforcement learning, or exhaustive analysis. In this paper, we constructively find optimal circuits for CAT states in a more scalable way. In particular, we derive formal lower bounds on the number of CNOT gates required for circuits implementing n-qubit CAT states that do not spread errors of weight at most t for 1 ≤ t ≤ 5. We do this by using fault-equivalent rewrites of ZX-diagrams to reduce it to a problem of characterising certain 3-regular simple graphs. We then provide families of such optimal graphs for infinitely many values of n and t ≤ 5. By encoding the construction of optimal graphs as a constraint satisfaction problem we find explicit constructions for circuits that match this lower bound on CNOT count for all n ≤ 50 and t ≤ 5 and for nearly all pairs (n, t) with n ≤ 100 and t ≤ 5 or n ≤ 50 and t ≤ 7, significantly extending the regimes that were achievable by previous methods and improving the resource counts for existing constructions. We additionally show how to trade CNOT count against depth, allowing us to construct constant-depth fault-tolerant implementations using O(n) ancilla and O(n) CNOT gates.

Abstract: We present parameter-optimal unitary synthesis methods based on flag decompositions and brick wall circuits. Our main contribution is the flag decomposition, an efficient linear-algebra tool that delivers parameter-optimal synthesis at all practically relevant system sizes. This approach is complemented by brick wall circuits, which additionally saturate the two-qubit gate lower bound at small scale. This extended abstract summarizes the core results of the companion preprints arXiv:2603.20376 and arXiv:2511.16736.

Abstract: Clifford+T synthesis of rotation gates is an important routine in fault-tolerant quantum compilation. While Clifford+T synthesis is scalable, it has a high overhead of tens of T gates per rotation in practice, translating to high resource estimates for many fault-tolerant algorithms. However, these well-known results, including those using probabilistic mixtures [Quantum 7, 1208 (2023)], are independent of the rotation angle theta, requiring O(log1/δ) T gates. We show that it is possible to do much better for small angles, reducing the T cost to ~O(θ^2/δ), and returning to existing O(log 1/δ) results in the worst case. This is particularly important since many algorithms, such as Trotterization, are dominated by small-angle rotations. Further, we perform a detailed theoretical and numerical study of quasi-probabilities, which can further reduce the total T cost of large circuits by orders of magnitude with only a small overhead in sample complexity. We also develop a scheme based on quasi-probability mixtures of Clifford+T fallback channels. We derive new theta-dependent formulas that can be used for resource estimation of fault-tolerant quantum algorithms. As an application of our results, we show that the gate cost of Trotterization circuits compiled to a Clifford+T gate set is constant in the small Trotter step size limit, and can be reduced by orders of magnitude even for large step sizes. The cost of fault-tolerant Trotterization for a variety of applications should be re-examined in light of these results. Our work dispels the widely-stated claim that Clifford+T rotation synthesis has a high cost independent of theta, and further develops a scalable quasi-probability method for rotation synthesis. We also expect our results to bring forward useful early fault-tolerant quantum computing by reducing required magic state resources.

Abstract: Fault-tolerant quantum computing requires compilers that can reason about logical qubits, error-correcting code (ECC) metadata, syndrome extraction, and magic-state resources before programs are lowered to backend-specific instructions. This talk summarizes the ftqc dialect, an open-source Multi-Level Intermediate Representation (MLIR) dialect that represents these concerns directly in the intermediate representation (IR), and its prototype compiler implementation. The dialect provides typed logical-qubit values parameterized by the ECC and its distance, 31 fault-tolerant operations, 18 transformation and analysis passes, and backend emitters for Open Quantum Assembly Language (OpenQASM)~3, Quantum Intermediate Representation (QIR), and Stim stabilizer circuits. Additionally, the prototype implementation explores IQM circuits encoded in JavaScript Object Notation (JSON) for real superconducting backends and LightStim experiment descriptors for quantum error correction (QEC) protocol evaluation. Evaluation on common circuit benchmarks shows that the proposed MLIR-based compiler preserves a single fault-tolerant IR while producing validated outputs for multiple execution and simulation environments.

Abstract: We estimate the cost of simulating the two-dimensional Fermi-Hubbard model on a biplanar spin-optical quantum computing (SPOQC) architecture. Qubits are encoded in the honeycomb Floquet code, and we use a circuit-level noise model with explicit timings for each native physical operation. We benchmark lattice surgery and magic state preparation within each plane, and transversal CNOT gates between corresponding logical qubits across planes. We compile a plaquette-based Trotterization of the time evolution operator, mapping the two spin sectors of the Fermi-Hubbard model onto two physical planes. This architectural co-design eliminates fermionic swap operations and reduces the depth of each Trotter step to 4t_synth + 90 logical timesteps, where t_synth is the logical timestep cost of arbitrary-angle rotations, compared to 6t_synth + 354 for prior single-plane compilations. All error sources — algorithmic (Trotter), logical noise, magic state infidelity, and rotation synthesis — are treated jointly within a single 1% diamond norm budget. For an L × L lattice with hopping amplitude t and on-site interaction strength U, setting L = 8 and U/t = 8, we estimate a total runtime of approximately 2 hours using 1.35 × 10⁶ physical qubits. We find that fallback-based rotation synthesis methods become a scalability bottleneck: the probability that all L² parallel rotations succeed on the first attempt vanishes exponentially with system size, causing the failure branch to dominate the expected runtime already at moderate L.

Abstract: As quantum computing hardware scales toward early fault tolerance, quantum compilation has emerged as a critical path to extracting performance from near-term and future devices. Hardware constraints — such as limited qubit connectivity, short coherence times, and the steep overhead of fault-tolerant operations like T-gates — demand highly optimized circuits. Consequently, quantum compilation is now a heavily active area of research and software development. Despite rapid progress in compilation theory and tooling, a clear disconnect persists between the software developers building sophisticated compilation tools and the research scientists who need them. Industry and academic groups are releasing advanced, scalable compiler frameworks built on heavy-duty infrastructure like MLIR and LLVM. Yet, many researchers remain unaware of these tools. Instead, scientific workflows frequently default to manual circuit optimizations, relying on undocumented, hand-coded tricks tailored to specific experiments in Python. This gap is driven by four factors. First, modern compilation software increasingly assumes a prerequisite understanding of classical compiler theory, alienating physicists and quantum chemists who lack formal software engineering backgrounds. Second, the existing literature is dense; techniques are frequently buried in broader papers under inconsistent names. Third, the quantum research audience is fundamentally fragmented, with distinct groups requiring entirely different interfaces and explanations for the same underlying compilation tools. Finally, there is uncertainty regarding the future needs and requirements for fault-tolerant quantum computing architectures. To address this, we present the quantum compilation content ecosystem developed within PennyLane.ai. By integrating technical explanation with executable code, we outline a targeted outreach and educational strategy designed to bridge compilation developers, application researchers, and compilation researchers. We demonstrate that building sophisticated compilation software is insufficient without an equal investment in translating those tools for the scientific end-user.

Abstract: Fault-tolerant preparation of logical states is an important task for the realization of large-scale fault-tolerant quantum computing. This paper introduces CSSCat, a scalable compilation pipeline that generates highly optimized, fault-tolerant state preparation circuits for arbitrary Calderbank-Shor-Steane (CSS) codes. Our method utilizes the ZX-calculus and fault-equivalent ZX rewrites~\cite{rodatz2024floquetifying,rodatz2025fault}, which are a restricted set of ZX rewrites guaranteeing that the behaviour of two diagrams remains identical under noise. We start with an idealized specification of a CSS state, which we then transform into a phase-free bipartite ZX-diagram, and finally obtain a fault-tolerant ZX-diagram. From this ZX-diagram, CSSCat extracts a fault-tolerant CSS state preparation circuit using a circuit extraction procedure that results in circuits with minimal gate overhead. As CSSCat only uses fault-equivalent ZX rewrites, the final circuit is provably fault-tolerant and the pipeline is fully scalable to any size given a database of precomputed CAT states of appropriate size and distance. Monte Carlo simulations across a variety of CSS codes demonstrate that CSSCat scales efficiently up to high distances, and constructs circuits with significantly reduced depth compared to existing methods, while achieving comparable or improved performance in terms of logical error and acceptance rates.

Abstract: Modern quantum transpilers chain pipelines of named passes (layout, routing, cancellation, scheduling), yet it is unclear which passes are truly critical and whether this depends on workload. We present PassProbe, which ablates all 2^k pass subsets in a k-pass pipeline and applies Shapley-value attribution to measure each pass's marginal contribution to circuit quality. Across 20 circuits, six workload classes, and four state-of-the-art compilers, we find that just 2-3 passes drive over 80% of quality gains, with the dominant pass shifting predictably by workload; pass ordering effects can exceed selection effects for deep circuits; and 3-5 passes per compiler can be safely pruned, cutting compilation time by up to 22% with <0.5% quality loss.

Abstract: Fault-tolerant quantum computers are increasingly designed as modular machines: qubits live in physical modules—logical patches of a surface code, blocks of a qLDPC code, separate chips—and talking between modules is far more expensive than computing inside one. On such machines the true cost of running a program is rarely its gate count; it is the routing of entanglement between distant qubits. The usual remedy is spatial: keep qubits that interact often close together. We explore an orthogonal, temporal idea borrowed from the memory hierarchy of classical processors. We equip the device with a small, fast cache into which frequently used logical operators are loaded once; afterwards, many non-Clifford rotations can be applied locally inside the cache, without paying the routing cost again and again. The rest of this section makes this picture precise: we recall how a single Pauli rotation is localized onto an ancilla, promote that gadget into a reusable cache abstraction with two primitives— Load and Patch—and describe a simple streaming pass that compiles any program into a sequence of cache instructions.

Abstract: Fault-tolerant quantum computing (FTQC) architectures such as the bivariate bicycle (BB) and Gross code promise logical error rates far below their physical counterparts, but demand compilers and resource estimation tools that do not yet exist at scale. Existing frameworks target e.g. near-term representations or generic metrics such as T-gate count, neither of which captures the three dominant cost channels of LDPC architectures: magic state injection, inter-module entanglement, and Pauli addressing overhead. We introduce Qiskit Resource Estimation (QRE), a resource estimation tool for generic intermediate representations (IRs) with Qiskit-native error models targeting LDPC-code architectures. QRE represents algorithms as a call graph and enable fast cost accumulation at any level of abstraction. A typed metric algebra handles customizable resources across arbitrary IRs. An off-the-shelf Gross code error model decomposes circuit fidelity into the three LDPC cost channels and models both SWAP-based and teleportation-based routing overhead. We evaluate QRE on quantum phase estimation for an Ising Hamiltonian and show that it closely tracks full Qiskit compilation fidelity while running an order of magnitude faster, making hyperparameter sweeps and architecture comparisons practical at system sizes where full compilation is intractable.