Design Automation for Quantum Circuits

3D illustration of a quantum circuit layout, showing how wires connect qubits and how their positions affect circuit design.

Design Automation for Quantum Circuits (DAQC) refers to the use of specialized software tools to help turn high-level quantum algorithms into working instructions that can be used on real quantum computers.[1] This automation process is essential because quantum computers work in a very different way than classical ones: they use qubits which can be in multiple states at once, and are easily affected by noise.[2] Additionally, DAQC means using software to make quantum computing hardware and applications easier to develop. It turns high-level quantum algorithms into optimized circuits for specific quantum systems. DAQC tools bridge the gap between abstract quantum algorithms and physical hardware implementations, enabling efficient use of noisy intermediate-scale quantum (NISQ) devices and fault-tolerant architectures.[3] Unlike classical circuit design, which has well-developed tools, quantum design automation is still new and challenging. One of the reasons is because quantum bits (qubits) behave differently. They are sensitive to noise, have limited connections, and use reversible logic. These issues require special methods for breaking down gates, reducing errors, mapping circuits, and simulating them. As quantum processors grow and change, automated design is crucial to ensure they work well and correctly on different hardware.[4]

The automation process in quantum circuit design includes various stages such as algorithm specification, circuit synthesis, gate decomposition, qubit mapping, and noise-aware optimization.[5] These stages help transform abstract quantum algorithms into physical instructions that can run on real quantum devices, often constrained by specific topologies and hardware characteristics.[6]

As the quantum computing ecosystem matures, numerous software frameworks and toolchains have emerged to support this design process. Platforms like IBM's Qiskit, Google's Cirq, and the MQT Suite provide environments for simulating, optimizing, and compiling quantum circuits tailored to current quantum hardware. These tools play a critical role in making quantum computing more scalable, reproducible, and accessible to researchers and engineers.[7]

Design Automation and Quantum Circuits: An Overview

Inspired by the success of electronic design automation (EDA) in classical computing, DAQC adapts similar principles to meet the unique constraints of quantum mechanics, such as reversibility, unitarity, and qubit decoherence.[8]

As opposed to classical design flows, quantum design automation must account for the limited connectivity between qubits, error-prone operations, and non-universal native gate sets.[9] This introduces new stages in the compilation pipeline, such as technology mapping, qubit routing, and fault-tolerant gate synthesis, all of which require automated decision-making to scale to large quantum circuits.[10]

The DAQC workflow typically includes several stages: quantum algorithm specification, synthesis of gate-level descriptions, mapping to hardware-specific constraints, layout optimization, error mitigation, and formal verification.[11] Modern toolchains such as IBM's Qiskit, Google's Cirq, and Cambridge Quantum's t|ket⟩ - provide partial or complete automation across these phases, enabling researchers to focus on algorithm design rather than low-level circuit engineering. By automating these processes, DAQC not only improves design productivity but also enhances circuit efficiency and scalability, which are critical for near-term quantum devices operating under the Noisy Intermediate-Scale Quantum (NISQ) regime.[12]

Before diving deeper, it's helpful to understand what makes quantum circuits different from classical ones. Quantum circuits operate on qubits that exhibit superposition and entanglement, requiring unitary operations (quantum gates) that are reversible and noise-sensitive.[13] Compared to classical circuits, these properties necessitate automated design tools to manage decoherence, gate fidelity, and coupling maps - factors critical for compiling algorithms to physical hardware.[14] In quantum circuits, quantum gates are used to perform calculations. These gates change the qubits in a manner that can be reversed. These gates are shown using special mathematical tools called unitary matrices. They are used to create the quantum algorithms. Some common gates are the Hadamard gate, which helps to create superposition, and the CNOT gate, which helps to create entanglement. These gates work in steps and do not waste energy, unlike regular gates. They follow the rules of quantum mechanics.[15]

In classical logic circuits, signals and logic states are predictable. However, in quantum circuits, there is a need to carefully control physical systems, such as trapped ions, superconducting circuits, or light-based parts.[16] Quantum circuits are sensitive; therefore, they must be designed with limits on how long they can stay stable (decoherence time), how accurate the gates are (gate fidelity), and how qubits connect (coupling map). These factors greatly affect how accurately they work and their error rates[17]

There are two types of quantum circuit model. The logical layer is related to the ideal operations required for computing. The physical layer deals with the real hardware limits and layout. It needs qubit mapping and optimization to fit logical circuits to the available qubits and their interactions.[18]

Challenges in Quantum Circuit Design

Quantum circuit design faces unique obstacles absent in classical electronic design automation (EDA), primarily due to the fundamental properties of quantum mechanics and hardware limitations. These challenges include:

Decoherence and Noise Sensitivity

Qubits lose their quantum state rapidly due to quantum decoherence, limiting the maximum circuit depth before errors dominate. Gate operations are also imperfect, with typical fidelities ranging from 99% to 99.9% on modern hardware. Therefore, DAQC tools must optimize circuits within coherence time limits. Techniques include:

• Dynamic decoupling pulse insertion
• Noise-adaptive scheduling (e.g., prioritizing high-fidelity gates)[19][20] Error rates scale with circuit complexity, necessitating noise-aware compilation techniques.[21]

