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

Quantum comparator circuit on superconducting quantum computer

Naphan Benchasattabuse

Published Jan 1, 2019• 1 citation
Publisher

Abstract

In this thesis, we present an optimised quantum comparator circuit based on Cuccaro's ripple-carry quantum adder using relative phase techniques from Maslov's multiple control Toffoli optimisation. We extend the cost function from simply counting C-Not and Toffoli gate to Qiskit cost which defines arbitrary single qubit gate cost as unity and C-Not as the only two qubit gate cost as ten. We report the comparison result between our comparator circuit with previous comparator circuits from literature using optimal Toffoli implementation with Qiskit cost, C-Not count, and circuit depth. We also report our experiment of implementing a two-bit comparator on IBM QX devices.

DOI
10.58837/chula.the.2019.156

Related papers

Optimizing T and CNOT Gates in Quantum Ripple-Carry Adders and Comparators

Maxime Remaud

The state of the art of quantum circuits using the ripple-carry strategy for the addition and comparison of two n-bit numbers is presented, as well as optimizations in the Clifford+ <?TeX $\mathsf {T}$?> Math 1 gate set, both in terms of <?TeX $\mathsf {CNOT}$?> Math 2 -depth and <?TeX $\mathsf {T}$?> Math 3 -depth, or <?TeX $\mathsf {CNOT}$?> Math 4 -count and <?TeX $\mathsf {T}$?> Math 5 -count. In particular, we consider the adders presented by Cuccaro et al. and Takahashi et al., and exhibit an adder with a <?TeX $\mathsf {T}$?> Math 6 -depth of 3n and a <?TeX $\mathsf {CNOT}$?> Math 7 -depth of 8n, while without optimization of the original circuits, a <?TeX $\mathsf {T}$?> Math 8 -depth of 6n is expected. Note that we have focused here on quantum ripple-carry adders using at most one ancilla, without any approximation of the 3-qubit gates involved (Toffoli, Peres and TR) or any strategy involving a measurement.

arXiv:2401.17921•Jun 19, 2024•4 citations

Asymptotically Optimal Quantum Circuits for Comparators and Incrementers

Vivien Vandaele

