The MQT Handbook¶
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.
For a comprehensive visual depiction of the MQT tools, we invite you to download our MQT Flyer.
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.
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].
Consider the following listing that describes the quantum circuit for generating a three-qubit GHZ state (also shown in Fig. 1):
1from qiskit import QuantumCircuit
2
3circ = QuantumCircuit(3)
4circ.h(2)
5circ.cx(2, 1)
6circ.cx(1, 0)
7circ.measure_all()
Quantum circuit for generating a three-qubit GHZ state.¶
This circuit can be classically simulated using DDSIM as a backend for IBM Qiskit:
1from mqt.ddsim import DDSIMProvider
2
3provider = DDSIMProvider()
4backend = provider.get_backend("qasm_simulator")
5result = backend.run(circ, shots=10000).result()
6result.get_counts()
{'000': 4981, '111': 5019}
(venv) $ pip install mqt.ddsim
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].
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].
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.
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.
1from mqt.qmap import compile
2from qiskit.providers.fake_provider import Fake5QV1
3
4backend = Fake5QV1()
5circ_mapped, results = compile(circ, backend)
(venv) $ pip install mqt.qmap
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 \(G=g_1,\dots,g_m\) and \(G'=g'_1,\dots,g'_n\) 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., \(G^{\prime -1}= (g'_n)^\dagger,\dots,(g'_1)^\dagger\). If two circuits are equivalent, this allows for the conclusion that \(G\cdot G^{\prime -1} = I\), where \(I\) 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.
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:
1from mqt.qcec import verify
2
3result = verify(circ, circ_mapped)
4print(result.equivalence)
equivalent
(venv) $ pip install mqt.qcec
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.
A larger version of the quantum circuit from Fig. 1 can easily be obtained programmatically from the MQT Bench Python package as follows:
1from mqt.bench import get_benchmark
2
3circ = get_benchmark("ghz", circuit_size=8, level="alg")
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.
(venv) $ pip install mqt.bench
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.
(venv) $ pip install mqt.core
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.
References¶
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.
D. Egger, C. Gambella, J. Marecek, S. McFaddin, M. Mevissen, R. Raymond, A. Simonetto, S. Woerner, and E. Yndurain. Quantum Computing for Finance: State-of-the-Art and Future Prospects. IEEE Transactions on Quantum Engineering, 2020. doi:10.1109/TQE.2020.3030314.
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.
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.
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.
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.
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.
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.
N. Quetschlich, M. Soeken, P. Murali, and R. Wille. Utilizing resource estimation for the development of quantum computing applications. 2024. arXiv:2402.12434.
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.
N. Quetschlich, L. Burgholzer, and R. Wille. MQT Predictor: Automatic device selection with device-specific circuit compilation for quantum computing. 2023. arXiv:2310.06889.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
D. Schoenberger, S. Hillmich, M. Brandl, and R. Wille. Shuttling for Scalable Trapped-Ion Quantum Computers. 2024. arXiv:2402.14065.
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.
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.
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.
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.
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.
K. Mato, S. Hillmich, and R. Wille. Mixed-dimensional qudit state preparation using edge-weighted decision diagrams. In Design Automation Conf. 2024.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
L. Berent, L. Burgholzer, P.-J. H. S. Derks, J. Eisert, and R. Wille. Decoding quantum color codes with MaxSAT. 2023. arXiv:2303.14237.
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.
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.
L. Berent, T. Hillmann, J. Eisert, R. Wille, and J. Roffe. Analog information decoding of bosonic quantum LDPC codes. 2023. arXiv:2311.01328.
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.
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.
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.
J. van de Wetering. ZX-calculus for the working quantum computer scientist. 2020. arXiv:2012.13966.
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.
L. Berent, L. Burgholzer, and R. Wille. Towards a SAT encoding for quantum circuits: A journey from classical circuits to Clifford circuits and beyond. In International Conference on Theory and Applications of Satisfiability Testing. 2022. arXiv:2203.00698, doi:10.4230/LIPIcs.SAT.2022.18.
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.
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.
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.
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.
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.
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.
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.
J. Brennan, M. Allalen, D. Brayford, K. Hanley, L. Iapichino, L. J. O'Riordan, M. Doyle, and N. Moran. Tensor Network Circuit Simulation at Exascale. In International Workshop on Quantum Computing Software (QCS), 20–26. IEEE, November 2021. doi:10.1109/QCS54837.2021.00006.
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.
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.
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.
R. Drechsler. Advanced Formal Verification. Springer, 2004. doi:10.5555/1024203.
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.
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.
Overview of Tools¶
The following gives an overview of all repositories, ordered along the quantum software stack from high-level Applications to Physical Design.
Application¶
A Quantum Circuit Benchmark Suite
(venv) $ pip install mqt.bench
A Tool for Solving Problems Using Quantum Computing
(venv) $ pip install mqt.problemsolver
A framework for the automatic generation of QUBO formulations for optimization problems.
(venv) $ pip install mqt.qubomaker
Simulation¶
A Tool for Classical Quantum Circuit Simulation based on Decision Diagrams
(venv) $ pip install mqt.ddsim
Compilation¶
A Tool for Determining Good Quantum Circuit Compilation Options
(venv) $ pip install mqt.predictor
A Tool for Quantum Circuit Mapping
(venv) $ pip install mqt.qmap
A Tool for Generating Shuttling Schedules for QCCD Architectures
A Framework For Mixed-Dimensional Qudit Quantum Computing
A Tool for the Synthesis of Reversible Circuits/Quantum Computing Oracles
(venv) $ pip install mqt.syrec
Verification¶
A Tool for Quantum Circuit Equivalence Checking
(venv) $ pip install mqt.qcec
Quantum Error Correction¶
A Tool for Quantum Error Correcting Codes
(venv) $ pip install mqt.qecc
Data Structures and Core Methods¶
The Backbone of the Munich Quantum Toolkit.
Quantum IR | DD Package | ZX Package
(venv) $ pip install mqt.core
A Web-Application Visualizing Decision Diagrams for Quantum Computing
A Tool for Encoding Quantum Computing using Satisfiability Testing (SAT) Techniques
(venv) $ pip install mqt.qusat
Physical Design¶
A Tool for Designing Alternative Superconducting Quantum Architectures
Stats¶
Top-5 Star History¶
GitHub Information¶
Projekt |
latest version |
forks |
stars |
|---|---|---|---|
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
PyPI Downloads¶
Projekt |
latest version |
weekly |
monthly |
total |
|---|---|---|---|---|
