Abstract: We present the first exact quantum adder with sublinear depth and no ancilla qubits. Our construction is based on classical reversible logic only and employs low-depth implementations for the CNOT ladder operator and the Toffoli ladder operator, two key components to perform ripple-carry addition. Namely, we demonstrate that any ladder of n CNOT gates can be replaced by a CNOT-circuit with O (log n) depth, while maintaining a linear number of gates.We then generalize this construction to Toffoli gates and demonstrate that any ladder of n Toffoli gates can be substituted with a circuit with O(log2 n) depth while utilizing a linearithmic number of gates. This builds on the recent works of Nie et al. and Khattar and Gidney on the technique of conditionally clean ancillae. By combining these two key elements, we present a novel approach to design quantum adders that can perform the addition of two n-bit numbers in depth O(log2 n) without the use of any ancilla and using classical reversible logic only (Toffoli, CNOT and X gates).

Abstract: We present the bicycle architecture, a modular quantum computing framework based on high-rate, low-overhead quantum LDPC codes identified in prior work. For two specific bivariate bicycle codes with distances 12 and 18, we construct explicit fault-tolerant logical instruction sets and estimate the logical error rate of each instruction under circuit noise. We develop a compilation strategy adapted to the constraints of the bicycle architecture, enabling large-scale universal quantum circuit execution. Integrating these components, we perform end-to-end resource estimates demonstrating that an order of magnitude larger logical circuits can be implemented with a given number of physical qubits on a bicycle architecture than on surface code architectures. We anticipate further improvements through advances in code constructions, circuit designs, and compilation techniques.

Abstract: Quantum compilers that reduce the number of T-gates are essential for minimizing the overhead of fault-tolerant quantum computation. To achieve effective T-gate reduction, it is necessary to identify equivalent circuit transformation rules that are not yet utilized in existing tools. In this study, we investigate the rotation axes of multi-Pauli rotation gates and introduce a nontrivial equivalent transformation rule, the multi-product commutation relation (MCR). This rule constructs gate sequences based on specific commutation properties among multi-Pauli operators, yielding seemingly non-commutative instances that can actually be commuted. To evaluate whether existing compilers account for this commutation rule, we create a benchmark circuit dataset using a quantum circuit unoptimization. This technique intentionally adds redundancy to the circuit while keeping its equivalence. By leveraging the known structure of the original circuit before unoptimization, this method enables a quantitative evaluation of compiler performance by measuring how closely the optimized circuit matches the original circuit. Our numerical experiments reveal that the transformation rule based on MCR is not yet incorporated into current compilers. This finding suggests an untapped potential for further T-gate reduction by integrating MCR-aware transformations, paving the way for improvements in quantum compilers.

Abstract: Commuting gates or blocks of gates imply there are multiple places across a quantum circuit where the application of a particular gate would have the same effect. This is central to circuit optimisation passes that merge similar rotation gates (a.k.a. phase folding), or restructure the circuit into regions that are more amenable to resynthesis methods (such as collecting large regions of commuting rotations for synthesis by mutual diagonalisation or for the purpose of T-gate optimisation). Even more opportunities for these optimisations occur if we can safely move gates between control-flow blocks in a quantum program.

Recent work by Amy and Lunderville rephrased the analysis for phase folding as a relational data-flow analysis, making it easier to reuse existing infrastructure from classical tools or integrate with other techniques for compiling classical programs. We propose a way to modify this method to track stabilizers as relations which are asymptotically efficient to work with and admit simple proofs of (relative) completeness for phase folding. Additionally, the new data-flow values completely capture the semantics of a basic block which can be resynthesised directly, where some of the stabilizers identified by the analysis present more degrees of freedom for optimisation during resynthesis.

Abstract: Dynamic quantum circuits allow mid-circuit measurements whose outcomes influence the subsequent circuit execution via classical control-flow. We propose a compiler pass that reduces the T-count of such dynamic circuits by detecting opportunities for linear phase polynomials to be hoisted out of control-flow structures. For example, in some situtions, T gates may be moved out of loops and replaced with a classical phase accumulator.

Our pass works across arbitrary structured and nested control-flow and scales to arbitrary branching depths. Apart from the hoisting itself, it fully maintains the program structure and performs no code duplication or unrolling. We framing the problem of detecting hoisting opportunities in terms of a phase folding analysis and build on top of the PF domain recently proposed by Amy and Lunderville for folding phases via data-flow analysis. We provide a prototype implementation, and a production grade implementation in the tket compiler is underway.

