Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2611.04075

Runtime Compilation for Quantum Circuits with PQF-Enabled $R_z$ Synthesis

Siddharth Dangwal, Christopher Kang, Jad Habhab, Ritvik Sharma, Frederic T. Chong, Gokul Subramanian Ravi

quant-phSubmitted Nov 2, 2026• Announced Nov 4, 2026• 0 citations
arXivHTMLPDF

Abstract

In Fault-Tolerant Quantum Computing (FTQC) using surface codes, reducing $T$-count is critical for efficient computation due to the high cost of $T$-state distillation. Probabilistic Quantum Circuit with Fallback (PQF) synthesis significantly lowers $T$-counts compared to standard protocols like Gridsynth, but introduces high circuit dynamism through extra gates inserted at runtime. This dynamism invalidates static compile-time routing, as these new $T$ gates require dynamic lattice surgery routing to establish non-intersecting ancilla paths to $T$-state factories while minimizing total execution time. To address this, we introduce $\text{R}^2$-PQF, a Runtime Routing protocol for PQF-synthesized quantum circuits. $\text{R}^2$-PQF dynamically routes gates layer-by-layer, computing paths during the execution of the previous logical timestep. To satisfy the strict computational window of $\sim t_{lattice\_surgery} + t_{reaction}$ and non-intersectionality constraints, we implement a Wavefront Breadth-First Search (W-BFS) and synthesise it on a 500MHz FPGA and 2 GHz ASIC. For a clock cycle of 2GHz, we achieve a median logical time-step of $1.51 μs$ for a 300 qubit Ising Hamiltonian circuit, demonstrating that $\text{R}^2$-PQF successfully resolves the vast majority of paths (with rare exceptions) within the execution window and enables the $T$-count benefits of PQF without latency penalties. Compared to a baseline stalling-based solution (the only no-runtime-recomputation solution), $\text{R}^2$-PQF speeds up circuit execution by $1.34\times$ on average and up to $1.76 \times$.

AI Summary

Probabilistic quantum circuits with fallback (PQF) reduce rotation-synthesis $T$ counts but require corrective gate sequences when measurements fail. These insertions can invalidate precomputed lattice-surgery routes. The paper asks whether routing can be recomputed during fault-tolerant execution without losing PQF’s resource benefits to scheduling delays. $R^2$-PQF incrementally reschedules dependency-ready gates, including inserted corrections, using bidirectional wavefront breadth-first search, heuristic route arbitration, and a retry stage. It computes the next layer’s routes while the current layer executes, with an initial stall after PQF failure. Evaluation combines circuit simulation for Hamiltonian simulation, VQE, QFT, and phase estimation on three layouts with FPGA and ASIC synthesis. Across benchmarks with 50–450 qubits at $p_{succ}=0.9$ and $\epsilon=10^{-13}$, reported schedule speedups average $1.34\times$ over serialized fallback execution and $1.25\times$ over a baseline that checks precomputed routes for conflicts; maxima are $1.76\times$ and $1.59\times$. Compared with statically compiled Gridsynth circuits, PQF circuits average $1.68\times$ faster. At the synthesized ASIC frequency of 2 GHz, median routing latency is $1.51\,\mu\mathrm{s}$ for a 300-qubit Ising circuit; at most $0.1\%$ of evaluated steps exceed the assumed $20\,\mu\mathrm{s}$ budget. Results depend on workload, layout, and timing assumptions. The 250 MHz FPGA exceeds that budget more often, requiring stalls. Repeated stochastic trials cover only circuits of at most 100 qubits, global-recompilation comparisons are limited by computational cost, and larger-scale timing estimates are extrapolations. Hardware results are synthesis-based rather than demonstrations integrated with a quantum processor.

Little sign of AI-generated textOverclaimsStrong assumptions

Error found: The abstract's 1.51 μs 'median logical time-step' is actually the ASIC's classical routing latency, not the modeled quantum timestep of 20 μs at code distance 10. The abstract reports a 500 MHz FPGA implementation, but the methodology, hardware tables, and evaluated latencies use 250 MHz. The claim of operation 'without latency penalties' overlooks explicitly acknowledged post-failure stalls and occasional routing-deadline overruns, although the reported speedups include the post-failure stalls.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Related papers

Quantum Compiler Design for Fault-Tolerant Quantum Computing

