The MQT Handbook

A Summary of Design Automation Tools and

Software for Quantum Computing
Robert Wille,
Lucas Berent, Tobias Forster, Jagatheesan Kunasaikaran, Kevin Mato, Tom Peham, Nils
Quetschlich, Damian Rovara, Aaron Sander, Ludwig Schmid, Daniel Schönberger, Yannick Stade,
Lukas Burgholzer
Chair for Design Automation, Technical University of Munich, Germany
[email protected]

Abstract
Quantum computers are becoming a reality and numerous quantum computing applications with a near-term
perspective (e.g., for finance, chemistry, machine learning, and optimization) and with a long-term perspective (e.g.,
for cryptography or unstructured search) are currently being investigated. However, designing and realizing potential
applications for these devices in a scalable fashion requires automated, efficient, and user-friendly software tools
that cater to the needs of end users, engineers, and physicists at every level of the entire quantum software stack.
Many of the problems to be tackled in that regard are similar to design problems from the classical realm for which
sophisticated design automation tools have been developed in the previous decades.
The Munich Quantum Toolkit (MQT) is a collection of software tools for quantum computing developed by the
Chair for Design Automation at the Technical University of Munich which explicitly utilizes this design automation
expertise. Our overarching objective is to provide solutions for design tasks across the entire quantum software
stack. This entails high-level support for end users in realizing their applications, efficient methods for the classical
simulation, compilation, and verification of quantum circuits, tools for quantum error correction, support for physical
design, and more. These methods are supported by corresponding data structures (such as decision diagrams) and core
methods (such as SAT encodings/solvers). All of the developed tools are available as open-source implementations
and are hosted on github.com/cda-tum.

Note: A live version of this document is available at mqt.readthedocs.io.

1
The MQT Handbook
I Introduction 2

II Classical Simulation of Quantum Circuits 3

III Compilation of Quantum Circuits 4

IV Verification of Quantum Circuits 6

V Benchmarking Software and Design Automation Tools for Quantum Computing 7

VI Open-Source Implementations 7

VII Conclusions 8

References 8

I Introduction
Quantum computing has the potential to revolutionize many fields in the 21st century, such as cryptography [1],
finance [2], chemistry [3], machine learning [4], and optimization [5]. Over the past decade, numerous quantum
computers from multiple providers based on different qubit technologies have been made publicly available. However,
the best hardware is only as good as the software available to realize corresponding applications on it—a lesson
learned from the past decades of research on designing and developing classical circuits and systems. Thanks to
the software tools and methods for Electronic Design Automation (EDA), we can create classical systems with a
staggering amount of transistors and complex functionalities that we often take for granted. These methods allow
designers to efficiently and automatically handle the intricacies of such systems and optimize their performance.
Compared to that, most existing software solutions for quantum computing leave the decades of research on design
automation methods underutilized.
The Munich Quantum Toolkit (MQT), which is developed by the Chair for Design Automation at the Technical
University of Munich, aims to leverage this latent potential by providing a collection of state-of-the-art design
automation methods and software tools for quantum computing. Our overarching objective is to provide solutions
for design tasks across the entire quantum software stack. This entails high-level support for end users in realizing
their applications [6, 7, 8, 9, 10, 11], efficient methods for the classical simulation [12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26], compilation [11, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46], and verification [47, 48, 49, 50, 51, 52, 53, 54, 55] of quantum circuits, tools for quantum error correction
[56, 57, 58, 59], support for physical design [60], and more. In all these tools, we try to utilize data structures (such
as decision diagrams [61, 62] or the ZX-calculus [63, 64]) and core methods (such as reasoning engines [65]) to
facilitate the efficient handling of quantum computations. The proposed solutions demonstrate how utilizing design
automation expertise can lead to improved efficiency, scalability, and reliability. In particular, they illustrate the
immense benefits of leveraging expertise in classical circuit and system design rather than starting from scratch.
All tools developed as part of the MQT are made available as open-source packages on github.com/cda-tum.
In the following, we briefly summarize some of the core methods and tools (covering classical simulation,
compilation, and verification of quantum circuits as well as benchmarking). We particularly focus on how to use
the tools, but additionally provide references and links that offer detailed descriptions of the underlying methods as
well as summaries of corresponding case studies and evaluations demonstrating the benefits.

2
 II Classical Simulation of Quantum Circuits
