Automated Circuit Depth Reduction of Quantum Subroutines via Compilation

Folkert de Ronde; Sebastian Feld; Stephan Wong

arxiv: 2605.04748 · v1 · submitted 2026-05-06 · 🪐 quant-ph

Automated Circuit Depth Reduction of Quantum Subroutines via Compilation

Folkert de Ronde , Stephan Wong , Sebastian Feld This is my paper

Pith reviewed 2026-05-08 17:19 UTC · model grok-4.3

classification 🪐 quant-ph

keywords quantum circuitscircuit depthGHZ statesCNOT chainsquantum compilationdepth reductionquantum algorithmsgate count trade-off

0 comments

The pith

A compiler can automatically replace linear-depth GHZ and CNOT subroutines with constant- or logarithmic-depth versions.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper establishes that quantum compilers can scan circuits for GHZ state creation and CNOT or CZ chains, then swap in shallower implementations. Constant-depth methods handle GHZ preparation and CZ decomposition while recursive decomposition brings CNOT chains to logarithmic depth. These changes increase parallelism and cut total circuit depth in the algorithms that contain the subroutines. The result is shorter execution time on hardware limited by coherence, at the cost of higher gate counts. Readers care because depth is often the binding constraint on what quantum algorithms can finish before noise dominates.

Core claim

By automatically detecting GHZ state creation and CNOT/CZ chain subroutines, the compiler applies constant-depth GHZ creation, constant-depth CZ chain decomposition, and logarithmic-depth recursive CNOT chain decomposition. These replacements reduce circuit depth and enable greater parallelism, as shown by performance measurements on benchmark algorithms, although the gate count rises and doubles for the CNOT case.

What carries the argument

Compiler-driven detection and replacement of GHZ state creation, CZ chains, and CNOT chains using constant-depth and recursive logarithmic-depth constructions.

If this is right

Algorithms that rely on these subroutines finish with lower depth and therefore shorter run time.
Linear scaling of depth with system size for chains and GHZ states is replaced by constant or logarithmic scaling.
The method introduces a deliberate trade-off of more gates for less depth.
Benchmarked algorithms exhibit measurable depth reductions after the transformations are applied.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

The same detection approach could be extended to other chain-like or entanglement-spreading patterns that appear in larger algorithms.
On hardware where coherence time is the main limit, the shallower circuits may allow more complex instances to complete successfully.
Programmers would no longer need to hand-optimize these common patterns once the compiler handles detection reliably.

Load-bearing premise

The compiler can correctly identify the target subroutines inside any quantum algorithm without missing cases or applying the wrong transformations.

What would settle it

Run the compiler on a known algorithm that contains explicit GHZ states or long CNOT chains, then measure whether the emitted circuit depth matches the claimed constant or logarithmic scaling and whether gate count increases as stated.

Figures

Figures reproduced from arXiv: 2605.04748 by Folkert de Ronde, Sebastian Feld, Stephan Wong.

**Figure 1.** Figure 1: Circuit representation of a standard GHZ state view at source ↗

**Figure 2.** Figure 2: Circuit representation of an improved GHZ state view at source ↗

**Figure 3.** Figure 3: Circuit representation of an improved GHZ state view at source ↗

**Figure 4.** Figure 4: (a) Circuit representation of a standard forward CNOT chain, exhibiting linear depth in the number of involved view at source ↗

**Figure 5.** Figure 5: (a) Circuit representation of a standard reversed CNOT chain, exhibiting linear depth in the number of qubits. (b) view at source ↗

**Figure 6.** Figure 6: (a) Circuit representation of a standard CZ chain. The solution shows linear depth in the number of involved qubits. view at source ↗

**Figure 7.** Figure 7: A CNOT chain with additional regions identified for view at source ↗

**Figure 9.** Figure 9: A flowchart describing the functionality of the detection algorithm. The algorithm is capable of detecting view at source ↗

**Figure 10.** Figure 10: The impact of different GHZ state algorithms are illustrated. (a) Circuit depth: the original approach scales linearly, view at source ↗