Non-Commutative Gate Operations

Unlike classical logic gates, quantum gates often do not commute, meaning the order of operations affects the final state. For example:$${\displaystyle H\cdot CNOT\neq CNOT\cdot H}$$This requires advanced optimization algorithms to identify gate cancellations or reorderings. However, DAQC has addressed this challenge by introducing automated gate sequencing tools to use:

• DAG-aware reordering
• Tensor network equivalence checking[22]

Qubit Connectivity Constraints

Most quantum hardware restricts interactions to adjacent qubits (e.g., superconducting chips) or requires SWAP gate insertion for distant interactions. This increases circuit depth and error rates.[23]

Need for Design Automation

Non-commutative gate sequences showing different outcomes for H·CNOT vs CNOT·H operations.[24]

Quantum design automation addresses three fundamental challenges absent in classical EDA:

1. Non-Commutative Gate Optimization

Quantum gates exhibit order-dependent effects due to non-commutativity:$${\displaystyle \|H\cdot CNOT-CNOT\cdot H\|\approx 0.82}$$where ${\displaystyle \|\cdot \|}$ denotes the operator norm. This requires:

• Tensor network verification of equivalent circuits
• DAG-aware scheduling tools
• Group-theoretic decomposition methods.[25]

2. Pulse-Level Control

DRAG pulse waveforms showing original (red) and optimized (blue) profiles.[26]

Modern quantum compilers must optimize:

• DRAG pulse parameters:

 ${\displaystyle \epsilon (t)=\Omega (t)+i{\frac {{\dot {\Omega }}(t)}{2\alpha }}}$
 where ${\displaystyle \alpha }$ is the anharmonicity

• Quantum crosstalk matrices:

 ${\displaystyle C_{ij}={\frac {g_{ij}}{\|\omega _{i}-\omega _{j}\|}}}$

• Nonlinearity corrections up to 3rd order.[27]

3. Cross-Platform Compilation

Hardware-Specific Compilation Challenges

Architecture	Key Constraint	Optimization Method	Typical Fidelity
Superconducting	Nearest-neighbor coupling	SWAP network synthesis	99.5% [20]
Trapped ion	Global Mølmer-Sørensen gates	Phase-space compression	99.9% [28]
Photonic	Probabilistic gates	Fusion network design	98.2% [29]

Data sources:[20][28][29]

Stages in the Design Automation Flow

Comparison between classical and quantum circuit design flows, illustrating differences in synthesis, mapping, and implementation stages.[30][31]

1. Algorithm Specification

The design process begins by creating a plan to solve a computer problem using quantum ideas. At this stage, the focus is on quantum operations and goals, rather than hardware. Some common quantum programming languages used are OpenQASM (for Qiskit), Quil (quantum instruction set) (by Rigetti), and Cirq's Python-based syntax. These languages help users to create quantum circuits with basic and complex gates, conditional quantum logic, and measurements. The aim is to create a logical circuit that works well and is efficient; however, it is not yet ready for hardware.[32][33]

2. Quantum Circuit Design

At this point, the main quantum algorithm is turned into a quantum circuit using gates from a universal set, such as Clifford+T. The logical parts are broken down into single- and two-qubit operations. Quantum compilers use rules to simplify circuits by reducing the depth and number of gates while maintaining their functionality. This step aims to create a clear and correct circuit that is ready for mapping and adapting to the hardware.[34] As circuits transition from logical design to physical implementation, hardware-specific constraints begin to influence the circuit layout. In particular, quantum processors differ in how qubits are interconnected. For instance, superconducting architectures like those used by IBM Quantum often follow a fixed grid pattern, where each qubit can only interact with adjacent neighbors. In contrast, ion-trap architectures, such as those developed by IonQ, allow for full connectivity between all qubits. These topological differences have a direct impact on circuit efficiency, as restricted connectivity may require inserting additional SWAP gates to enable distant qubit interactions. Mapping logical qubits onto physical layouts while minimizing these overheads is a key task for quantum compilers.[35][36]

Topological Qubit Connectivity - Superconducting vs Ion Trap: Superconducting qubits (e.g., IBM) are typically arranged in a 2D grid, while ion-trap systems (e.g., IonQ) allow full connectivity between qubits.

3. Compilation and Mapping

Quantum compilation involves adapting the logical circuit to accommodate the specific constraints of a given quantum device, which include:

• Support for the native gate set
• Qubit connectivity
• Physical error models

The mapping process assigns each logical qubit to a physical qubit in the hardware. Owing to limitations in connectivity, SWAP gates can be introduced to facilitate interactions between non-adjacent qubits. Additionally, scheduling is employed to organize the execution of gates within coherence time windows.[37]

4. Error Mitigation and Correction

Quantum systems are very sensitive to noise and can lose their stability. Before running, the circuit can be adjusted to account for errors.

• Error mitigation: Fixing errors after they happen or adjusting the circuit with methods like zero-noise extrapolation.
• Quantum error correction: Using quantum error correcting codes like surface codes to fix errors.

Most NISQ (Noisy Intermediate-Scale Quantum) devices use error mitigation instead of full error correction because they have a limited number of qubits.[38]

5. Execution on Hardware or Simulator