Performing a quantum computation (commonly described as a quantum circuit) entails evolving an initial quantum
state by applying a sequence of operations (also called gates) and measuring the resulting system. Eventually, the
goal should obviously be to do that on a real device. However, there are several important reasons for simulating
the corresponding computations on a classical machine, particularly in the early stages of the design: As long as no
suitable devices are available (e.g., in terms of scale, feasible computation depth, or accuracy), classical simulations
of quantum circuits still allow one to explore and test quantum applications, even if only on a limited scale. However,
also with further progress in the capabilities of the hardware platforms, classical simulation will remain an essential
part of the quantum computing design process, since it additionally allows access to all amplitudes of a resulting
quantum state in contrast to a real device that only probabilistically returns measurement results. Moreover, classical
simulation provides means to study quantum error correction as well as a baseline to estimate the advantage of
quantum computers over classical computers.
The classical simulation of quantum circuits is commonly conducted by performing consecutive matrix-vector
multiplication, which many simulators realize by storing a dense representation of the complete state vector in
memory and evolving it correspondingly (see, e.g., [66, 67, 68, 69, 70]) or by relying on tensor network methods
(see, e.g., [71, 72, 73, 74]). This approach quickly becomes intractable due to the exponential growth of the quantum
state with respect to the number of qubits—quickly rendering such simulations infeasible even on supercomputer
clusters. Simulation methodologies based on decision diagrams [12, 62, 75] are a promising complementary approach
that frequently allows reducing the required memory by exploiting redundancies in the simulated quantum state.
The MQT offers the classical quantum circuit simulator DDSIM that can be used to perform various quantum circuit
simulation tasks based on using decision diagrams as a data structure. This includes strong and weak simulation
[12, 13, 14], approximation techniques [15, 16], noise-aware simulation [17, 18, 19], hybrid Schrödinger-Feynman
techniques [20], support for dynamic circuits, the computation of expectation values [21], the simulation of mixed-
dimensional systems [22], and more [23, 24, 25, 26].
Example 1. Consider the following listing that describes the quantum circuit for generating a three-qubit GHZ
state (also shown in Fig. 1):
1 from qiskit import QuantumCircuit
2

3 circ = QuantumCircuit(3)
4 circ.h(2)
5 circ.cx(2, 1)
6 circ.cx(1, 0)
7 circ.measure_all()

Fig. 1. Quantum circuit for generating a three-qubit GHZ state.

This circuit can be classically simulated using DDSIM as a backend for IBM Qiskit:
1 from mqt.ddsim import DDSIMProvider
2
3 provider = DDSIMProvider()
(continues on next page)

3
 (continued from previous page)
4 backend = provider.get_backend("qasm_simulator")
5 result = backend.run(circ, shots=10000).result()
6 result.get_counts()

{'000': 4975, '111': 5025}

MQT DDSIM
Code: cda-tum/mqt-ddsim
Python Package: pypi.org/p/mqt.ddsim
Documentation: mqt.rtfd.io/projects/ddsim

III Compilation of Quantum Circuits

In today’s digital world, creating computer programs has become a crucial element of software development. With
the advent of high-level programming languages such as C++ or Python, the development process has become
simpler and more efficient. These languages enable developers to produce code that is more human-readable
and understandable without having to worry about the underlying hardware’s low-level features. But before these
programs can be executed on a computer, they must be translated into machine code that the computer can process.
This procedure is known as compilation, and it entails converting high-level code into a binary format that the
computer’s processor can directly execute. By making it easier for more people to create computer programs, this
has enabled the development of complex software applications that can run on many different platforms such as
desktops, laptops, mobile phones or embedded devices.
Just as in classical computing, the design of quantum circuits and the development of quantum algorithms are
fundamental in the development of quantum computing applications. Quantum circuits are analogous to classical
functions or programs in that they are a sequence of quantum gates that perform specific operations on quantum bits
or qubits instead of classical bits. Similarly to classical processors, quantum processors can only execute a certain
set of native instructions, and they might further limit the qubits on which these operations might be applied. Thus,
any high-level quantum circuit (describing a quantum application) must be compiled into a representation that can
be executed on the targeted device. Most importantly, the resulting quantum circuit must only use gates that are
native to the device on which it shall be executed. If the device only has limited connectivity between its qubits,
it must only apply gates to qubits that are connected on the device. Naturally, the efficiency of this compilation
process is critical because it can have a significant impact on the performance of the resulting quantum program.
Inefficient compilation can lead to longer execution times, higher error rates, and reduced accuracy in the final result.
Therefore, developing efficient compilation methods for quantum programs is essential to overcome the challenges
of quantum computing and realize the potential of this technology.
In the following, we mainly focus on the quantum circuit mapping task. This is a crucial step in the compilation
flow, as it directly affects the feasibility and performance of the quantum circuit on a given device. It involves
finding a way to map the qubits of a quantum circuit to the qubits of a quantum device, while respecting the
limited connectivity constraints of the device and minimizing the overhead of additional gates. In most cases, it is
not possible to statically define a mapping of the circuit’s qubits to the device’s qubits such that all gates of the
circuit conform to the connectivity limitations of the device. Consequently, this mapping has to change dynamically
throughout the circuit. This can be accomplished by using SWAP gates that allow the position of two logical qubits
on the architecture to be interchanged. However, since any additional gate increases the error rate and, hence, reduces
the accuracy of the computation, it is vital to keep the number of additionally added gates as low as possible. It
has been shown that even this small part in the compilation flow is an NP-complete problem [76].
The MQT offers the quantum circuit mapping tool QMAP that allows one to generate circuits which satisfy all
constraints given by the targeted architecture and, at the same time, keep the overhead in terms of additionally
required quantum gates as low as possible. More precisely, different approaches based on design automation
techniques are provided, which are generic and can be easily configured for future architectures. Among them
is a heuristic, scalable solution for arbitrary circuits based on informed-search algorithms [27, 28, 29] as well as a
solution for obtaining mappings ensuring minimal overhead with respect to SWAP gate insertions [30, 31].