**Figure 11.** Figure 11: The theoretical potential of chain optimization is illustrated. (a) Circuit depth comparison for three versions: the old view at source ↗

**Figure 12.** Figure 12: The graph compares benchmark circuit depths view at source ↗

**Figure 13.** Figure 13: The plot shows VQEs that improved using our compiler, depicting the relative change in circuit depth before and view at source ↗

**Figure 14.** Figure 14: The plot shows VQEs that improved using our compiler, depicting the relative depth change before and after view at source ↗

read the original abstract

Optimizing quantum circuits by reducing circuit depth is essential for improving the efficiency and scalability of quantum algorithms, particularly as quantum hardware continues to evolve. This can be achieved by restructuring quantum algorithms to allow more parallelism. A compiler is needed to automatically detect and apply these optimizations. In this work, we focus on the optimization of two fundamental quantum subroutines: GHZ state creation and CNOT/CZ chain decomposition. Traditional implementations of these subroutines suffer from linearly increasing circuit depth, which limits scalability. We propose a compiler-driven approach that automatically detects and optimizes these two fundamental quantum subroutines. Our approach reduces circuit depth through constant-depth GHZ state creation, constant depth CZ chain decomposition, and logarithmic depth recursive CNOT chain decomposition, which enhance parallel execution. Performance analysis of benchmarked algorithms shows significant reductions in depth. However, our solution also results in an increased gate count, which makes our optimization a trade-off. The gate count for the CNOT chains is doubled, where logarithmic depth reduction is achieved. The reduced circuit depth results in more efficient algorithms by reducing execution time.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

This paper sketches an automated compiler for depth-optimized GHZ and CNOT/CZ subroutines, but the absence of benchmarks and implementation details leaves the central claims untested.

read the letter

The main takeaway is that the authors describe a compiler meant to spot GHZ preparation and CNOT or CZ chains inside larger circuits and replace them with lower-depth versions. They use constant-depth rewrites for GHZ and CZ plus a recursive logarithmic-depth version for CNOT chains, and they note the expected trade-off of higher gate counts. That framing is straightforward and addresses a known practical limit on current hardware. The automation angle is the part that could matter if it actually works at scale without manual intervention. The paper does a decent job of naming the subroutines and the depth problem they create, and it is honest about the gate-count increase. Those are the pieces that feel grounded. The soft spots are more substantial. The abstract claims that benchmarked algorithms show significant depth reductions, yet no numbers, no list of the algorithms, and no before-and-after circuit metrics appear. There is also no description of the detection method, no check that the rewrites preserve semantics, and no discussion of false positives or missed patterns in non-standard implementations. Without those elements the automation claim stays at the level of an idea rather than a demonstrated result. This kind of work would interest people building quantum compilers or trying to squeeze more out of NISQ devices. A reader already familiar with the depth-reduction tricks could pick up the high-level strategy, but anyone wanting reproducible techniques or verified savings would come away wanting more. It deserves a serious referee because the target problem is real and the direction is reasonable, though the manuscript would need concrete data, correctness arguments, and implementation specifics before it could be published.

Referee Report

3 major / 0 minor

Summary. The paper proposes a compiler-driven approach to automatically detect GHZ state creation and CNOT/CZ chain subroutines in quantum circuits and rewrite them using constant-depth GHZ and CZ decompositions plus logarithmic-depth recursive CNOT chains, claiming this yields significant depth reductions (at the cost of increased gate count) in benchmarked algorithms.

Significance. If the detection mechanism proves reliable and the rewrites are semantics-preserving, the work could provide a practical tool for depth optimization on hardware where latency matters, highlighting a depth-versus-gate-count trade-off. The absence of any quantitative benchmarks, detection algorithm details, or equivalence checks, however, leaves the claimed improvements unsupported and reduces the result's current significance.

major comments (3)