Chenghong Zhu, Jiahan Chen, Keming He +9 more

Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC realization, and decoder runtime integration. At the logical level, we review surface-code lattice-surgery compilers, beyond-surface-code code-surgery frameworks including emerging qLDPC approaches, and compilation support for non-Clifford operations such as magic-state distillation and code switching. At the physical level, we survey hardware-aware QEC realization on superconducting, trapped-ion, and neutral-atom platforms. We further examine decoder models, real-time decoding systems, and frame-management mechanisms that close the feedback loop during fault-tolerant execution. Finally, we identify open challenges in cross-layer optimization, qLDPC compilation, compiler-decoder co-design, runtime adaptivity, and the development of integrated and benchmarkable FTQC compilation stacks. An actively maintained paper list is available at: github.com/chenghongz/QEC-compiler-design.

quant-pharXiv:2609.17465•Sep 16, 2026•0 citations

General circuit compilation protocol into partially fault-tolerant quantum computing architecture

Tomochika Kurita

As we are entering an early-FTQC era, circuit execution protocols with logical qubits and certain error-correcting codes are being discussed. Here, we propose a circuit execution protocol for the space-time efficient analog rotation (STAR) architecture. Gate operations within the STAR architecture is based on lattice surgery with surface codes, but it allows direct execution of continuous gates $Rz(θ)$ as non-Clifford gates instead of $T = Rz(π/4)$. $Rz(θ)$ operations involve creation of resource states $|m_θ\rangle = \frac{1}{\sqrt{2}} (|0 \rangle + e^{iθ} |1\rangle ) $ followed by ZZ joint measurements with target logical qubits. While employing $Rz(θ)$ enables more efficient circuit execution, both their creations and joint measurements are probabilistic processes and adopt repeat-until-success (RUS) protocols which are likely to result in considerable time overhead. Our circuit execution protocol aims to reduce such time overhead by parallel trials of resource state creations and more frequent trials of joint measurements. By employing quadratic unconstrained binary optimization (QUBO) in determining resource state allocations within the space, we successfully make our protocol efficient. Furthermore, we proposed performance estimators given the target circuit and qubit topology. It successfully predicts the time performance within less time than actual simulations do, and helps find the optimal qubit topology to run the target circuits efficiently.

quant-pharXiv:2603.17428•Mar 19, 2026•1 citation

Efficient synthesis of probabilistic quantum circuits with fallback

Alex Bocharov, Martin Roetteler, Krysta M. Svore

Repeat-until-success (RUS) circuits can approximate a given single-qubit unitary with an expected number of $T$ gates of about $\frac{1}{3}$ of what is required by optimal, deterministic, ancilla-free decompositions over the Clifford + $T$ gate set. In this work, we introduce a more general and conceptually simpler circuit decomposition method that allows for synthesis into protocols that probabilistically implement quantum circuits over several universal gate sets including, but not restricted to, the Clifford + $T$ gate set. The protocol, which we call probabilistic quantum circuits with fallback (PQF), implements a walk on a discrete Markov chain in which the target unitary is an absorbing state and in which transitions are induced by multiqubit unitaries followed by measurements. In contrast to RUS protocols, the presented PQF protocols are guaranteed to terminate after a finite number of steps. Specifically, we apply our method to the Clifford + $T$, Clifford + $V$, and Clifford + $\ensuremath{\pi}/12$ gate sets to achieve decompositions with expected gate counts of ${log}_{b}(1/\ensuremath{\varepsilon})+O{ln[ln(1/\ensuremath{\varepsilon})]}$, where $b$ is a quantity related to the expansion property of the underlying universal gate set.

arXiv:1409.3552•Physical Review A•May 18, 2015•78 citations

Flow-Based Lattice Surgery Optimization with Runtime T Gate Scheduling

Raymond Iacobacci, Tianyi Hao, Neer Patel +1 more