4
 Additionally, the MQT offers many more methods for various compilation tasks, such as Clifford circuit synthesis
[32, 33], determining optimal sub-architectures [34], compiler optimization [11, 35, 36], and compilation techniques
for neutral atom technologies [40, 41], ion-trap shuttling [37, 38, 39], or multi-level quantum systems [42, 43, 44,
45]. Furthermore, it provides first automated methods regarding Fault-Tolerant Quantum Computing (FTQC) such
as automatic circuit generation and evaluation for error-correcting codes [46].
Example 2. Assume we want to perform the computation from Fig. 1 on a five-qubit IBM quantum computer
described by the coupling map shown in Fig. 2.

Fig. 2. Coupling map of a generic five-qubit IBM device.

Then, mapping the circuit to that device merely requires the following lines of Python and results in the circuit
shown in Fig. 3.
1 from mqt.qmap import compile
2 from qiskit.providers.fake_provider import Fake5QV1
3

4 backend = Fake5QV1()
5 circ_mapped, results = compile(circ, backend)

Fig. 3. Quantum circuit from Fig. 1 mapped to the five-qubit device shown in Fig. 2.

MQT QMAP
Code: cda-tum/mqt-qmap
Python Package: pypi.org/p/mqt.qmap
Documentation: mqt.rtfd.io/projects/qmap

5
 IV Verification of Quantum Circuits
Compiling quantum algorithms results in different representations of the considered functionality, which significantly
differ in their basis operations and structure but are still supposed to be functionally equivalent. As described in
the previous section, even individual compilation tasks can be highly complex. Consequently, checking whether the
original functionality is indeed maintained throughout all these different abstractions becomes increasingly relevant
in order to guarantee a consistent and error-free compilation flow. This is similar to the classical realm, where
descriptions at various levels of abstraction also exist. These descriptions are verified using design automation
expertise—resulting in efficient methods for verification to ensure the correctness of the design across different
levels of abstraction [77]. However, since quantum circuits additionally employ quantum-physical effects such as
superposition and entanglement, these methods cannot be used out of the box in the quantum realm. Accordingly,
verification of quantum circuits must be approached from a different perspective. At first glance, these characteristics
of quantum computing make verification much harder as for classical circuits and systems. In fact, equivalence
checking of quantum circuits has been proven to be a computationally hard problem [78].
At the same time, quantum circuits possess certain characteristics that offer remarkable potential for efficient
equivalence checking that is not available in classical computing. More precisely, consider two quantum circuits
𝐺 = 𝑔1 , . . . , 𝑔𝑚 and 𝐺′ = 𝑔1′ , . . . , 𝑔𝑛′ whose equivalence shall be checked. Due to the inherent reversibility of
quantum operations, the inverse of a quantum circuit can easily be computed by taking the complex conjugate of
every gate and reversing the sequence of the gates in the circuit, i.e., 𝐺′−1 = (𝑔𝑛′ )† , . . . , (𝑔1′ )† . If two circuits are
equivalent, this allows for the conclusion that 𝐺 · 𝐺′−1 = 𝐼, where 𝐼 is the identity function. Since the identity
has the most compact representation for most data structures representing quantum functionality (e.g., linear with
respect to the number of qubits in case of decision diagrams), the equivalence check can be simplified considerably.
Even complex circuits can be verified efficiently, if one manages to apply the gates of both circuits in a sequence
that keeps the intermediate representation “close to the identity”. Within the MQT, several methods and strategies
were proposed that utilize this characteristic of quantum computations. Eventually, this led to solutions that can
verify the results of whole quantum compilation flows (such as IBM’s Qiskit) in negligible runtime—something we
never managed for classical circuits and systems.
The MQT offers the quantum circuit equivalence checking tool QCEC which encompasses a comprehensive suite
of efficient methods and automated tools for the verification of quantum circuits based on the ideas outlined in [47,
48, 49, 50, 51, 52, 53, 54, 55]. By this, an important step towards avoiding or substantially mitigating the emerge
of a verification gap for quantum circuits is taken, i.e., a situation where the physical development of a technology
substantially outperforms our ability to design suitable applications for it or to verify it.
Example 3. Verifying that the quantum circuit from Fig. 3 has been correctly compiled to the architecture from
Fig. 2, i.e., checking whether it still implements the functionality of the circuit shown in Fig. 1, merely requires the
following lines of Python:
1 from mqt.qcec import verify
2
3 result = verify(circ, circ_mapped)
4 print(result.equivalence)