We present quantum circuits for comparison and increment operations that achieve an asymptotically optimal gate count of $Θ(n)$ and depth of $Θ(\log n)$ over the Clifford+Toffoli gate set, while using a provably minimal number of qubits. 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 $\mathcal{O}(n^3)$ to $\mathcal{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.

quant-pharXiv:2603.12917•Mar 16, 2026•9 citations

Optimization of Ripple Carry Adder using Quantum Computing

N.Parvatham, Rithiga R, Ruzmina M +1 more

This paper presents the design, optimization, and simulation of arithmetic circuits using reversible logic for quantum computing applications. The motivation behind this work is to achieve resource-efficient computation through reduced quantum cost, minimized garbage outputs, and lower ancilla requirements. The methodology involves implementing Half Adders, Full Adders, Multiplexers, and Ripple Carry Adders (RCAs) using Toffoli and Peres gates. The proposed 8-bit RCA achieves a quantum cost of 58 using 24 qubits, 8 garbage outputs, and 6 ancilla inputs—showing a significant improvement over conventional Toffoli-based designs that require higher quantum cost and resources. Simulations were conducted on IBM Qiskit and Google Colab using the Qiskit SDK to validate circuit correctness and scalability. The obtained results demonstrate superior resource efficiency and confirm the feasibility of reversible-logic-based quantum arithmetic as a foundation for scalable quantum arithmetic logic units (ALUs) and processors.

International Conference on Ubiquitous Computing and Intelligent Information Systems (ICUIS)•Nov 26, 2025•0 citations

Design and Evaluation of Low-Depth Approximate Quantum Computing

Taegyun Kim, Jungu Kang, Yeongkyo Seo

Approximate quantum adders are gaining traction in NISQ-era computing for their potential to reduce quantum resource usage while preserving computational accuracy. In this work, we evaluate two 8-qubit hybrid approximate quantum adders that combine a 2-qubit approximate block, either a pass-through Copy Adder or a CNOT-based design, with a 6-qubit Cuccaro ripple-carry adder. Simulations are conducted using IBM's Qiskit framework under realistic noise models, including bit-flip, depolarizing, and thermal noise. Compared to the exact 8-bit Cuccaro adder, our designs reduce quantum cost and circuit depth by over 20 percent and achieve up to 79.3 percent higher output probability under noisy conditions. These results highlight the robustness and efficiency of approximate logic in noisy quantum environments and confirm its practicality for near-term quantum hardware.

International SoC Design Conference•Oct 15, 2025•0 citations

An Efficient Approximate Toffoli-Based Quantum Adder for Low-Power and High-Performance Applications

B N Lavanya, K. Rasadurai

The basic components of both quantum and quantum-inspired arithmetic systems are quantum adders. Traditional direct quantum adders like the Vedral and Cuccaro ripple-carry adders provide accurate computation but have higher circuit depth, longer propagation delay and complexity of hardware implementation based upon extensive usage of Toffoli gates. This article brings about a comparison analysis of the current quantum adder designs, and it suggests an Approximate Toffoli Adder in order to enhance performance and hardware efficiency. The suggested design is designed with the help of Verilog HDL and run with Xilinx Vivado 2025.2. As can be seen from experimental results, the Vedral and Cuccaro adders have a critical path delay of 7.999 ns and 7.979 ns, respectively, and the total on-chip power consumption of 2.945 W. Conversely, the Approximate Toffoli Adder proposed has a low critical path delay of 7.261 ns, lower power consumption of 2.442 W and less hardware consumption with 18 logic cells than the current designs with 20 logic cells. Analysis of errors ensures that there is a minimal difference in the accuracy of the output. It is proven that approximate arithmetic offers a successful trade-off between precision, speed, and power efficiency to use in quantum-inspired computing.

International Conference Trends Material Science and Inventive Materials•Apr 8, 2026•0 citations

Toffoli-porttien toteutuskustannuksien alentaminen approksimaatioilla

Simo Puttonen

The Toffoli gate (controlled-controlled-NOT) and its multi-controlled generalizations are fundamental logical building blocks of quantum algorithms and utilized extensively in pivotal algorithms such as Grover’s algorithm and Shor’s algorithm. Despite being a fundamental logical primitive of quantum algorithms, Toffoli gates must be decomposed to primitive single-qubit and two-qubit gates which are available in physical quantum hardware. These decompositions incur significant implementation costs in circuit depth and gate count, costs that propagate directly to the entire circuit. Consequently, reducing the implementation cots of Toffoli gates provides a direct method of reducing the implementation costs of many quantum algorithms. This thesis evaluates state-of-the-art methods for reducing the implementation costs of Toffoli gates by introducing approximations. While approximations introduce errors to the output of the Toffoli gate, they can reduce the depth and gate count of the implementation. This thesis finds that discrete errors in two-qubit and three-qubit controlled Toffoli gates have been utilized to reduce the gate counts in such a way that the implementation is exact cancelling the errors. Additionally, continuous errors are utilized to reduce the depth of a multi-controlled Toffoli gate decomposition in ancilla-free settings. However, this review also demonstrates other, non-approximate, construction of multi-controlled Toffoli gate, which achieves comparable implementation costs demonstrating marginal gains for the approximation techniques currently.

•Apr 24, 2026•0 citations
In this thesis, we present an optimised quantum comparator circuit based on Cuccaro's ripple-carry quantum adder using relative phase techniques from Maslov's multiple control Toffoli optimisation. We extend the cost function from simply counting C-Not and Toffoli gate to Qiskit cost which defines arbitrary single qubit gate cost as unity and C-Not as the only two qubit gate cost as ten. We report the comparison result between our comparator circuit with previous comparator circuits from literature using optimal Toffoli implementation with Qiskit cost, C-Not count, and circuit depth. We also report our experiment of implementing a two-bit comparator on IBM QX devices.
The state of the art of quantum circuits using the ripple-carry strategy for the addition and comparison of two n-bit numbers is presented, as well as optimizations in the Clifford+ <?TeX T\mathsf {T}T?> Math 1 gate set, both in terms of <?TeX CNOT\mathsf {CNOT}CNOT?> Math 2 -depth and <?TeX T\mathsf {T}T?> Math 3 -depth, or <?TeX CNOT\mathsf {CNOT}CNOT?> Math 4 -count and <?TeX T\mathsf {T}T?> Math 5 -count. In particular, we consider the adders presented by Cuccaro et al. and Takahashi et al., and exhibit an adder with a <?TeX T\mathsf {T}T?> Math 6 -depth of 3n and a <?TeX CNOT\mathsf {CNOT}CNOT?> Math 7 -depth of 8n, while without optimization of the original circuits, a <?TeX T\mathsf {T}T?> Math 8 -depth of 6n is expected. Note that we have focused here on quantum ripple-carry adders using at most one ancilla, without any approximation of the 3-qubit gates involved (Toffoli, Peres and TR) or any strategy involving a measurement.
We present quantum circuits for comparison and increment operations that achieve an asymptotically optimal gate count of Θ(n)Θ(n)Θ(n) and depth of Θ(log⁡n)Θ(\log n)Θ(logn) over the Clifford+Toffoli gate set, while using a provably minimal number of qubits. 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(n3)\mathcal{O}(n^3)O(n3) to O(n2log⁡2n)\mathcal{O}(n^2 \log^2 n)O(n2log2n) 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.
This paper presents the design, optimization, and simulation of arithmetic circuits using reversible logic for quantum computing applications. The motivation behind this work is to achieve resource-efficient computation through reduced quantum cost, minimized garbage outputs, and lower ancilla requirements. The methodology involves implementing Half Adders, Full Adders, Multiplexers, and Ripple Carry Adders (RCAs) using Toffoli and Peres gates. The proposed 8-bit RCA achieves a quantum cost of 58 using 24 qubits, 8 garbage outputs, and 6 ancilla inputs—showing a significant improvement over conventional Toffoli-based designs that require higher quantum cost and resources. Simulations were conducted on IBM Qiskit and Google Colab using the Qiskit SDK to validate circuit correctness and scalability. The obtained results demonstrate superior resource efficiency and confirm the feasibility of reversible-logic-based quantum arithmetic as a foundation for scalable quantum arithmetic logic units (ALUs) and processors.
Approximate quantum adders are gaining traction in NISQ-era computing for their potential to reduce quantum resource usage while preserving computational accuracy. In this work, we evaluate two 8-qubit hybrid approximate quantum adders that combine a 2-qubit approximate block, either a pass-through Copy Adder or a CNOT-based design, with a 6-qubit Cuccaro ripple-carry adder. Simulations are conducted using IBM's Qiskit framework under realistic noise models, including bit-flip, depolarizing, and thermal noise. Compared to the exact 8-bit Cuccaro adder, our designs reduce quantum cost and circuit depth by over 20 percent and achieve up to 79.3 percent higher output probability under noisy conditions. These results highlight the robustness and efficiency of approximate logic in noisy quantum environments and confirm its practicality for near-term quantum hardware.
The basic components of both quantum and quantum-inspired arithmetic systems are quantum adders. Traditional direct quantum adders like the Vedral and Cuccaro ripple-carry adders provide accurate computation but have higher circuit depth, longer propagation delay and complexity of hardware implementation based upon extensive usage of Toffoli gates. This article brings about a comparison analysis of the current quantum adder designs, and it suggests an Approximate Toffoli Adder in order to enhance performance and hardware efficiency. The suggested design is designed with the help of Verilog HDL and run with Xilinx Vivado 2025.2. As can be seen from experimental results, the Vedral and Cuccaro adders have a critical path delay of 7.999 ns and 7.979 ns, respectively, and the total on-chip power consumption of 2.945 W. Conversely, the Approximate Toffoli Adder proposed has a low critical path delay of 7.261 ns, lower power consumption of 2.442 W and less hardware consumption with 18 logic cells than the current designs with 20 logic cells. Analysis of errors ensures that there is a minimal difference in the accuracy of the output. It is proven that approximate arithmetic offers a successful trade-off between precision, speed, and power efficiency to use in quantum-inspired computing.
The Toffoli gate (controlled-controlled-NOT) and its multi-controlled generalizations are fundamental logical building blocks of quantum algorithms and utilized extensively in pivotal algorithms such as Grover’s algorithm and Shor’s algorithm. Despite being a fundamental logical primitive of quantum algorithms, Toffoli gates must be decomposed to primitive single-qubit and two-qubit gates which are available in physical quantum hardware. These decompositions incur significant implementation costs in circuit depth and gate count, costs that propagate directly to the entire circuit. Consequently, reducing the implementation cots of Toffoli gates provides a direct method of reducing the implementation costs of many quantum algorithms. This thesis evaluates state-of-the-art methods for reducing the implementation costs of Toffoli gates by introducing approximations. While approximations introduce errors to the output of the Toffoli gate, they can reduce the depth and gate count of the implementation. This thesis finds that discrete errors in two-qubit and three-qubit controlled Toffoli gates have been utilized to reduce the gate counts in such a way that the implementation is exact cancelling the errors. Additionally, continuous errors are utilized to reduce the depth of a multi-controlled Toffoli gate decomposition in ancilla-free settings. However, this review also demonstrates other, non-approximate, construction of multi-controlled Toffoli gate, which achieves comparable implementation costs demonstrating marginal gains for the approximation techniques currently.