Lattice surgery on the surface code is a leading route to fault-tolerant quantum computation. Compiling logical circuits into lattice surgery operations is a pivotal step that determines the resource cost of a computation. Prior compilers build on idealized assumptions, and one that works in practical settings remains to be developed. Existing works are either unscalable or route one gate at a time within a layer, so the embedding depends on the order of gates and opportunities to route many gates at once are lost. In addition, they assume magic states are always available and cost-free, even though preparing one costs more than a Clifford operation. We present FlowRouter, the first topological lattice surgery compiler that places Clifford routing and stochastic magic state cultivation inside a single 3D embedding. At compile time, FlowRouter formulates the routing of an entire circuit layer as a maximum-flow problem, embedding many gates simultaneously. At runtime, it allows magic states to be cultivated at every idling patch, works with the realistic cultivation process with multiplexing and multi-stage post-selections, and absorbs the stochasticity by introducing delay mechanisms that add as little spacetime volume as possible. With magic states assumed free, FlowRouter reduces spacetime volume by 2.3x and compiles 10.8x faster than the state-of-the-art static topological lattice surgery compiler. With the cultivation-aware setting that includes both Clifford and magic state cost, FlowRouter reduces spacetime volume by 2.3x on a distance-13 surface code when compared with the state-of-the-art runtime compiler.

quant-pharXiv:2609.23756•Sep 22, 2026•1 citation

Space-Time Optimisations for Early Fault-Tolerant Quantum Computation

Sanaa Sharma, Prakash Murali

Fault-tolerance is the future of quantum computing, ensuring error-corrected quantum computation that can be used for practical applications. Resource requirements for fault-tolerant quantum computing (FTQC) are daunting, and hence, compilation techniques must be designed to ensure resource efficiency. There is a growing need for compilation strategies tailored to the early FTQC regime, which refers to the first generation of fault-tolerant machines operating under stringent resource constraints of fewer physical qubits and limited distillation capacity. Present-day compilation techniques are largely focused on overprovisioning of routing paths and make liberal assumptions regarding the availability of distillation factories. Our work develops compilation techniques that are tailored to the needs of early FTQC systems, including distillation-adaptive qubit layouts and routing techniques. In particular, we show that simple greedy heuristics are extremely effective for this problem, offering up to 60% reduction in the number of qubits compared to prior works. Our techniques offer results with an average overhead of 1.2X in execution time for a 53% reduction in qubits against the theoretical lower bounds. As the industry develops early FTQC systems with tens to hundreds of logical qubits over the coming years, our work has the potential to be widely useful for optimising program executions.

quant-pharXiv:2511.08848•Nov 13, 2025•3 citations

A Resource Allocating Compiler for Lattice Surgery

Alan Robertson, Gao, Haowen, Yuval R. Sanders