equivalent

MQT QCEC
Code: cda-tum/mqt-qcec
Python Package: pypi.org/p/mqt.qcec
Documentation: mqt.rtfd.io/projects/qcec

6
 V Benchmarking Software and Design Automation Tools for Quantum
Computing
Tools like the ones proposed above are key in order to support end users in the realization of their quantum
computing applications. And, thankfully, a huge variety of tools has been proposed in the past—with many more
to come. However, whenever such a quantum software tool is proposed, it is important to empirically evaluate its
performance and to compare it to the state of the art. For that purpose, proper benchmarks are needed. To provide
those, MQT Bench is proposed [79], which offers over 70, 000 benchmarks on various abstraction levels (depending
on what level the to-be-evaluated software tool operates on). Having all those benchmarks in a single repository
enables an increased comparability, reproducibility, and transparency. To make the benchmarks as accessible as
possible, MQT Bench comes as an easy-to-use website that is hosted at www.cda.cit.tum.de/mqtbench/ and as a
Python package available on PyPI.
Example 4. A larger version of the quantum circuit from Fig. 1 can easily be obtained programmatically from the
MQT Bench Python package as follows:
1 from mqt.bench import get_benchmark
2

3 circ = get_benchmark("ghz", circuit_size=8, level="alg")

Fig. 4. Larger version of the circuit from Fig. 1 obtained via MQT Bench.

This gives the circuit shown in Fig. 4, which can then be used to evaluate the performance of a quantum software
tool, e.g., to test how well the tool can simulate the circuit or how well it can compile it to a given architecture.
MQT Bench
Code: cda-tum/mqt-bench
Python Package: pypi.org/p/mqt.bench
Documentation: mqt.rtfd.io/projects/bench

VI Open-Source Implementations
All tools that have been developed as part of the MQT are publicly available on github.com/cda-tum. Many of
these tools are powered by MQT Core, which forms the backbone of the entire toolkit. It features a comprehensive
intermediate representation for quantum computations as well as a state-of-the-art decision diagram package for
quantum computing and a dedicated ZX-calculus library.
All tools have been mainly implemented in C++, but strive to be as user-friendly as possible for the community.
Hence, push-button solutions are provided through Python bindings, pre-built Python wheels are available for all
major platforms and Python versions, and all tools integrate natively with IBM’s Qiskit. All tools are actively
maintained and well documented.
MQT Core
Code: cda-tum/mqt-core
Python Package: pypi.org/p/mqt.core
Documentation: mqt.rtfd.io/projects/core

7
VII Conclusions
Design automation tools and software have been crucial for the development of classical circuits and systems. They
enable faster and more reliable design cycles, reduce human errors, and allow for complex and large-scale designs. In
the domain of quantum computing, the corresponding design automation methods (which have been developed over
the past decades) remain heavily underutilized. The Munich Quantum Toolkit (MQT) makes substantial contributions
towards leveraging this latent potential. For many important design tasks, several methods and tools have been
proposed that explicitly use design automation expertise while, at the same time, considering characteristics of
quantum computing. As the quantum computing landscape advances towards Fault-Tolerant Quantum Computing
(FTQC), the MQT aims to support researchers, developers, and practitioners in the near-, middle-, and far-term
future by providing a comprehensive suite of tools and methods.
Acknowledgments
We thank everyone that contributed to the development of the Munich Quantum Toolkit. Special thanks go to Alwin
Zulehner, Stefan Hillmich, Thomas Grurl, Hartwig Bauer, Sarah Schneider, Smaran Adarsh, and Alexander Ploier
for their specific contributions in the past.
The Munich Quantum Toolkit has been supported by the European Union’s Horizon 2020 research and innovation
programme under the ERC Consolidator Grant (agreement No. 101001318), the NeQST Grant (agreement No.
101080086) and MILLENION (agreement No. 101114305). It is part of the Munich Quantum Valley, which is
supported by the Bavarian state government with funds from the Hightech Agenda Bayern Plus, and has been
supported by the BMWK on the basis of a decision by the German Bundestag through project QuaST, as well as
by the BMK, BMDW, the State of Upper Austria in the frame of the COMET program, and the QuantumReady
project within Quantum Austria (managed by the FFG).