Abstract: Recursive Cartan decompositions (CDs) provide a way to exactly factorize quantum circuits into smaller components, making them a central tool for unitary synthesis. Here we present a detailed overview of recursive CDs, elucidating their mathematical structure, demonstrating their algorithmic utility, and implementing them numerically at large scales. We adapt, extend, and unify existing mathematical frameworks for recursive CDs, allowing us to gain new insights and streamline the construction of new circuit decompositions. Based on this, we show that several leading synthesis techniques from the literature—the Quantum Shannon, Block-ZXZ, and Khaneja-Glaser decompositions—implement the same recursive CD. We also present new recursive CDs based on the orthogonal and symplectic groups, and derive parameter-optimal decompositions. Furthermore, we aggregate numerical tools for CDs from the literature, put them into a common context, and complete them to allow for numerical implementations of all possible classical CDs in canonical form. As an application, we efficiently compile fast-forwardable Hamiltonian time evolution to fixed-depth circuits, compiling the transverse-field XY model on a thousand qubits into 2 million gates in 22 seconds on a laptop.

Abstract: In the era of noisy intermediate-scale quantum (NISQ) devices, there is a constant need to optimize the gate count, circuit depth, and in general, execution time. In this work, we introduce mixed-channel phase squashing, a novel protocol for approximate quantum circuit simulation that extends prior techniques by allowing mixed quantum channels. Our protocol uses the ZX-calculus optimization techniques and a greedy strategy that selectively replaces small-angle Z-phase gates with stochastic mixtures of identity and different Z-phase gates, all under a strict error budget. We demonstrate that, while the approach yields modest two-qubit gate-count reduction in generic random quantum circuits, it achieves substantial reduction in structured circuits, such as the quantum Fourier transform. These results highlight the potential of mixed-channel approximations to enhance near-term quantum circuit performance, suggesting new directions for resource-aware quantum compilation beyond pure unitary channels.

Abstract: We present an efficient algorithm to reduce the number of non-Clifford gates in quantum circuits and the number of parametrized rotations in parametrized quantum circuits. The method consists in finding rotations that can be merged into a single rotation gate. This approach has already been considered before and is used as a pre-processing procedure in many optimization algorithms, notably for optimizing the number of Hadamard gates or the number of T gates in Clifford+T circuits. Our algorithm has a better complexity than similar methods and is particularly efficient for circuits with a low number of internal Hadamard gates. Furthermore, we show that this approach is optimal for parametrized circuits composed of Clifford gates and parametrized rotations with non-repeated parameters. For the same type of parametrized quantum circuits, we also prove that a previous procedure optimizing the number of Hadamard gates and internal Hadamard gates is optimal. This procedure is notably used in our low-complexity algorithm for optimally reducing the number of parametrized rotations.

Abstract: A critical property of any quantum error correcting code implementation is fault-tolerance (FT): the physical circuits that perform encoding, decoding, and logical operations must not introduce or propagate errors in a way that overwhelms the code's corrective capabilities. Verifying this property is notoriously difficult and error-prone to perform manually, especially for complex codes and compiled circuits. By incorporating the techniques of quantum symbolic execution, Chen et. al developed an automatic verification framework and tool for checking quantum fault-tolerance. The approach leverages symbolic execution and Satisfiability Modulo Theories (SMT) solvers to automatically prove whether a given circuit gadget is fault-tolerant for a specific QECC. We build on this foundation and introduce ucc-ft, an open-source tool that brings this verification technique into a practical, compiler-friendly ecosystem. It supports standard interfaces such as Python and OpenQASM 3, making advanced fault-tolerance verification accessible to both quantum researchers and compiler developers. In this submission, we provide an overview of the formal verification method, describe the architecture of ucc-ft, and demonstrate its utility in verifying an example circuit.

Abstract: We introduce Unitary Compiler Collection (UCC), an open-source Python package for front-end-agnostic, high-performance compilation of quantum circuits. UCC's goal is to gather the best of open-source compilation to make quantum programming simpler, faster, and more scalable. As quantum hardware advances, so does the complexity of programming it: increasing qubit counts, diverse gate operations, and varied architectures all present new challenges for quantum compilation. Two major challenges that we see are (1) compiler improvements are often isolated in separate libraries or unmaintained repositories without integration into existing tools, and (2) there are high switching costs between quantum computing frameworks and hardware platforms for both compiler developers and users. To address these, Unitary Foundation has developed UCC with an architecture and contribution framework to foster collaboration and enable the most performant tools of quantum and classical compilation to work together.

Abstract: This contribution presents Graphix, an open-source software library written in Python for measurement-quantum computation (MBQC).

MBQC is an important computational model that has not been as thoroughly investigated as the circuit model which provides complementary insights and new handles on algorithm design. In this model, a quantum computation (a pattern) is executed by starting from an initial resource state and applying adaptive single-qubit measurements where adaptivity and Pauli corrections are required to compensate the randomness of quantum measurements.

The Graphix library contains tools to transpile from quantum circuits, analyse graphical properties known as flow conditions, transpile to and from ZX diagrams, manipulate the patterns (standardisation, Pauli measurements presimulation) and to simulate patterns on our internal backends (statevector, density matrix and tensor network). Moreover, an expressive noise model interface has been implemented for the density matrix backend allowing the design of custom MBQC-native noise models.