Quantum circuits can be executed on physical hardware or simulated classically, each with distinct trade-offs in fidelity, scalability, and noise modeling. The choice depends on the design stage, resource constraints, and error tolerance.

Simulation vs. Hardware Trade-offs

Comparison of Quantum Simulators and Physical Hardware

Aspect	Quantum Simulators	Quantum Hardware
Noise Modeling	Perfect (ideal) or configurable	Device-specific (e.g., 1/f noise, crosstalk)
Qubit Limit	30–50 (state-vector), 100+ (tensor-network)	50–1,000 (NISQ devices)
Execution Speed	Slower (exponential classical overhead)	Real-time (nanosecond gate operations)
Error Mitigation	Not required	Essential (e.g., zero-noise extrapolation)
Use Case	Algorithm validation, education	Benchmarking, hybrid workflows

Sources:[39]

Simulator Types

• State-vector simulators: Exact but memory-intensive (∼16 GB per 30 qubits). Used for small-scale validation.[40]
• Tensor-network simulators: Approximate, scalable to 100+ qubits for low-entanglement circuits.[41]
• Noise models: Emulate hardware errors (e.g., thermal relaxation, T1 and T2|T₂ decoherence). Critical for pre-fabrication testing.[42]

Hardware Execution

Modern quantum processors (e.g., IBM Quantum, Honeywell Quantum Solutions) typically offer:

• Pulse-level control: Custom waveforms for gate optimization.[43]
• Hybrid workflows: Integration with classical coprocessors (e.g., quantum-classical interfaces).[44]

6. Post-Processing and Analysis

Following the execution, the measurement results undergo statistical analysis to derive the final outputs. For probabilistic algorithms, multiple iterations (shots) are aggregated to estimate the outcome distributions.[45] This phase may also encompass result filtering, classical postprocessing, and plotting. In hybrid quantum-classical algorithm workflows, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), the results are subsequently passed to a classical optimizer.[46]

Tools and Frameworks

Quantum design automation relies on software toolchains that translate high-level algorithms into executable hardware instructions. Major platforms include:

Quantum Compilation Frameworks

Tool	Developer	Key Features	Target Hardware
Qiskit	IBM	Pulse-level control, noise-aware compilation	Superconducting
Cirq	Google	Native gate synthesis, hybrid algorithms	Superconducting, trapped ions
TKET	Quantinuum	Cross-platform optimization	Photonic, superconducting
PennyLane	Xanadu	Hybrid quantum-classical ML	Photonic

Sources:[47][48]

Benchmarking Metrics

Quantum compilers are evaluated by:

• Circuit depth: Minimizing sequential gate layers.
• T-count: Critical for fault-tolerant costs.
• SWAP overhead: Qubit routing efficiency.

Recent studies compare tools using randomized benchmarking on NISQ devices.[49]

Mathematical Foundations in Quantum Design

Design automation for quantum circuits is rooted in quantum mechanics and linear algebra.[2] Unlike classical circuits, which rely on binary logic and combinational arithmetic, quantum circuits are defined through unitary matrix operations acting on vector spaces of complex amplitudes.[13] This section outlines the mathematical representations that underpin quantum gate operations, decomposition, and circuit optimization.

Gate Representation and Unitarity

Quantum gates are represented by unitary matrices, which preserve the norm of quantum states during computation. For a system of ${\displaystyle n}$ qubits, gate operations are modeled as ${\displaystyle 2^{n}\times 2^{n}}$ unitary matrices ${\displaystyle U}$ such that ${\displaystyle U^{\dagger }U=I}$.[50]

For example, the Hadamard gate ${\displaystyle H}$, a single-qubit gate that creates superposition, is defined by: ${\displaystyle H={\frac {1}{\sqrt {2}}}{\begin{bmatrix}1&1\\1&-1\end{bmatrix}}}$