[Abstract] Abstract: the statement that 'performance analysis of benchmarked algorithms shows significant reductions in depth' is unsupported; no tables, figures, numerical values, or specific circuits are provided to quantify the depth savings or gate-count overhead.
[Compiler-driven approach] Compiler-driven approach (throughout): no description is given of the automatic detection method (pattern matching, graph rewriting, AST traversal, etc.), which is load-bearing for the central automation claim; without it, false-positive/negative rates, missed opportunities, and semantic preservation cannot be assessed.
[Optimization techniques] Optimization techniques: the constant-depth GHZ/CZ and log-depth CNOT rewrites are asserted to enhance parallelism, yet no verification, equivalence proof, or simulation results are supplied to confirm the transformed circuits compute the same function as the originals.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for the detailed and constructive report. We agree that the current manuscript lacks sufficient detail on the detection mechanism, supporting benchmarks, and verification of the rewrites. We will revise the paper to address these points directly while preserving the core contribution on depth-versus-gate-count trade-offs for the identified subroutines.

read point-by-point responses

Referee: [Abstract] Abstract: the statement that 'performance analysis of benchmarked algorithms shows significant reductions in depth' is unsupported; no tables, figures, numerical values, or specific circuits are provided to quantify the depth savings or gate-count overhead.

Authors: The referee correctly identifies that the abstract claim is not backed by data in the submitted version. In the revision we will add a dedicated results section with concrete benchmarks on representative circuits (including GHZ preparation, CNOT ladders, and CZ chains), reporting numerical depth reductions, gate-count overheads, and before/after comparisons in both tables and figures. revision: yes
Referee: [Compiler-driven approach] Compiler-driven approach (throughout): no description is given of the automatic detection method (pattern matching, graph rewriting, AST traversal, etc.), which is load-bearing for the central automation claim; without it, false-positive/negative rates, missed opportunities, and semantic preservation cannot be assessed.

Authors: We acknowledge the absence of any description of the detection procedure. The revised manuscript will include a new subsection detailing the pattern-matching rules (based on circuit DAG traversal for GHZ and chain structures), the decision criteria for applying each rewrite, and a brief discussion of how the transformations are designed to be semantics-preserving. revision: yes
Referee: [Optimization techniques] Optimization techniques: the constant-depth GHZ/CZ and log-depth CNOT rewrites are asserted to enhance parallelism, yet no verification, equivalence proof, or simulation results are supplied to confirm the transformed circuits compute the same function as the originals.

Authors: The referee is right that no equivalence verification is provided. We will augment the optimization section with (i) a short inductive argument establishing functional equivalence for the constant-depth GHZ and CZ rewrites and (ii) explicit simulation results on small instances confirming that the logarithmic-depth CNOT recursion produces identical output states to the linear-depth baseline. revision: yes

Circularity Check

0 steps flagged

No circularity: optimizations are direct algorithmic rewrites with no self-referential derivations

full rationale

The paper presents a compiler-based method for detecting and rewriting specific quantum subroutines (GHZ creation, CNOT/CZ chains) into lower-depth forms. These are described as explicit transformations (constant-depth GHZ, constant-depth CZ, log-depth recursive CNOT) applied via automatic detection. No equations, fitted parameters, or predictions are involved that reduce to the inputs by construction. No self-citations are used as load-bearing uniqueness theorems or ansatzes. The derivation chain consists of standard pattern-based rewrites whose correctness is independent of the paper's own results, making the work self-contained against external benchmarks.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 0 invented entities

The approach rests on standard assumptions of quantum circuit equivalence and the ability of a compiler to pattern-match subcircuits; no free parameters or new entities are introduced in the abstract.

axioms (1)

domain assumption Quantum circuit rewrites that preserve the overall unitary operation are valid optimizations.
Implicit in all depth-reduction claims.

pith-pipeline@v0.9.0 · 5482 in / 1180 out tokens · 48900 ms · 2026-05-08T17:19:40.894546+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

24 extracted references · 4 canonical work pages

[1]

Going beyond bell’s theorem,

D. M. Greenbergeret al., “Going beyond bell’s theorem,”Bell’s theorem, quantum theory and conceptions of the universe, pp. 69–72, 1989

1989
[2]