The talk will highlight the theoretical foundations of the software, its core features as well as the general direction for future developments. Emphasis will be put on the transpilation between the different languages related to MBQC (circuits, patterns, open graphs and ZX diagrams) and the ongoing efforts to develop applications (variational algorithms, verification of quantum computation) and to interface the library with QPU providers' SDKs and hardware.

Abstract: Decomposing unitary operations into native gates is an essential step for implementing quantum algorithms. For qubit-based devices, where native gates are typically single- and two-qubit operations, a range of decomposition techniques have been developed. In particular, efficient algorithms exist for decomposing exponentials of Pauli strings while taking hardware topology in account. Motivated by the growing interest in qutrit-based quantum computing, we develop analogous decomposition methods for qutrit systems. Specifically, we introduce an algorithm that decomposes the exponential of an arbitrary tensor product of Weyl-Heisenberg operators (plus their Hermitian conjugation) into single- and two-qutrit gates. We further extend this approach to unitaries generated by Gell-Mann string (i.e., a tensor product of Gell-Mann matrices). Since both Gell-Mann matrices and Weyl-Heisenberg operators form (together with identity) complete operator bases of qutrit operators, we can use this result also to decompose any multi-qutrit gate that is diagonal up to single-qutrit rotations.

As a practical application, we use our method to decompose the layers of the quantum approximate optimization algorithm for qutrit-based implementations of the graph k-coloring problem. For values of k well-suited to qutrit architectures (e.g., k=3 or in general k=3^n), our approach yields significantly shallower circuits compared to qubit-based implementations, an advantage that grows with problem size, while also requiring a smaller total Hilbert space dimension. Finally, we also address the routing challenge in qutrit architectures that arises due to the limited connectivity of the devices. In particular, we generalize the Steiner-Gauss method, originally developed to reduce CNOT counts in qubit circuit, to optimize gate routing in qutrit-based systems.

Abstract: Fault-tolerant state preparation is essential for reliable quantum error correction, particularly in Steane-type error correction, which relies on robust ancilla states for syndrome readout. One way of fault-tolerant state preparation is to initialize multiple ancilla states and check them against each other to detect problematic errors. In the worst case, the number of states required for a successful initialization grows polynomially with respect to the distance of the code, but it has been shown that this can be reduced to constant ancilla overhead—in the best case, only four states are required. However, existing techniques are limited to codes with large symmetric groups like the Golay code. In this work, we propose a general, automated synthesis methodology for Steane-type fault-tolerant state preparation circuit synthesis that applies to arbitrary Calderbank-Shor-Steane (CSS) codes and does not rely on symmetries in the code. We apply the proposed methods to various CSS d = 5 and d = 7 codes and demonstrate successful fault-tolerant initialization of logical basis states under circuit-level depolarizing noise. The circuits synthesized using the proposed methodology provide an important step towards experimental realizations of high-fidelity ancilla states for near-term demonstration of fault-tolerant quantum computation.

Abstract: Decoded Quantum Interferometry (DQI) is a quantum algorithm for reducing classical optimization problems to classical decoding problems by exploiting structure in the Fourier spectrum of the objective function. When applied to the Optimal Polynomial Intersection (OPI) problem, this framework requires the decoding of Reed-Solomon codes. The most computationally dominant part of the algorithm is running a classical decoding algorithm as a reversible quantum circuit, which is the main focus of our work.

This work provides the first end-to-end resource estimates for solving classically intractable instances of the OPI problem using DQI. We introduce significant compilation improvements, including adapting the problem to binary extension fields to leverage optimized arithmetic and developing a new, qubit-efficient compilation for the Extended Euclidean Algorithm (EEA), which we belive will be useful in cryptographic applications beyond DQI.

Our analysis shows that an OPI instance, estimated to require over 10²³ classical trials, can be solved with approximately 1600 logical qubits and 33 million Toffoli gates. These results provide a concrete roadmap and a realistic assessment of the resources required to achieve quantum advantage on a structured optimization problem.

Abstract: We introduce a low-overhead approach for detecting errors in arbitrary Clifford circuits on arbitrary qubit connectivities. Our method is based on the framework of spacetime codes, and is particularly suited to near-term hardware since it has a much milder overhead in qubits and gates compared to error correction, while achieving a better sampling overhead than existing error mitigation methods. We present efficient algorithms for finding valid checks that are simultaneously low weight, satisfy connectivity constraints, and cover large detecting regions within the circuit. Using this approach, we experimentally demonstrate error detection on circuits of up to 50 logical qubits containing 2450 CZ gates, and show physical to logical fidelity gains of up to 236×. Furthermore, we show our algorithm can efficiently find checks in universal circuits, but the space of valid checks diminishes exponentially with the non-Cliffordness of the circuit. These theoretical and experimental results suggest that Clifford-dominated circuits are promising candidates for near-term quantum advantage.