The emerging field of quantum resource estimation is aimed at providing estimates of the hardware requirements (`quantum resources') needed to execute a useful, fault-tolerant quantum computation. Given that quantum computers are intended to compete with supercomputers, useful quantum computations are likely to involve the use of millions of qubits and error correction clock cycles. The compilation and benchmarking of these circuits depends on placement and routing algorithms, which are infeasible to construct at scale by hand. We offer a compiler that transforms a quantum circuit into a sequence of lattice surgery operations. The compiler manages memory in terms of surface code patches and costs the space-time volume and cycle counts of the input circuits. These compiled lattice surgery objects are then recursively repurposed as gates for larger scale compilations. Our code is available on GitHub under a permissive software license and we welcome community contributions.

arXiv:2506.04620•Jun 5, 2025•7 citations
Runtime Compilation for Quantum Circuits with PQF-Enabled RzR_zRz​ Synthesis
In Fault-Tolerant Quantum Computing (FTQC) using surface codes, reducing TTT-count is critical for efficient computation due to the high cost of TTT-state distillation. Probabilistic Quantum Circuit with Fallback (PQF) synthesis significantly lowers TTT-counts compared to standard protocols like Gridsynth, but introduces high circuit dynamism through extra gates inserted at runtime. This dynamism invalidates static compile-time routing, as these new TTT gates require dynamic lattice surgery routing to establish non-intersecting ancilla paths to TTT-state factories while minimizing total execution time.
To address this, we introduce R2\text{R}^2R2-PQF, a Runtime Routing protocol for PQF-synthesized quantum circuits. R2\text{R}^2R2-PQF dynamically routes gates layer-by-layer, computing paths during the execution of the previous logical timestep. To satisfy the strict computational window of ∼tlattice_surgery+treaction\sim t_{lattice\_surgery} + t_{reaction}∼tlattice_surgery​+treaction​ and non-intersectionality constraints, we implement a Wavefront Breadth-First Search (W-BFS) and synthesise it on a 500MHz FPGA and 2 GHz ASIC. For a clock cycle of 2GHz, we achieve a median logical time-step of 1.51μs1.51 μs1.51μs for a 300 qubit Ising Hamiltonian circuit, demonstrating that R2\text{R}^2R2-PQF successfully resolves the vast majority of paths (with rare exceptions) within the execution window and enables the TTT-count benefits of PQF without latency penalties. Compared to a baseline stalling-based solution (the only no-runtime-recomputation solution), R2\text{R}^2R2-PQF speeds up circuit execution by 1.34×1.34\times1.34× on average and up to 1.76×1.76 \times1.76×.
Probabilistic quantum circuits with fallback (PQF) reduce rotation-synthesis TTT counts but require corrective gate sequences when measurements fail. These insertions can invalidate precomputed lattice-surgery routes. The paper asks whether routing can be recomputed during fault-tolerant execution without losing PQF’s resource benefits to scheduling delays.
R2R^2R2-PQF incrementally reschedules dependency-ready gates, including inserted corrections, using bidirectional wavefront breadth-first search, heuristic route arbitration, and a retry stage. It computes the next layer’s routes while the current layer executes, with an initial stall after PQF failure. Evaluation combines circuit simulation for Hamiltonian simulation, VQE, QFT, and phase estimation on three layouts with FPGA and ASIC synthesis.
Across benchmarks with 50–450 qubits at psucc=0.9p_{succ}=0.9psucc​=0.9 and ϵ=10−13\epsilon=10^{-13}ϵ=10−13, reported schedule speedups average 1.34×1.34\times1.34× over serialized fallback execution and 1.25×1.25\times1.25× over a baseline that checks precomputed routes for conflicts; maxima are 1.76×1.76\times1.76× and 1.59×1.59\times1.59×. Compared with statically compiled Gridsynth circuits, PQF circuits average 1.68×1.68\times1.68× faster. At the synthesized ASIC frequency of 2 GHz, median routing latency is 1.51 μs1.51\,\mu\mathrm{s}1.51μs for a 300-qubit Ising circuit; at most 0.1%0.1\%0.1% of evaluated steps exceed the assumed 20 μs20\,\mu\mathrm{s}20μs budget.
Results depend on workload, layout, and timing assumptions. The 250 MHz FPGA exceeds that budget more often, requiring stalls. Repeated stochastic trials cover only circuits of at most 100 qubits, global-recompilation comparisons are limited by computational cost, and larger-scale timing estimates are extrapolations. Hardware results are synthesis-based rather than demonstrations integrated with a quantum processor.
Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC realization, and decoder runtime integration. At the logical level, we review surface-code lattice-surgery compilers, beyond-surface-code code-surgery frameworks including emerging qLDPC approaches, and compilation support for non-Clifford operations such as magic-state distillation and code switching. At the physical level, we survey hardware-aware QEC realization on superconducting, trapped-ion, and neutral-atom platforms. We further examine decoder models, real-time decoding systems, and frame-management mechanisms that close the feedback loop during fault-tolerant execution. Finally, we identify open challenges in cross-layer optimization, qLDPC compilation, compiler-decoder co-design, runtime adaptivity, and the development of integrated and benchmarkable FTQC compilation stacks. An actively maintained paper list is available at: github.com/chenghongz/QEC-compiler-design.
As we are entering an early-FTQC era, circuit execution protocols with logical qubits and certain error-correcting codes are being discussed. Here, we propose a circuit execution protocol for the space-time efficient analog rotation (STAR) architecture. Gate operations within the STAR architecture is based on lattice surgery with surface codes, but it allows direct execution of continuous gates Rz(θ)Rz(θ)Rz(θ) as non-Clifford gates instead of T=Rz(π/4)T = Rz(π/4)T=Rz(π/4). Rz(θ)Rz(θ)Rz(θ) operations involve creation of resource states $|m_θ\rangle = \frac{1}{\sqrt{2}} (|0 \rangle + e^{iθ} |1\rangle ) $ followed by ZZ joint measurements with target logical qubits. While employing Rz(θ)Rz(θ)Rz(θ) enables more efficient circuit execution, both their creations and joint measurements are probabilistic processes and adopt repeat-until-success (RUS) protocols which are likely to result in considerable time overhead. Our circuit execution protocol aims to reduce such time overhead by parallel trials of resource state creations and more frequent trials of joint measurements. By employing quadratic unconstrained binary optimization (QUBO) in determining resource state allocations within the space, we successfully make our protocol efficient. Furthermore, we proposed performance estimators given the target circuit and qubit topology. It successfully predicts the time performance within less time than actual simulations do, and helps find the optimal qubit topology to run the target circuits efficiently.
Repeat-until-success (RUS) circuits can approximate a given single-qubit unitary with an expected number of TTT gates of about 13\frac{1}{3}31​ of what is required by optimal, deterministic, ancilla-free decompositions over the Clifford + TTT gate set. In this work, we introduce a more general and conceptually simpler circuit decomposition method that allows for synthesis into protocols that probabilistically implement quantum circuits over several universal gate sets including, but not restricted to, the Clifford + TTT gate set. The protocol, which we call probabilistic quantum circuits with fallback (PQF), implements a walk on a discrete Markov chain in which the target unitary is an absorbing state and in which transitions are induced by multiqubit unitaries followed by measurements. In contrast to RUS protocols, the presented PQF protocols are guaranteed to terminate after a finite number of steps. Specifically, we apply our method to the Clifford + TTT, Clifford + VVV, and Clifford + $\ensuremath{\pi}/12$ gate sets to achieve decompositions with expected gate counts of ${log}_{b}(1/\ensuremath{\varepsilon})+O{ln[ln(1/\ensuremath{\varepsilon})]}$, where bbb is a quantity related to the expansion property of the underlying universal gate set.
Lattice surgery on the surface code is a leading route to fault-tolerant quantum computation. Compiling logical circuits into lattice surgery operations is a pivotal step that determines the resource cost of a computation. Prior compilers build on idealized assumptions, and one that works in practical settings remains to be developed. Existing works are either unscalable or route one gate at a time within a layer, so the embedding depends on the order of gates and opportunities to route many gates at once are lost. In addition, they assume magic states are always available and cost-free, even though preparing one costs more than a Clifford operation. We present FlowRouter, the first topological lattice surgery compiler that places Clifford routing and stochastic magic state cultivation inside a single 3D embedding. At compile time, FlowRouter formulates the routing of an entire circuit layer as a maximum-flow problem, embedding many gates simultaneously. At runtime, it allows magic states to be cultivated at every idling patch, works with the realistic cultivation process with multiplexing and multi-stage post-selections, and absorbs the stochasticity by introducing delay mechanisms that add as little spacetime volume as possible. With magic states assumed free, FlowRouter reduces spacetime volume by 2.3x and compiles 10.8x faster than the state-of-the-art static topological lattice surgery compiler. With the cultivation-aware setting that includes both Clifford and magic state cost, FlowRouter reduces spacetime volume by 2.3x on a distance-13 surface code when compared with the state-of-the-art runtime compiler.
Fault-tolerance is the future of quantum computing, ensuring error-corrected quantum computation that can be used for practical applications. Resource requirements for fault-tolerant quantum computing (FTQC) are daunting, and hence, compilation techniques must be designed to ensure resource efficiency. There is a growing need for compilation strategies tailored to the early FTQC regime, which refers to the first generation of fault-tolerant machines operating under stringent resource constraints of fewer physical qubits and limited distillation capacity. Present-day compilation techniques are largely focused on overprovisioning of routing paths and make liberal assumptions regarding the availability of distillation factories. Our work develops compilation techniques that are tailored to the needs of early FTQC systems, including distillation-adaptive qubit layouts and routing techniques. In particular, we show that simple greedy heuristics are extremely effective for this problem, offering up to 60% reduction in the number of qubits compared to prior works. Our techniques offer results with an average overhead of 1.2X in execution time for a 53% reduction in qubits against the theoretical lower bounds. As the industry develops early FTQC systems with tens to hundreds of logical qubits over the coming years, our work has the potential to be widely useful for optimising program executions.
The emerging field of quantum resource estimation is aimed at providing estimates of the hardware requirements (`quantum resources') needed to execute a useful, fault-tolerant quantum computation. Given that quantum computers are intended to compete with supercomputers, useful quantum computations are likely to involve the use of millions of qubits and error correction clock cycles. The compilation and benchmarking of these circuits depends on placement and routing algorithms, which are infeasible to construct at scale by hand. We offer a compiler that transforms a quantum circuit into a sequence of lattice surgery operations. The compiler manages memory in terms of surface code patches and costs the space-time volume and cycle counts of the input circuits. These compiled lattice surgery objects are then recursively repurposed as gates for larger scale compilations. Our code is available on GitHub under a permissive software license and we welcome community contributions.