References
[1] P. W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing,
1997. doi:10.1137/S0097539795293172.
[2] D. Egger, C. Gambella, J. Marecek, S. McFaddin, M. Mevissen, R. Raymond, A. Simonetto, S. Woerner, and E. Yndurain. Quantum Comput-
ing for Finance: State-of-the-Art and Future Prospects. IEEE Transactions on Quantum Engineering, 2020. doi:10.1109/TQE.2020.3030314.
[3] S. McArdle, S. Endo, A. Aspuru-Guzik, S. C. Benjamin, and X. Yuan. Quantum computational chemistry. Reviews of Modern Physics,
92(1):015003, 2020. doi:10.1103/RevModPhys.92.015003.
[4] H.-Y. Huang, R. Kueng, G. Torlai, V. V. Albert, and J. Preskill. Provably efficient machine learning for quantum many-body problems.
Science, 377(6613):eabk3333, 2022. doi:10.1126/science.abk3333.
[5] S. Harwood, C. Gambella, D. Trenev, A. Simonetto, D. Bernal Neira, and D. Greenberg. Formulating and solving routing problems on
quantum computers. IEEE Transactions on Quantum Engineering, 2:1–17, 2021. doi:10.1109/TQE.2021.3049230.
[6] N. Quetschlich, L. Burgholzer, and R. Wille. Towards an Automated Framework for Realizing Quantum Computing Solutions. In Int'l
Symp. on Multi-Valued Logic. 2023. arXiv:2210.14928, doi:10.1109/ISMVL57333.2023.00035.
[7] N. Quetschlich, V. Koch, L. Burgholzer, and R. Wille. A hybrid classical quantum computing approach to the satellite mission planning
problem. In Int'l Conf. on Quantum Computing and Engineering, volume 01, 642–647. 2023. doi:10.1109/QCE57702.2023.00079.
[8] N. Quetschlich, L. Burgholzer, and R. Wille. Predicting Good Quantum Circuit Compilation Options. In Int'l Conf. on Quantum Software.
2023. arXiv:2210.08027, doi:10.1109/QSW59989.2023.00015.
[9] N. Quetschlich, M. Soeken, P. Murali, and R. Wille. Utilizing resource estimation for the development of quantum computing applications.
2024. arXiv:2402.12434.
[10] N. Quetschlich, F. J. Kiwit, M. A. Wolf, C. A. Riofrio, L. Burgholzer, A. Luckow, and R. Wille. Towards application-aware quantum
circuit compilation. 2024. arXiv:2404.12433.
[11] N. Quetschlich, L. Burgholzer, and R. Wille. MQT Predictor: Automatic device selection with device-specific circuit compilation for
quantum computing. 2023. arXiv:2310.06889.
[12] A. Zulehner and R. Wille. Advanced simulation of quantum computations. IEEE Trans. on CAD of Integrated Circuits and Systems, 2019.
doi:10.1109/TCAD.2018.2834427.
[13] A. Zulehner and R. Wille. Matrix-Vector vs. Matrix-Matrix multiplication: Potential in DD-based simulation of quantum computations. In
Design, Automation and Test in Europe. 2019. doi:10.23919/DATE.2019.8714836.