K.et al.Quantum algorithms for electronic structure calculations: Particle-hole hamiltonian and optimized wave-function expansions.Phys

P. K. Barkoutsoset al., “Quantum algorithms for electronic structure calculations: Particle-hole hamiltonian and optimized wave-function expansions,”Phys. Rev. A, vol. 98, p. 022322, Aug 2018. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevA.98.022322

work page doi:10.1103/physreva.98.022322 2018
[3]

Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classical algorithms,

S. Simet al., “Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classical algorithms,”Advanced Quantum Technologies, vol. 2, no. 12, p. 1900070, 2019

2019
[4]

Distributed quantum com- puting: A distributed shor algorithm,

A. Yimsiriwattana and S. J. Lomonaco Jr, “Distributed quantum com- puting: A distributed shor algorithm,” inQuantum information and computation II, vol. 5436. SPIE, 2004, pp. 360–372

2004
[5]

Quantum neural networks force fields generation,

O. Kisset al., “Quantum neural networks force fields generation,” Machine Learning: Science and Technology, vol. 3, no. 3, p. 035004, jul
[6]

Available: https://dx.doi.org/10.1088/2632-2153/ac7d3c

[Online]. Available: https://dx.doi.org/10.1088/2632-2153/ac7d3c

work page doi:10.1088/2632-2153/ac7d3c
[7]

Automated error correction in ibm quantum computer and explicit generalization,

D. Ghoshet al., “Automated error correction in ibm quantum computer and explicit generalization,”Quantum Information Processing, vol. 17, no. 6, p. 153, 2018

2018
[8]

Solving graph problems using permutation- invariant quantum machine learning,