A common two-qubit entangling gate is the CNOT gate: ${\displaystyle {\text{CNOT}}={\begin{bmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{bmatrix}}}$

These gates form the basic building blocks of all quantum circuits and are the foundation for logic synthesis and optimization in quantum EDA tools.[51]

Gate Decomposition and Universal Sets

Many quantum devices do not support arbitrary unitaries directly. Instead, circuits must be compiled into universal gate sets, such as the Clifford+T set. An arbitrary single-qubit operation ${\displaystyle U\in {\text{SU}}(2)}$ can be decomposed using Euler angles:[52]

${\displaystyle U(\alpha ,\beta ,\gamma )=R_{z}(\alpha )\cdot R_{y}(\beta )\cdot R_{z}(\gamma )}$

Where ${\displaystyle R_{z}(\alpha )}$ and ${\displaystyle R_{y}(\beta )}$ are basic rotation gates:

${\displaystyle R_{z}(\alpha )={\begin{bmatrix}e^{-i\alpha /2}&0\\0&e^{i\alpha /2}\end{bmatrix}}}$ ${\displaystyle R_{y}(\beta )={\begin{bmatrix}\cos(\beta /2)&-\sin(\beta /2)\\\sin(\beta /2)&\cos(\beta /2)\end{bmatrix}}}$[53]

Circuit Cost Models

Quantum compilers and EDA tools evaluate circuit complexity using cost metrics. These include depth, gate count, and fault-tolerant overheads such as T-gate counts.[54] A generalized circuit cost model is: ${\displaystyle {\text{Cost}}=\alpha \cdot {\text{Depth}}+\beta \cdot {\text{T-Count}}+\gamma \cdot {\text{SWAPs}}}$[55]

Where:

• ${\displaystyle {\text{Depth}}}$: number of sequential layers (impacts coherence)
• ${\displaystyle {\text{T-Count}}}$: number of T-gates (important for error correction)
• ${\displaystyle {\text{SWAPs}}}$: inserted to satisfy qubit connectivity

Toolchains attempt to minimize this cost using layout-aware synthesis and scheduling algorithms.

Fault-Tolerant Cost Models

Quantum error correction (QEC) introduces significant overhead, which design automation tools must optimize. The surface code, a leading QEC scheme, requires:

$${\displaystyle {\text{FT Overhead}}={\frac {\text{Physical Qubits}}{\text{Logical Qubits}}}=O(d^{2})}$$[56]

where ${\displaystyle d}$ is the code distance (correlated with error suppression). For a logical qubit with ${\displaystyle d=7}$, this translates to ~49 physical qubits per logical qubit.[57] Key cost drivers include:

1. T-Gate Synthesis

Non-Clifford gates (e.g., T gates) dominate resource costs in fault-tolerant schemes. Their synthesis requires magic state distillation, with an approximate cost:$${\displaystyle {\text{T-Count}}\approx 3.3\log _{2}(1/\epsilon )+O(\log \log 1/\epsilon )}$$per T-gate at target error rate ${\displaystyle \epsilon }$.[58]

2. Routing Overhead

Topological constraints in surface codes impose additional costs for qubit communication. The worst-case space-time volume for a CNOT gate scales as:$${\displaystyle V_{\text{CNOT}}\approx 8d^{3}}$$lattice cells.[59]

Fault-Tolerant Resource Estimates for Common Operations

Operation	Physical Qubits	Depth (Surface Code Cycles)
Logical T-gate	49	12${\displaystyle d}$
Logical CNOT	98	6${\displaystyle d}$
Toffoli gate	147	24${\displaystyle d}$

Data from:[57]

Optimization Techniques in DAQC

Quantum circuit optimization techniques are algorithmic methods that transform quantum circuits into equivalent, more efficient implementations by minimizing physical resource requirements while preserving computational functionality.[60] They transform high-level algorithms into hardware-executable instructions and address unique quantum challenges such as non-commutative gates, hardware topology constraints, and decoherence. These techniques form the core of quantum electronic design automation (EDA), analogous to classical logic synthesis and optimization in traditional EDA flows.[61] Optimization approaches are categorized as follows:

Optimization Approaches

Compiler-Driven Optimizations

This compiler-driven approach focuses on reducing logical gate counts and circuit depth through:

• Gate cancellation: Identifies and removes redundant operations and automated identification of inverse gates(e.g., ${\displaystyle H\cdot H=I}$)
• Gate decomposition: Breaks down arbitrary unitaries into native gates using the Solovay-Kitaev theorem.[62]
• T-count reduction: Clifford+T synthesis with Ross-Selinger algorithm[63]

Hardware-Backed Optimization

Adapts circuits to physical device constraints:

• Qubit mapping: Uses SWAP network synthesis or the SABRE algorithm to minimize routing overhead.
• Pulse-level control: Optimizes DRAG pulses for superconducting qubits:
  ${\displaystyle \epsilon (t)=\Omega (t)+i{\frac {{\dot {\Omega }}(t)}{2\alpha }}}$
• Topology adaptation: Adjusts for nearest-neighbor coupling vs. all-to-all connectivity.[64]

Error-Tolerant Optimization

Mitigates noise through:

• Dynamical decoupling: Inserts idle-qubit sequences (${\displaystyle \tau -X-\tau -X-\tau }$) to suppress decoherence.[65]
• Zero-noise extrapolation: Extrapolates results from multiple noisy executions.[66]
• Error-adaptive compilation: Prioritizes high-fidelity gates (see Noise-Adaptive Optimization).

Machine Learning in Quantum Design Automation

Recent advances in machine learning (ML) have introduced data-driven methods to automate and optimize quantum circuit design. These techniques address challenges such as qubit mapping, gate decomposition, and noise adaptation, where traditional heuristic approaches may struggle with scalability or hardware-specific constraints.

Key Applications

• Qubit Mapping with Reinforcement Learning (RL):

RL agents learn to minimize SWAP gate overhead by exploring qubit connectivity graphs. For example, Google’s 2023 work demonstrated a 37% reduction in SWAP gates compared to SABRE, a leading heuristic algorithm, on 53-qubit superconducting devices.[67]

• Noise-Adaptive Compilation via Neural Networks:

Graph neural networks (GNNs) predict optimal gate sequences by analyzing hardware noise profiles. IBM’s "Qiskit Runtime" integrates such models to dynamically adjust circuits for T1 and T2|T₁/T₂ decoherence and crosstalk.[68]

• Gate Synthesis with Generative Models:

Variational autoencoders (VAEs) generate compact gate sequences for arbitrary unitaries, reducing T-count by up to 29% in fault-tolerant circuits.[69]

Limitations and Open Challenges

• Training Data Scarcity: ML models require large datasets of quantum circuit benchmarks, which are computationally expensive to generate.[70]
• Generalization Across Architectures: Models trained on superconducting qubits may not transfer to photonic or trapped-ion systems.[71]

Future Directions in DAQC

Recent literature emphasizes that scalability, compiler-hardware co-design, and the integration of machine learning (ML) are emerging as central challenges in advancing design automation for quantum circuits (DAQC). As quantum processors scale to hundreds or thousands of qubits, traditional mapping and routing techniques become computationally expensive and increasingly impractical. New strategies must adapt to heterogeneous hardware, variable error rates, and modular qubit layouts.[72]

Compiler co-design is a promising direction, where quantum hardware and software are developed in tandem to optimize for specific noise profiles and connectivity constraints. Machine learning techniques, including reinforcement learning and graph neural networks, are also being explored to guide gate synthesis, qubit placement, and error mitigation dynamically during compilation.[73]

For instance, recent efforts like QFAST, Quarl, and hybrid ML-assisted pipelines demonstrate potential improvements in circuit fidelity and depth reduction under noise constraints. These approaches suggest that future DAQC workflows may combine classical optimization, data-driven learning, and hardware-aware heuristics to meet the performance needs of near-term quantum devices.[74]

See also

• Electronic design automation - Classical counterpart to quantum design automation
• Quantum error correction - Techniques for mitigating errors in quantum circuits
• Quantum programming - High-level languages for quantum algorithm development
• Quantum volume - Metric for assessing quantum computer performance
• Quantum logic gate - Fundamental operations in quantum circuits
• Quantum algorithm - Computational methods using quantum effects
• Quantum supremacy - Demonstration of quantum advantage
• List of quantum processors - Survey of current quantum hardware

Related Tools and Frameworks

• Qiskit - IBM's quantum computing framework
• Cirq - Google's quantum programming library
• ket⟩ - Cambridge Quantum's compiler stack
• Quantum Development Kit - Microsoft's quantum toolkit

External Resources

• IBM Quantum Experience
• Google Quantum AI
• IBM Quantum Learning
• QWorld educational initiative

References

1. Quetschlich, Nils; Burgholzer, Lukas; Wille, Robert (2023-07-20). "MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing". Quantum. 7: 1062. doi:10.22331/q-2023-07-20-1062. ISSN 2521-327X.
2. Hong, Xin; Zhou, Xiangzhen; Li, Sanjiang; Feng, Yuan; Ying, Mingsheng (2022-11-30). "A Tensor Network based Decision Diagram for Representation of Quantum Circuits". ACM Transactions on Design Automation of Electronic Systems. 27 (6): 1–30. doi:10.1145/3514355. ISSN 1084-4309.
3. Kundu, Joydeep; Paria, Prantik; Dey, Rajjdeep; Sengupta, Saptarshi; Dey, Pritam; Pradhan, Debkanta; Mukherjee, Chiradeep; Pramanik, Sayak (2023), Bhattacharyya, Siddhartha; Banerjee, Jyoti Sekhar; Köppen, Mario (eds.), "Performance Analysis of Reversible Full Adders in Noisy Intermediate Scale Quantum (NISQ) Devices", Human-Centric Smart Computing, vol. 316, Singapore: Springer Nature Singapore, pp. 67–79, doi:10.1007/978-981-19-5403-0_6, ISBN 978-981-19-5402-3, retrieved 2025-06-08
4. Desurvire, Emmanuel (2009-02-19). Classical and Quantum Information Theory: An Introduction for the Telecom Scientist (1 ed.). Cambridge University Press. doi:10.1017/cbo9780511803758.018. ISBN 978-0-521-88171-5.
5. Matteo, Olivia Di; Mosca, Michele (2016-03-01). "Parallelizing quantum circuit synthesis". Quantum Science and Technology. 1 (1): 015003. doi:10.1088/2058-9565/1/1/015003. ISSN 2058-9565.
6. Kim, Dongmin; Heng, Sengthai; Han, Youngsun (2022-02-28). "A Parallelized Qubit Mapping Algorithm for Large-scale Quantum Circuits". IEIE Transactions on Smart Processing & Computing. 11 (1): 40–48. doi:10.5573/IEIESPC.2021.11.1.40. ISSN 2287-5255.
7. Mulherkar, Jaideep; Rajdeepak, Rishikant; Sunitha, V. (2022-10-01). "Implementation of quantum hitting times of cubelike graphs on IBM's Qiskit platform". International Journal of Quantum Information. 20 (07). doi:10.1142/S0219749922500204. ISSN 0219-7499.
8. Javadi-Abhari, Ali (2021). "ScaffCC: Quantum Program Compilation with ScaffCC". International Conference on Computer-Aided Design. ACM. pp. 1–8. doi:10.1145/1124023.1124085.
9. Zhang, Jingfu; Laflamme, Raymond; Suter, Dieter (2012-09-06). "Experimental Implementation of Encoded Logical Qubit Operations in a Perfect Quantum Error Correcting Code". Physical Review Letters. 109 (10). doi:10.1103/PhysRevLett.109.100503. ISSN 0031-9007.
10. Itoko, Toshinari (2021). "Design Automation for Quantum Computing: Status and Challenges". Integration. 75: 77–89. doi:10.1016/j.vlsi.2020.10.003.
11. Niu, Siyuan; Todri-Sanial, Aida (2022). "Effects of Dynamical Decoupling and Pulse-Level Optimizations on IBM Quantum Computers". IEEE Transactions on Quantum Engineering. 3: 1–10. doi:10.1109/TQE.2022.3203153. ISSN 2689-1808.
12. Wille, Robert (2021). "Design Automation for Quantum Computing: Status and Challenges". Proceedings of the Design Automation Conference. IEEE. doi:10.1109/DAC18074.2021.9472873.
13. Córcoles, A. D.; Takita, Maika; Inoue, Ken; Lekuch, Scott; Minev, Zlatko K.; Chow, Jerry M.; Gambetta, Jay M. (2021-08-31). "Exploiting Dynamic Quantum Circuits in a Quantum Algorithm with Superconducting Qubits". Physical Review Letters. 127 (10). doi:10.1103/PhysRevLett.127.100501. ISSN 0031-9007.
14. Preskill, J. (2018). "Quantum Computing in the NISQ era". Quantum. 2: 79. doi:10.22331/q-2018-08-06-79.
15. Flarend, Alice, and Bob Hilborn, 'Quantum Gates and Quantum Circuits', Quantum Computing: From Alice to Bob (Oxford, 2022; online edn, Oxford Academic, 23 June 2022), https://doi.org/10.1093/oso/9780192857972.003.0006, accessed 8 June 2025.
16. Jurcevic, Petar; Javadi-Abhari, Ali; Bishop, Lev S; Lauer, Isaac; Bogorin, Daniela F; Brink, Markus; Capelluto, Lauren; Günlük, Oktay; Itoko, Toshinari; Kanazawa, Naoki; Kandala, Abhinav; Keefe, George A; Krsulich, Kevin; Landers, William; Lewandowski, Eric P (2021-04-01). "Demonstration of quantum volume 64 on a superconducting quantum computing system". Quantum Science and Technology. 6 (2): 025020. doi:10.1088/2058-9565/abe519. ISSN 2058-9565.
17. Ganzhorn, M.; Salis, G.; Egger, D. J.; Fuhrer, A.; Mergenthaler, M.; Müller, C.; Müller, P.; Paredes, S.; Pechal, M.; Werninghaus, M.; Filipp, S. (2020-09-18). "Benchmarking the noise sensitivity of different parametric two-qubit gates in a single superconducting quantum computing platform". Physical Review Research. 2 (3). doi:10.1103/PhysRevResearch.2.033447. ISSN 2643-1564.
18. Binti Adnan, N.A., Yamashita, S., Devitt, S.J., Nemoto, K. (2014). 2D Qubit Layout Optimization for Topological Quantum Computation. In: Yamashita, S., Minato, Si. (eds) Reversible Computation. RC 2014. Lecture Notes in Computer Science, vol 8507. Springer, Cham. https://doi.org/10.1007/978-3-319-08494-7_14
19. Murali, P. (2019). "Noise-Adaptive Compiler Mappings". ASPLOS: 1015–1029. doi:10.1145/3297858.3304075.
20. "IBM Quantum Processor Specifications". IBM.
21. Preskill, John (2018). "Quantum Computing in the NISQ era and beyond". Quantum. 2: 79. doi:10.22331/q-2018-08-06-79.
22. Nielsen, M.A. (2010). "Quantum circuits". Quantum Computation and Quantum Information. Cambridge.
23. Li, Gushu. "Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices". ASPLOS 2019: 1001–1014. doi:10.1145/3297858.3304023.
24. Garcia-Escartin, Juan Carlos (2013). "Quantum gates: commutativity and reversibility". Physical Review A. 87 (5): 052330. doi:10.1103/PhysRevA.87.052330.
25. Nielsen, Michael A. (2010). "Quantum circuits". Quantum Computation and Quantum Information. Cambridge. ISBN 978-1107002173.
26. Motzoi, Farhang (2009). "Simple pulses for elimination of leakage in weakly nonlinear qubits". Physical Review Letters. 103 (11): 110501. doi:10.1103/PhysRevLett.103.110501.
27. McKay, David C. (2016). "Universal Gate for Fixed-Frequency Qubits via a Tunable Bus". Physical Review Applied. 6 (6): 064007. doi:10.1103/PhysRevApplied.6.064007.
28. Gaebler, J.P. (2022). "High-Fidelity Universal Gate Set for ^9Be^+ Ion Qubits". Physical Review Letters. 128 (3): 033905. doi:10.1103/PhysRevLett.128.033905.
29. Arrazola, Juan Miguel (2023). "Quantum circuits with many photons on a programmable nanophotonic chip". Nature. 591 (7848): 54–60. doi:10.1038/s41586-021-03202-1.
30. Wille, R., et al. (2024). "The MQT Handbook". arXiv preprint.
31. Cui, R., Lyu, Z. (17 November 2023). "Analysis of quantum gates in quantum circuits". Theoretical and Natural Science. 10 (1). Eliwise Academy: 1–8. doi:10.54254/2753-8818/10/20230301.
32. Cross, Andrew; Javadi-Abhari, Ali; Alexander, Thomas; De Beaudrap, Niel; Bishop, Lev S.; Heidel, Steven; Ryan, Colm A.; Sivarajah, Prasahnt; Smolin, John; Gambetta, Jay M.; Johnson, Blake R. (2022-09-30). "OpenQASM 3: A Broader and Deeper Quantum Assembly Language". ACM Transactions on Quantum Computing. 3 (3): 1–50. doi:10.1145/3505636. ISSN 2643-6809.
33. Jones, N. Cody; Van Meter, Rodney; Fowler, Austin G.; McMahon, Peter L.; Kim, Jungsang; Ladd, Thaddeus D.; Yamamoto, Yoshihisa (2012-07-31). "Layered Architecture for Quantum Computing". Physical Review X. 2 (3). doi:10.1103/PhysRevX.2.031007. ISSN 2160-3308.
34. Kissinger, Aleks; van de Wetering, John (2020-08-11). "Reducing the number of non-Clifford gates in quantum circuits". Physical Review A. 102 (2). doi:10.1103/PhysRevA.102.022406. ISSN 2469-9926.
35. Murali, Prakash; Chong, Fredrik T.; Martonosi, Margaret. "Noise-Adaptive Compiler Mappings for Noisy Intermediate-Scale Quantum Computers". ASPLOS 2019: 1015–1029. doi:10.1145/3297858.3304075.
36. Maslov, Dmitri (2016). "Advantages of using relative-phase Toffoli gates with an application to multiple control Toffoli optimization". Physical Review A. 93 (2): 022311. doi:10.1103/PhysRevA.93.022311.
37. Perez-Leija, Armando; Weimann, Steffen; Gräfe, Markus; Szameit, Alexander; Busch, Kurt (2017). "Photonic Two-Qubit SWAP Gates". Quantum Information and Measurement (QIM) 2017. Washington, D.C.: OSA: QT6A.36. doi:10.1364/qim.2017.qt6a.36.
38. Weaving, Tim; Ralli, Alexis; Kirby, William M.; Love, Peter J.; Succi, Sauro; Coveney, Peter V. (2023-10-17). "Benchmarking noisy intermediate scale quantum error mitigation strategies for ground state preparation of the HCl molecule". Physical Review Research. 5 (4). doi:10.1103/PhysRevResearch.5.043054. ISSN 2643-1564.
39. Georgescu, I. (2020). "Quantum Simulation". Nature Reviews Physics. 2 (9): 422–439. doi:10.1038/s42254-020-0209-1.
40. Chen, Z. (2021). "Classical Simulation of Quantum Circuits". Physical Review A. 104 (3): 032602. doi:10.1103/PhysRevA.104.032602.
41. Markov, I.L. (2018). "Quantum Circuit Simulation". ACM Computing Surveys. 51 (4): 68. doi:10.1145/3173543.
42. "Qiskit Aer Noise Model Documentation". IBM Quantum.
43. McKay, D.C. (2016). "Universal Gate for Fixed-Frequency Qubits". Physical Review Applied. 6 (6): 064007. doi:10.1103/PhysRevApplied.6.064007.
44. Peruzzo, A. (2014). "Variational Quantum Eigensolver". Nature Communications. 5: 4213. doi:10.1038/ncomms5213.
45. Yang, Bo; Raymond, Rudy; Uno, Shumpei (2022-07-18). "Efficient quantum readout-error mitigation for sparse measurement outcomes of near-term quantum devices". Physical Review A. 106 (1). doi:10.1103/PhysRevA.106.012423. ISSN 2469-9926.
46. Liu, Xiaoyuan; Angone, Anthony; Shaydulin, Ruslan; Safro, Ilya; Alexeev, Yuri; Cincio, Lukasz (2022). "Layer VQE: A Variational Approach for Combinatorial Optimization on Noisy Quantum Computers". IEEE Transactions on Quantum Engineering. 3: 1–20. doi:10.1109/TQE.2021.3140190. ISSN 2689-1808.
47. McKay, David C. (2018). "Qiskit Backend Specifications for OpenPulse". IBM Research.
48. "Cirq Documentation". Google Quantum AI.
49. Nam, Yunseong (2018). "Automated optimization of large quantum circuits". NPJ Quantum Information. 4: 23. doi:10.1038/s41534-018-0072-4.
50. Hu, Shi; Cui, Wen-Xue; Wang, Dong-Yang; Bai, Cheng-Hua; Guo, Qi; Wang, Hong-Fu; Zhu, Ai-Dong; Zhang, Shou (2015-07-30). "Teleportation of a Toffoli gate among distant solid-state qubits with quantum dots embedded in optical microcavities". Scientific Reports. 5 (1). doi:10.1038/srep11321. ISSN 2045-2322.
51. Abdollahi, A.; Pedram, M. (2006). "Analysis and Synthesis of Quantum Circuits by Using Quantum Decision Diagrams". Proceedings of the Design Automation & Test in Europe Conference. IEEE: 1–6. doi:10.1109/date.2006.244176.
52. Plesch, Martin; Brukner, Časlav (2011-03-03). "Quantum-state preparation with universal gate decompositions". Physical Review A. 83 (3). doi:10.1103/PhysRevA.83.032302. ISSN 1050-2947.
53. Perivolaropoulos, L. (2017-05-31). "Cosmological horizons, uncertainty principle, and maximum length quantum mechanics". Physical Review D. 95 (10). doi:10.1103/PhysRevD.95.103523. ISSN 2470-0010.
54. Munoz-Coreas, Edgard; Thapliyal, Himanshu (2019-05-01). "Quantum Circuit Design of a T-count Optimized Integer Multiplier". IEEE Transactions on Computers. 68 (5): 729–739. doi:10.1109/TC.2018.2882774. ISSN 0018-9340.
55. Zhu, Huangjun; Zhang, Haoyu (2020-04-15). "Efficient verification of quantum gates with local operations". Physical Review A. 101 (4). doi:10.1103/PhysRevA.101.042316. ISSN 2469-9926.
56. Lao, Lingling; Almudever, Carmen G. (2020-03-20). "Fault-tolerant quantum error correction on near-term quantum processors using flag and bridge qubits". Physical Review A. 101 (3). doi:10.1103/PhysRevA.101.032333. ISSN 2469-9926.
57. Fowler, A.G. (2012). "Surface codes: Towards practical large-scale quantum computation". Physical Review A. 86 (3): 032324. doi:10.1103/PhysRevA.86.032324.
58. Gidney, C. (2021). "Factoring with ${\displaystyle n+2}$ qubits". Quantum. 5: 433. doi:10.22331/q-2021-04-15-433.
59. Beverland, M.E. (2022). "Lower bounds on the non-Clifford resources for quantum computations". Quantum Science and Technology. 7 (3): 035019. doi:10.1088/2058-9565/ac6f37.
60. Lacroix, Nathan; Hellings, Christoph; Andersen, Christian Kraglund; Di Paolo, Agustin; Remm, Ants; Lazar, Stefania; Krinner, Sebastian; Norris, Graham J.; Gabureac, Mihai; Heinsoo, Johannes; Blais, Alexandre; Eichler, Christopher; Wallraff, Andreas (2020-10-20). "Improving the Performance of Deep Quantum Optimization Algorithms with Continuous Gate Sets". PRX Quantum. 1 (2). doi:10.1103/PRXQuantum.1.020304. ISSN 2691-3399.
61. Wu, L.-A.; Zanardi, P.; Lidar, D. A. (2005-09-22). "Holonomic Quantum Computation in Decoherence-Free Subspaces". Physical Review Letters. 95 (13). doi:10.1103/PhysRevLett.95.130501. ISSN 0031-9007.
62. Dawson, C.M. (2006). "The Solovay-Kitaev algorithm". Quantum Information & Computation. 6 (1): 81–95.
63. Ross, N. (2015). "Optimal ancilla-free Clifford+T approximation of z-rotations". Quantum. 1: 13. doi:10.22331/q-2015-04-17-13.
64. Murali, P. (2020). "Architecture-aware quantum circuit optimization". IEEE Micro. 40 (6): 19–28. doi:10.1109/MM.2020.3024196.
65. Viola, L. (1999). "Dynamical decoupling sequences". Physical Review A. 60 (1): 821. doi:10.1103/PhysRevA.60.821.
66. Kandala, A. (2019). "Error mitigation extends computational reach". Nature. 567 (7749): 491–495. doi:10.1038/s41586-019-1040-7.
67. Zhou, Y. (2023). "Quantum Circuit Mapping Optimization via Deep Reinforcement Learning". Nature Computational Science. 3 (4): 318–327. doi:10.1038/s43588-023-00429-y.
68. Murali, P. (2022). "Machine Learning for Quantum Hardware-Aware Compilation". IEEE Quantum Week. pp. 1–10. doi:10.1109/QCE53715.2022.00020.
69. Cincio, L. (2023). "Learning Quantum Circuit Synthesis with Noise". arXiv:2305.15201 [quant-ph].
70. McClean, J.R. (2021). "Barren Plateaus in Quantum Neural Networks". Nature Communications. 12: 1791. doi:10.1038/s41467-021-21728-w.
71. Wang, Z. (2023). "Cross-Platform Quantum Machine Learning". Physical Review X. 13 (2): 021049. doi:10.1103/PhysRevX.13.021049.
72. Wang, Yue; Ding, Yongshan; Wu, Xiaodi (2024). "A Survey on Machine Learning-Enhanced Quantum Compilation and Mapping". arXiv:2405.17543 [quant-ph].
73. Li, Jian; Wu, Xiaodi (2023). "Reinforcement learning for scalable qubit mapping in noisy quantum architectures". Proceedings of the AAAI Conference on Artificial Intelligence. 37 (7): 8329–8337. doi:10.1609/aaai.v37i7.25809.
74. Itoko, Toshinari; Haner, Thomas (2022). "Scalable mapping and layout of quantum circuits". IEEE Transactions on Quantum Engineering. 3: 1–12. doi:10.1109/TQE.2022.3198356.