8
[14] S. Hillmich, I. L. Markov, and R. Wille. Just like the real thing: Fast weak simulation of quantum computation. In Design Automation
Conf. 2020. doi:10.1109/DAC18072.2020.9218555.
[15] S. Hillmich, R. Kueng, I. L. Markov, and R. Wille. As accurate as needed, as efficient as possible: Approximations in DD-based quantum
circuit simulation. In Design, Automation and Test in Europe. 2020. doi:10.23919/DATE51398.2021.9474034.
[16] S. Hillmich, A. Zulehner, R. Kueng, I. L. Markov, and R. Wille. Approximating decision diagrams for quantum circuit simulation. ACM
Transactions on Quantum Computing, 3(4):1–21, 2022. doi:10.1145/3530776.
[17] T. Grurl, J. Fuß, and R. Wille. Considering decoherence errors in the simulation of quantum circuits using decision diagrams. In Int'l
Conf. on CAD. 2020. doi:10.1145/3400302.3415622.
[18] T. Grurl, R. Kueng, J. Fuß, and R. Wille. Stochastic quantum circuit simulation using decision diagrams. In Design, Automation and Test
in Europe. 2021. doi:10.23919/DATE51398.2021.9474135.
[19] T. Grurl, J. Fuß, and R. Wille. Noise-aware quantum circuit simulation with decision diagrams. IEEE Trans. on CAD of Integrated Circuits
and Systems, 42(3):860–873, 2023. doi:10.1109/TCAD.2022.3182628.
[20] L. Burgholzer, H. Bauer, and R. Wille. Hybrid Schrödinger-Feynman simulation of quantum circuits with decision diagrams. In Int'l Conf.
on Quantum Computing and Engineering. 2021. doi:10.1109/QCE52317.2021.00037.
[21] A. Sander, L. Burgholzer, and R. Wille. Towards hamiltonian simulation with decision diagrams. In Int'l Conf. on Quantum Computing
and Engineering. 2023. arXiv:2305.02337, doi:10.1109/QCE57702.2023.00039.
[22] K. Mato, S. Hillmich, and R. Wille. Mixed-dimensional quantum circuit simulation with decision diagrams. In Int'l Conf. on Quantum
Computing and Engineering. 2023. arXiv:2308.12332, doi:10.1109/QCE57702.2023.00112.
[23] S. Hillmich, A. Zulehner, and R. Wille. Concurrency in DD-based quantum circuit simulation. In Asia and South Pacific Design Automation
Conf. 2020. doi:10.1109/ASP-DAC47756.2020.9045711.
[24] L. Burgholzer, A. Ploier, and R. Wille. Exploiting arbitrary paths for the simulation of quantum circuits with decision diagrams. In Design,
Automation and Test in Europe. 2022. doi:10.23919/DATE54114.2022.9774631.
[25] L. Burgholzer, A. Ploier, and R. Wille. Simulation paths for quantum circuit simulation with decision diagrams: What to
learn from tensor networks, and what not. IEEE Trans. on CAD of Integrated Circuits and Systems, 2022. arXiv:2203.00703,
doi:10.1109/TCAD.2022.3197969.
[26] L. Burgholzer, R. Raymond, I. Sengupta, and R. Wille. Efficient construction of functional representations for quantum algorithms. In Int'l
Conf. of Reversible Computation. 2021. doi:10.1007/978-3-030-79837-6_14.
[27] A. Zulehner, A. Paler, and R. Wille. An efficient methodology for mapping quantum circuits to the IBM QX architectures. IEEE Trans.
on CAD of Integrated Circuits and Systems, 2019. doi:10.1109/TCAD.2018.2846658.
[28] S. Hillmich, A. Zulehner, and R. Wille. Exploiting Quantum Teleportation in Quantum Circuit Mapping. In Asia and South Pacific Design
Automation Conf., 792–797. 2021. doi:10.1145/3394885.3431604.
[29] A. Zulehner and R. Wille. Compiling SU(4) quantum circuits to IBM QX architectures. In Asia and South Pacific Design Automation
Conf., 185–190. 2019. doi:10.1145/3287624.3287704.
[30] R. Wille, L. Burgholzer, and A. Zulehner. Mapping quantum circuits to IBM QX architectures using the minimal number of SWAP and
H operations. In Design Automation Conf. 2019. doi:10.1145/3316781.3317859.
[31] L. Burgholzer, S. Schneider, and R. Wille. Limiting the search space in optimal quantum circuit mapping. In Asia and South Pacific Design
Automation Conf. 2022. doi:10.1109/ASP-DAC52403.2022.9712555.
[32] T. Peham, N. Brandl, R. Kueng, R. Wille, and L. Burgholzer. Depth-optimal synthesis of Clifford circuits with SAT solvers. In Int'l Conf.
on Quantum Computing and Engineering. 2023. arXiv:2305.01674, doi:10.1109/QCE57702.2023.00095.
[33] S. Schneider, L. Burgholzer, and R. Wille. A SAT encoding for optimal Clifford circuit synthesis. In Asia and South Pacific Design
Automation Conf. 2023. doi:10.1145/3566097.3567929.
[34] T. Peham, L. Burgholzer, and R. Wille. On Optimal Subarchitectures for Quantum Circuit Mapping. ACM Transactions on Quantum
Computing, 2023. arXiv:2210.09321, doi:10.1145/3593594.
[35] N. Quetschlich, L. Burgholzer, and R. Wille. Compiler Optimization for Quantum Computing Using Reinforcement Learning. In Design
Automation Conf. 2023. arXiv:2212.04508, doi:10.1109/DAC56929.2023.10248002.
[36] N. Quetschlich, L. Burgholzer, and R. Wille. Reducing the compilation time of quantum circuits using pre-compilation on the gate level.
In Int'l Conf. on Quantum Computing and Engineering. 2023. arXiv:2305.04941, doi:10.1109/QCE57702.2023.00091.
[37] D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille. Using Boolean Satisfiability for Exact Shuttling in Trapped-Ion Quantum Computers.
In Asia and South Pacific Design Automation Conf. 2024. doi:10.1109/ASP-DAC58780.2024.10473902.
[38] D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille. Towards Cycle-based Shuttling for Trapped-Ion Quantum Computers. In Design,
Automation and Test in Europe. 2024.
[39] D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille. Shuttling for Scalable Trapped-Ion Quantum Computers. 2024. arXiv:2402.14065.
[40] L. Schmid, S. Park, and R. Wille. Hybrid Circuit Mapping: Leveraging the Full Spectrum of Computational Capabilities of Neutral Atom
Quantum Computers. In Design Automation Conf. 2024.