M. B. Manskyet al., “Solving graph problems using permutation- invariant quantum machine learning,” in2025 IEEE International Con- ference on Quantum Computing and Engineering (QCE), vol. 1. IEEE, 2025, pp. 1611–1620. 10 Algorithm 2DetectAndDecomposeChains: CX/CZ Chain De- tection Require:List of quantum instructionsL 1:i←0 2:whilei <length(L)do 3:l i ←L[...

2025
[9]

A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits,

M. Amyet al., “A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 32, no. 6, pp. 818–830, 2013

2013
[10]

Optimal layout-aware cnot circuit synthesis with qubit permutation,

I. Shaik and J. van de Pol, “Optimal layout-aware cnot circuit synthesis with qubit permutation,”arXiv preprint arXiv:2408.04349, 2024

work page arXiv 2024
[11]

Nearest neighbor synthesis of cnot circuits on general quantum architectures,

X. Chenet al., “Nearest neighbor synthesis of cnot circuits on general quantum architectures,”arXiv preprint arXiv:2310.00592, 2023

work page arXiv 2023
[12]

Quantum circuits of cnot gates: optimization and entangle- ment,

M. Bataille, “Quantum circuits of cnot gates: optimization and entangle- ment,”Quantum Information Processing, vol. 21, no. 7, p. 269, 2022

2022
[13]

Efficient quantum circuit compilation for near- term quantum advantage,

Y . Guo and S. Yang, “Efficient quantum circuit compilation for near- term quantum advantage,”EPJ Quantum Technology, vol. 12, no. 1, p. 69, 2025

2025
[14]

M. A. Nielsen and I. L. Chuang,Quantum Computation and Quantum Information. Cambridge University Press, 2010

2010
[15]

Efficient quantum algorithms for ghz and w states, and implementation on the ibm quantum computer,

D. Cruzet al., “Efficient quantum algorithms for ghz and w states, and implementation on the ibm quantum computer,”Advanced Quantum Technologies, vol. 2, no. 5-6, p. 1900015, 2019

2019
[16]

Generation and verification of 27-qubit greenberger-horne-zeilinger states in a superconducting quantum com- puter,

G. J. Mooneyet al., “Generation and verification of 27-qubit greenberger-horne-zeilinger states in a superconducting quantum com- puter,”Journal of Physics Communications, vol. 5, no. 9, p. 095004, 2021

2021
[17]

Multivariate trace estimation in constant quantum depth,

Y . Queket al., “Multivariate trace estimation in constant quantum depth,”Quantum, vol. 8, p. 1220, 2024

2024
[18]

Quantum computing with Qiskit,

A. Javadi-Abhariet al., “Quantum computing with Qiskit,” 2024

2024
[19]

t—ket〉: a retargetable compiler for nisq devices,

S. Sivarajahet al., “t—ket〉: a retargetable compiler for nisq devices,” Quantum Science and Technology, vol. 6, no. 1, p. 014003, 2020

2020
[20]

Practical resource estimation for quantum many- body simulations,

R. S. Smithet al., “Practical resource estimation for quantum many- body simulations,”npj Quantum Information, vol. 2, no. 1, p. 16006, 2016

2016
[21]

An efficient methodology for mapping quantum circuits to the ibm qx architectures,

A. Zulehner and R. Wille, “An efficient methodology for mapping quantum circuits to the ibm qx architectures,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 38, no. 7, pp. 1226–1236, 2019

2019
[22]

Polynomial-time t-depth optimization of clifford+t circuits via matroid partitioning,

M. Amyet al., “Polynomial-time t-depth optimization of clifford+t circuits via matroid partitioning,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 33, no. 10, pp. 1476– 1489, 2014

2014
[23]

Automated optimization of large quantum circuits with continuous parameters,

Y . Namet al., “Automated optimization of large quantum circuits with continuous parameters,” inProceedings of the 24th International Conference on Architectural Support for Programming Languages and Operating Systems, 2018

2018
[24]

Ancilla-free quantum adder with sub- linear depth,

M. Remaud and V . Vandaele, “Ancilla-free quantum adder with sub- linear depth,” inInternational Conference on Reversible Computation. Springer, 2025, pp. 137–154. 11

2025

[1] [1]

Going beyond bell’s theorem,

D. M. Greenbergeret al., “Going beyond bell’s theorem,”Bell’s theorem, quantum theory and conceptions of the universe, pp. 69–72, 1989

1989

[2] [2]

K.et al.Quantum algorithms for electronic structure calculations: Particle-hole hamiltonian and optimized wave-function expansions.Phys

P. K. Barkoutsoset al., “Quantum algorithms for electronic structure calculations: Particle-hole hamiltonian and optimized wave-function expansions,”Phys. Rev. A, vol. 98, p. 022322, Aug 2018. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevA.98.022322

work page doi:10.1103/physreva.98.022322 2018

[3] [3]

Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classical algorithms,

S. Simet al., “Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classical algorithms,”Advanced Quantum Technologies, vol. 2, no. 12, p. 1900070, 2019

2019

[4] [4]

Distributed quantum com- puting: A distributed shor algorithm,

A. Yimsiriwattana and S. J. Lomonaco Jr, “Distributed quantum com- puting: A distributed shor algorithm,” inQuantum information and computation II, vol. 5436. SPIE, 2004, pp. 360–372

2004

[5] [5]

Quantum neural networks force fields generation,

O. Kisset al., “Quantum neural networks force fields generation,” Machine Learning: Science and Technology, vol. 3, no. 3, p. 035004, jul

[6] [6]

Available: https://dx.doi.org/10.1088/2632-2153/ac7d3c

[Online]. Available: https://dx.doi.org/10.1088/2632-2153/ac7d3c

work page doi:10.1088/2632-2153/ac7d3c

[7] [7]

Automated error correction in ibm quantum computer and explicit generalization,

D. Ghoshet al., “Automated error correction in ibm quantum computer and explicit generalization,”Quantum Information Processing, vol. 17, no. 6, p. 153, 2018

2018

[8] [8]

Solving graph problems using permutation- invariant quantum machine learning,

M. B. Manskyet al., “Solving graph problems using permutation- invariant quantum machine learning,” in2025 IEEE International Con- ference on Quantum Computing and Engineering (QCE), vol. 1. IEEE, 2025, pp. 1611–1620. 10 Algorithm 2DetectAndDecomposeChains: CX/CZ Chain De- tection Require:List of quantum instructionsL 1:i←0 2:whilei <length(L)do 3:l i ←L[...

2025

[9] [9]

A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits,

M. Amyet al., “A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 32, no. 6, pp. 818–830, 2013

2013

[10] [10]

Optimal layout-aware cnot circuit synthesis with qubit permutation,

I. Shaik and J. van de Pol, “Optimal layout-aware cnot circuit synthesis with qubit permutation,”arXiv preprint arXiv:2408.04349, 2024

work page arXiv 2024

[11] [11]

Nearest neighbor synthesis of cnot circuits on general quantum architectures,

X. Chenet al., “Nearest neighbor synthesis of cnot circuits on general quantum architectures,”arXiv preprint arXiv:2310.00592, 2023

work page arXiv 2023

[12] [12]

Quantum circuits of cnot gates: optimization and entangle- ment,

M. Bataille, “Quantum circuits of cnot gates: optimization and entangle- ment,”Quantum Information Processing, vol. 21, no. 7, p. 269, 2022

2022

[13] [13]

Efficient quantum circuit compilation for near- term quantum advantage,

Y . Guo and S. Yang, “Efficient quantum circuit compilation for near- term quantum advantage,”EPJ Quantum Technology, vol. 12, no. 1, p. 69, 2025

2025

[14] [14]

M. A. Nielsen and I. L. Chuang,Quantum Computation and Quantum Information. Cambridge University Press, 2010

2010

[15] [15]

Efficient quantum algorithms for ghz and w states, and implementation on the ibm quantum computer,

D. Cruzet al., “Efficient quantum algorithms for ghz and w states, and implementation on the ibm quantum computer,”Advanced Quantum Technologies, vol. 2, no. 5-6, p. 1900015, 2019

2019

[16] [16]

Generation and verification of 27-qubit greenberger-horne-zeilinger states in a superconducting quantum com- puter,

G. J. Mooneyet al., “Generation and verification of 27-qubit greenberger-horne-zeilinger states in a superconducting quantum com- puter,”Journal of Physics Communications, vol. 5, no. 9, p. 095004, 2021

2021

[17] [17]

Multivariate trace estimation in constant quantum depth,

Y . Queket al., “Multivariate trace estimation in constant quantum depth,”Quantum, vol. 8, p. 1220, 2024

2024

[18] [18]

Quantum computing with Qiskit,

A. Javadi-Abhariet al., “Quantum computing with Qiskit,” 2024

2024

[19] [19]

t—ket〉: a retargetable compiler for nisq devices,

S. Sivarajahet al., “t—ket〉: a retargetable compiler for nisq devices,” Quantum Science and Technology, vol. 6, no. 1, p. 014003, 2020

2020

[20] [20]

Practical resource estimation for quantum many- body simulations,

R. S. Smithet al., “Practical resource estimation for quantum many- body simulations,”npj Quantum Information, vol. 2, no. 1, p. 16006, 2016

2016

[21] [21]

An efficient methodology for mapping quantum circuits to the ibm qx architectures,

A. Zulehner and R. Wille, “An efficient methodology for mapping quantum circuits to the ibm qx architectures,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 38, no. 7, pp. 1226–1236, 2019

2019

[22] [22]

Polynomial-time t-depth optimization of clifford+t circuits via matroid partitioning,

M. Amyet al., “Polynomial-time t-depth optimization of clifford+t circuits via matroid partitioning,”IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 33, no. 10, pp. 1476– 1489, 2014

2014

[23] [23]

Automated optimization of large quantum circuits with continuous parameters,

Y . Namet al., “Automated optimization of large quantum circuits with continuous parameters,” inProceedings of the 24th International Conference on Architectural Support for Programming Languages and Operating Systems, 2018

2018

[24] [24]

Ancilla-free quantum adder with sub- linear depth,

M. Remaud and V . Vandaele, “Ancilla-free quantum adder with sub- linear depth,” inInternational Conference on Reversible Computation. Springer, 2025, pp. 137–154. 11

2025