9
[41] L. Schmid, D. Locher, M. Rispler, S. Blatt, J. Zeiher, M. Müller, and R. Wille. Computational Capabilities and Compiler Development
for Neutral Atom Quantum Processors - Connecting Tool Developers and Hardware Experts. Quantum Science and Technology, 2024.
doi:10.1088/2058-9565/ad33ac.
[42] K. Mato, M. Ringbauer, S. Hillmich, and R. Wille. Adaptive compilation of multi-level quantum operations. In Int'l Conf. on Quantum
Computing and Engineering, 484–491. 2022. doi:10.1109/QCE53715.2022.00070.
[43] K. Mato, M. Ringbauer, S. Hillmich, and R. Wille. Compilation of entangling gates for high-dimensional quantum systems. In Asia and
South Pacific Design Automation Conf., 202–208. 2023. doi:10.1145/3566097.3567930.
[44] K. Mato, S. Hillmich, and R. Wille. Compression of qubit circuits: Mapping to mixed-dimensional quantum systems. In Int'l Conf. on
Quantum Software, 155–161. 2023. doi:10.1109/QSW59989.2023.00027.
[45] K. Mato, S. Hillmich, and R. Wille. Mixed-dimensional qudit state preparation using edge-weighted decision diagrams. In Design
Automation Conf. 2024.
[46] T. Grurl, C. Pichler, J. Fuß, and R. Wille. Automatic Implementation and Evaluation of Error-Correcting Codes for Quantum Computing:
An Open-Source Framework for Quantum Error Correction. In VLSI Design, 301–306. 2023. doi:10.1109/VLSID57277.2023.00068.
[47] L. Burgholzer and R. Wille. Advanced equivalence checking for quantum circuits. IEEE Trans. on CAD of Integrated Circuits and Systems,
2021. doi:10.1109/TCAD.2020.3032630.
[48] L. Burgholzer and R. Wille. Improved DD-based equivalence checking of quantum circuits. In Asia and South Pacific Design Automation
Conf. 2020. doi:10.1109/ASP-DAC47756.2020.9045153.
[49] L. Burgholzer and R. Wille. The power of simulation for equivalence checking in quantum computing. In Design Automation Conf. 2020.
doi:10.1109/DAC18072.2020.9218563.
[50] L. Burgholzer, R. Kueng, and R. Wille. Random stimuli generation for the verification of quantum circuits. In Asia and South Pacific
Design Automation Conf. 2021. doi:10.1145/3394885.3431590.
[51] L. Burgholzer, R. Raymond, and R. Wille. Verifying results of the IBM Qiskit quantum circuit compilation flow. In Int'l Conf. on Quantum
Computing and Engineering. 2020. doi:10.1109/QCE49297.2020.00051.
[52] T. Peham, L. Burgholzer, and R. Wille. Equivalence checking of parameterized quantum circuits: Verifying the compilation of variational
quantum algorithms. In Asia and South Pacific Design Automation Conf. 2023. doi:10.1145/3566097.3567932.
[53] T. Peham, L. Burgholzer, and R. Wille. Equivalence checking of quantum circuits with the ZX-Calculus. IEEE Journal on Emerging and
Selected Topics in Circuits and Systems, 2022. doi:10.1109/JETCAS.2022.3202204.
[54] T. Peham, L. Burgholzer, and R. Wille. Equivalence checking paradigms in quantum circuit design: A case study. In Design Automation
Conf. 2022. doi:10.1145/3489517.3530480.
[55] R. Wille and L. Burgholzer. Verification of Quantum Circuits. In A. Chattopadhyay, editor, Handbook of Computer Architecture, pages
1–28. Springer Nature Singapore, Singapore, 2022. doi:10.1007/978-981-15-6401-7_43-1.
[56] L. Berent, L. Burgholzer, P.-J. H. S. Derks, J. Eisert, and R. Wille. Decoding quantum color codes with MaxSAT. 2023. arXiv:2303.14237.
[57] L. Berent, L. Burgholzer, and R. Wille. Software tools for decoding quantum low-density parity check codes. In Asia and South Pacific
Design Automation Conf. 2023. doi:10.1145/3566097.3567934.
[58] A. Strikis and L. Berent. Quantum low-density parity-check codes for modular architectures. PRX Quantum, 4(2):020321, 2023.
doi:10.1103/PRXQuantum.4.020321.
[59] L. Berent, T. Hillmann, J. Eisert, R. Wille, and J. Roffe. Analog information decoding of bosonic quantum LDPC codes. 2023.
arXiv:2311.01328.
[60] J. Kunasaikaran, K. Mato, and R. Wille. A framework for the design and realization of alternative superconducting quantum architectures.
In Int'l Symp. on Multi-Valued Logic. 2024.
[61] R. Wille, S. Hillmich, and B. Lukas. Tools for quantum computing based on decision diagrams. ACM Transactions on Quantum Computing,
2022. doi:10.1145/3491246.
[62] R. Wille, S. Hillmich, and L. Burgholzer. Decision Diagrams for Quantum Computing. In Design Automation of Quantum Computers.
2023. doi:10.1007/978-3-031-15699-1_1.
[63] J. van de Wetering. ZX-calculus for the working quantum computer scientist. 2020. arXiv:2012.13966.
[64] R. Duncan, A. Kissinger, S. Perdrix, and J. van de Wetering. Graph-theoretic Simplification of Quantum Circuits with the ZX-calculus.
Quantum, 4:279, 2020. doi:10.22331/q-2020-06-04-279.
[65] L. Berent, L. Burgholzer, and R. Wille. Towards a SAT encoding for quantum circuits: A journey from classical circuits to Clif-
ford circuits and beyond. In International Conference on Theory and Applications of Satisfiability Testing. 2022. arXiv:2203.00698,
doi:10.4230/LIPIcs.SAT.2022.18.
[66] T. Häner and D. S. Steiger. 0.5 petabyte simulation of a 45-Qubit quantum circuit. In Int'l Conf. for High Performance Computing,
Networking, Storage and Analysis. 2017. doi:10.1145/3126908.3126947.
[67] J. Doi, H. Takahashi, R. Raymond, T. Imamichi, and H. Horii. Quantum computing simulator on a heterogenous HPC system. In Int'l
Conf. on Computing Frontiers, 85–93. 2019. doi:10.1145/3310273.3323053.

10
[68] T. Jones, A. Brown, I. Bush, and S. C. Benjamin. QuEST and high performance simulation of quantum computers. In Scientific Reports.
2018. doi:10.1038/s41598-019-47174-9.
[69] G. G. Guerreschi, J. Hogaboam, F. Baruffa, and N. P. D. Sawaya. Intel Quantum Simulator: a cloud-ready high-performance simulator of
quantum circuits. Quantum Science and Technology, 5(3):034007, 2020. doi:10.1088/2058-9565/ab8505.
[70] X.-C. Wu, S. Di, E. M. Dasgupta, F. Cappello, H. Finkel, Y. Alexeev, and F. T. Chong. Full-state quantum circuit simulation by using data
compression. In Int'l Conf. for High Performance Computing, Networking, Storage and Analysis. 2019. doi:10.1145/3295500.3356155.
[71] I. L. Markov and \relax Yaoyun. Shi. Simulating quantum computation by contracting tensor networks. SIAM Journal on Computing,
38(3):963–981, 2008. doi:10.1137/050644756.
[72] B. Villalonga, S. Boixo, B. Nelson, C. Henze, E. Rieffel, R. Biswas, and S. Mandrà. A flexible high-performance simulator for verifying
and benchmarking quantum circuits implemented on real hardware. npj Quantum Information, 2019. doi:10.1038/s41534-019-0196-1.
[73] J. Brennan, M. Allalen, D. Brayford, K. Hanley, L. Iapichino, L. J. O'Riordan, M. Doyle, and N. Moran. Tensor Network Cir-
cuit Simulation at Exascale. In International Workshop on Quantum Computing Software (QCS), 20–26. IEEE, November 2021.
doi:10.1109/QCS54837.2021.00006.
[74] T. Vincent, L. J. O'Riordan, M. Andrenkov, J. Brown, N. Killoran, H. Qi, and I. Dhand. Jet: Fast quantum circuit simulations with parallel
task-based tensor-network contraction. Quantum, 6:709, 2022. doi:10.22331/q-2022-05-09-709.
[75] G. F. Viamontes, I. L. Markov, and J. P. Hayes. Improving gate-level simulation of quantum circuits. Quantum Information Processing,
2(5):347–380, 2003. doi:10.1023/B:QINP.0000022725.70000.4a.
[76] A. Botea, A. Kishimoto, and R. Marinescu. On the complexity of quantum circuit compilation. In Int'l Symp. on Combinatorial Search.
2018. doi:10.1609/socs.v9i1.18463.
[77] R. Drechsler. Advanced Formal Verification. Springer, 2004. doi:10.5555/1024203.
[78] D. Janzing, P. Wocjan, and T. Beth. “Non-identity check” is QMA-complete. International Journal of Quantum Information, 03(03):463–473,
2005. doi:10.1142/S0219749905001067.
[79] N. Quetschlich, L. Burgholzer, and R. Wille. MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing.
Quantum, 7:1062, 2023. doi:10.22331/q-2023-07-20-1062.

11