arXiv subjects

Lukas Burgholzer

Publications and source records attributed to Lukas Burgholzer.

At least 37 records · Page 2Linked to original sources

arXiv2025

A Framework for the Efficient Evaluation of Runtime Assertions on Quantum Computers

The continuous growth of quantum computing and the increasingly complex quantum programs resulting from it lead to unprecedented obstacles in ensuring program correctness. Runtime assertions are, therefore, becoming a crucial tool in the development of quantum programs. They assist developers in the debugging process and help to test and verify the program. However, while assertions can be implemented in a straightforward manner on classical computers, physical limitations of quantum computers pose considerable challenges for the evaluation of quantum assertions. Access to the quantum state of a program is limited, execution time is expensive and noise can significantly distort measurement outcomes. To address these problems, this work proposes a framework that assists developers in the evaluation of runtime assertions on real quantum computers. It translates a variety of assertions into sets of measurements, reduces execution overhead where possible and evaluates the measurement results after the execution even in the presence of noise. This approach substantially aids developers in the debugging process, enabling efficient assertion-driven debugging even in large programs. The proposed framework is available as an open-source implementation at https://github.com/munich-quantum-toolkit/debugger

quant-ph↗

arXiv2025

Joint Cutting for Hybrid Schrödinger-Feynman Simulation of Quantum Circuits

Despite the continuous advancements in size and robustness of real quantum devices, reliable large-scale quantum computers are not yet available. Hence, classical simulation of quantum algorithms remains crucial for testing new methods and estimating quantum advantage. Pushing classical simulation methods to their limit is essential, particularly due to their inherent exponential complexity. Besides the established Schrödinger-style full statevector simulation, so-called Hybrid Schrödinger-Feynman (HSF) approaches have shown promise to make simulations more efficient. HSF simulation employs the idea of "cutting" the circuit into smaller parts, reducing their execution times. This, however, comes at the cost of an exponential overhead in the number of cuts. Inspired by the domain of Quantum Circuit Cutting, we propose an HSF simulation method based on the idea of "joint cutting" to significantly reduce the aforementioned overhead. This means that, prior to the cutting procedure, gates are collected into "blocks" and all gates in a block are jointly cut instead of individually. We investigate how the proposed refinement can help decrease simulation times and highlight the remaining challenges. Experimental evaluations show that "joint cutting" can outperform the standard HSF simulation by up to a factor $\approx 4000\times$ and the Schrödinger-style simulation by a factor $\approx 200\times$ for suitable instances. The implementation is available at https://github.com/cda-tum/mqt-qsim-joint-cutting.

quant-ph↗

arXiv2025

Optimal State Preparation for Logical Arrays on Zoned Neutral Atom Quantum Computers

Quantum computing promises to solve problems previously deemed infeasible. However, high error rates necessitate quantum error correction for practical applications. Seminal experiments with zoned neutral atom architectures have shown remarkable potential for fault-tolerant quantum computing. To fully harness their potential, efficient software solutions are vital. A key aspect of quantum error correction is the initialization of physical qubits representing a logical qubit in a highly entangled state. This process, known as state preparation, is the foundation of most quantum error correction codes and, hence, a crucial step towards fault-tolerant quantum computing. Generating a schedule of target-specific instructions to perform the state preparation is highly complex. First software tools exist but are not suitable for the zoned neutral atom architectures. This work addresses this gap by leveraging the computational power of SMT solvers and generating minimal schedules for the state preparation of logical arrays. Experimental evaluations demonstrate that actively utilizing zones to shield idling qubits consistently results in higher fidelities than solutions disregarding these zones. The complete code is publicly available in open-source as part of the Munich Quantum Toolkit (MQT) at https://github.com/cda-tum/mqt-qmap/tree/main/src/na/nasp.

quant-ph↗

arXiv2024

Automatically Refining Assertions for Efficient Debugging of Quantum Programs

As new advancements in the field of quantum computing lead to the development of increasingly complex programs, approaches to validate and debug these programs are becoming more important. To this end, methods employed in classical debugging, such as assertions for testing specific properties of a program's state, have been adapted for quantum programs. However, to efficiently debug quantum programs, it is key to properly place these assertions. This usually requires a deep understanding of the program's underlying mathematical properties, constituting a time-consuming manual task for developers. To address this problem, this work proposes methods for automatically refining assertions in quantum programs by moving them to more favorable positions in the program or by placing new assertions that help to further narrow down potential error locations. This allows developers to take advantage of rich and expressive assertions that greatly improve the debugging experience without requiring them to place these assertions manually in an otherwise tedious manner. An open-source implementation of the proposed methods is available at https://github.com/cdatum/mqt-debugger.

quant-ph↗

arXiv2024

A Framework for Debugging Quantum Programs

Recent advancements in quantum computing software are gradually increasing the scope and size of quantum programs being developed. At the same time, however, these larger programs provide more possibilities for functional errors that are harder to detect and resolve. Meanwhile, debugging tools that could aid developers in resolving these errors are still barely existent and far from what we take for granted in classical design automation and software engineering. As a result, even if one manages to identify the incorrect behavior of a developed quantum program, detecting and resolving the underlying errors in the program remains a time-consuming and tedious task. Moreover, the exponential growth of the state space in quantum programs makes the efficient manual investigation of errors radically difficult even for respectively simple algorithms, and almost impossible as the number of qubits increases. To address this problem, this work proposes a debugging framework, available as an open-source implementation at https://github.com/cda-tum/mqt-debugger. It assists developers in debugging errors in quantum programs, allowing them to efficiently identify the existence of errors and diagnose their causes. Users are given the ability to place assertions in the code that test for the correctness of a given algorithm and are evaluated using classical simulations of the underlying quantum program. Once an assertion fails, the proposed framework employs different diagnostic methods to point towards possible error causes. This way, the debugging workload for quantum programs is drastically reduced.

quant-ph↗

arXiv2024

Decoding quantum color codes with MaxSAT

In classical computing, error-correcting codes are well established and are ubiquitous both in theory and practical applications. For quantum computing, error-correction is essential as well, but harder to realize, coming along with substantial resource overheads and being concomitant with needs for substantial classical computing. Quantum error-correcting codes play a central role on the avenue towards fault-tolerant quantum computation beyond presumed near-term applications. Among those, color codes constitute a particularly important class of quantum codes that have gained interest in recent years due to favourable properties over other codes. As in classical computing, decoding is the problem of inferring an operation to restore an uncorrupted state from a corrupted one and is central in the development of fault-tolerant quantum devices. In this work, we show how the decoding problem for color codes can be reduced to a slight variation of the well-known LightsOut puzzle. We propose a novel decoder for quantum color codes using a formulation as a MaxSAT problem based on this analogy. Furthermore, we optimize the MaxSAT construction and show numerically that the decoding performance of the proposed decoder achieves state-of-the-art decoding performance on color codes. The implementation of the decoder as well as tools to automatically conduct numerical experiments are publicly available as part of the Munich Quantum Toolkit (MQT) on GitHub.

quant-ph↗

arXiv2024

MQT Qudits: A Software Framework for Mixed-Dimensional Quantum Computing

Quantum computing holds great promise for surpassing the limits of classical devices in many fields. Despite impressive developments, however, current research is primarily focused on qubits. At the same time, quantum hardware based on multi-level, qudit, systems offers a range of advantages, including expanded gate sets, higher information density, and improved computational efficiency, which might play a key role in overcoming not only the limitations of classical machines but also of current qubit-based quantum devices. However, working with qudits faces challenges not only in experimental control but particularly in algorithm development and quantum software. In this work, we introduce MQT Qudits, an open-source tool, which, as part of the Munich Quantum Toolkit (MQT), is built to assist in designing and implementing applications for mixed-dimensional qudit devices. We specify a standardized language for mixed-dimension systems and discuss circuit specification, compilation to hardware gate sets, efficient circuit simulation, and open challenges. MQT Qudits is available at github.com/cda-tum/mqt-qudits and on pypi at pypi.org/project/mqt.qudits.

quant-ph↗

arXiv2024

MQT Predictor: Automatic Device Selection with Device-Specific Circuit Compilation for Quantum Computing

Fueled by recent accomplishments in quantum computing hardware and software, an increasing number of problems from various application domains are being explored as potential use cases for this new technology. Similarly to classical computing, realizing an application on a particular quantum device requires the corresponding (quantum) circuit to be compiled so that it can be executed on the device. With a steadily growing number of available devices and a wide variety of different compilation tools, the number of choices to consider when trying to realize an application is quickly exploding. Due to missing tool support and automation, especially end-users who are not quantum computing experts are easily left unsupported and overwhelmed. In this work, we propose a methodology that allows one to automatically select a suitable quantum device for a particular application and provides an optimized compiler for the selected device. The resulting framework -- called the MQT Predictor -- not only supports end-users in navigating the vast landscape of choices, it also allows mixing and matching compiler passes from various tools to create optimized compilers that transcend the individual tools. Evaluations of an exemplary framework instantiation based on more than 500 quantum circuits and seven devices have shown that -- compared to both Qiskit's and TKET's most optimized compilation flows for all devices -- the MQT Predictor produces circuits within the top-3 out of 14 baselines in more than 98% of cases while frequently outperforming any tested combination by up to 53% when optimizing for expected fidelity. MQT Predictor is publicly available as open-source on GitHub (https://github.com/cda-tum/mqt-predictor) and as an easy-to-use Python package (https://pypi.org/p/mqt.predictor).

quant-ph↗

arXiv2024

An Abstract Model and Efficient Routing for Logical Entangling Gates on Zoned Neutral Atom Architectures

Recent experimental achievements have demonstrated the potential of neutral atom architectures for fault-tolerant quantum computing. These architectures feature the dynamic rearrangement of atoms during computation, enabling nearly arbitrary two-dimensional rearrangements. Additionally, they employ a zoned layout with dedicated regions for entangling, storage, and readout. This architecture requires design automation software that efficiently compiles quantum circuits to this hardware and takes care that atoms are in the right place at the right time. In this paper, we initiate this line of work by providing, (1) an abstract model of the novel architecture and, (2) an efficient solution to the routing problem of entangling gates. By this, we aim to maximize the parallelism of entangling gates and minimize the overhead caused by the routing of atoms between zones. In addition to that, we keep the realm of fault-tolerant quantum computing in mind and consider logical qubit arrays, each of which encodes one logical qubit. We implemented the proposed idea as a tool called NALAC and demonstrated its effectiveness and efficiency by showing that it can significantly reduce the routing overhead of logical entangling gates compared to the naive approach. As part of the Munich Quantum Toolkit (MQT), NALAC is publicly available as open-source at https://github.com/cda-tum/mqt-qmap.

quant-ph↗

arXiv2024

Stripping Quantum Decision Diagrams of their Identity

Classical representations of quantum states and operations as vectors and matrices are plagued by an exponential growth in memory and runtime requirements for increasing system sizes. Based on their use in classical computing, an alternative data structure known as Decision Diagrams (DDs) has been proposed, which, in many cases, provides both a more compact representation and more efficient computation. In the classical realm, decades of research have been conducted on DDs and numerous variations tailored for specific applications exist. However, DDs for quantum computing are just in their infancy and there is still room for tailoring them to this new technology. In particular, existing representations of DDs require extending all operations in a quantum circuit to the full system size through extension by nodes representing identity matrices. In this work, we make an important step forward for quantum DDs by stripping these identity structures from quantum operations. This significantly reduces the number of nodes required to represent them as well as eases the pressure on key building blocks of their implementation. As a result, we obtain a structure that is more natural for quantum computing and significantly speeds up with computations-with a runtime improvement of up to 70x compared to the state-of-the-art.

quant-ph↗

arXiv2024

Towards Application-Aware Quantum Circuit Compilation

Quantum computing has made tremendous improvements in both software and hardware that have sparked interest in academia and industry to realize quantum computing applications. To this end, several steps are necessary: The underlying problem must be encoded in a quantum circuit, a suitable device must be selected to execute it, and it must be compiled accordingly. This compilation step has a significant influence on the quality of the resulting solution. However, current state-of-the-art compilation tools treat the quantum circuit as a sequence of instructions without considering the actual application it realizes -- wasting a yet untapped potential to increase the solution quality. In this work, a different approach is explored that explicitly incorporates the application considered and aims to optimize its solution quality during compilation. Initial results show the benefits of this approach: For an industry-inspired application of a quantum generative model, the proposed approach outperformed Qiskit's most-optimized compilation scheme and led to better solution quality. Therefore, this work presents a first step towards application-aware compilation.

quant-ph↗

arXiv2024

The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing

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 https://github.com/cda-tum.

quant-ph↗

arXiv2024

Forward and Backward Constrained Bisimulations for Quantum Circuits using Decision Diagrams

Efficient methods for the simulation of quantum circuits on classic computers are crucial for their analysis due to the exponential growth of the problem size with the number of qubits. Here we study lumping methods based on bisimulation, an established class of techniques that has been proven successful for (classic) stochastic and deterministic systems such as Markov chains and ordinary differential equations. Forward constrained bisimulation yields a lower-dimensional model which exactly preserves quantum measurements projected on a linear subspace of interest. Backward constrained bisimulation gives a reduction that is valid on a subspace containing the circuit input, from which the circuit result can be fully recovered. We provide an algorithm to compute the constraint bisimulations yielding coarsest reductions in both cases, using a duality result relating the two notions. As applications, we provide theoretical bounds on the size of the reduced state space for well-known quantum algorithms for search, optimization, and factorization. Using a prototype implementation, we report significant reductions on a set of benchmarks. In particular, we show that constrained bisimulation can boost decision-diagram-based quantum circuit simulation by several orders of magnitude, allowing thus for substantial synergy effects.

quant-ph↗

arXiv2024

Towards Hamiltonian Simulation with Decision Diagrams

This paper proposes a novel approach to Hamiltonian simulation using Decision Diagrams (DDs), which are an exact representation based on exploiting redundancies in representations of quantum states and operations. While the simulation of Hamiltonians has been studied extensively, scaling these simulations to larger or more complex systems is often challenging and may require approximations or new simulation methods altogether. DDs offer such an alternative that has not yet been applied to Hamiltonian simulation. In this work, we investigate the behavior of DDs for this task. To this end, we review the basics of DDs such as their construction and present how the relevant operations for Hamiltonian simulation are implemented in this data structure -- leading to the first DD-based Hamiltonian simulation approach. Based on several series of evaluations and comparisons, we then discuss insights about the performance of this complementary approach. Overall, these studies show that DDs indeed may offer a promising new data structure which, for certain examples, can provide orders of magnitudes of improvement compared to the state-of-the-art, yet also comes with its own, fundamentally different, limitations.

quant-ph↗

arXiv2023

Recommending Solution Paths for Solving Optimization Problems with Quantum Computing

Solving real-world optimization problems with quantum computing requires choosing between a large number of options concerning formulation, encoding, algorithm and hardware. Finding good solution paths is challenging for end users and researchers alike. We propose a framework designed to identify and recommend the best-suited solution paths. This introduces a novel abstraction layer that is required to make quantum-computing-assisted solution techniques accessible to end users without requiring a deeper knowledge of quantum technologies. State-of-the-art hybrid algorithms, encoding and decomposition techniques can be integrated in a modular manner and evaluated using problem-specific performance metrics. Equally, tools for the graphical analysis of variational quantum algorithms are developed. Classical, fault tolerant quantum and quantum-inspired methods can be included as well to ensure a fair comparison resulting in useful solution paths. We demonstrate and validate our approach on a selected set of options and illustrate its application on the capacitated vehicle routing problem (CVRP). We also identify crucial requirements and the major design challenges for the proposed automation layer within a quantum-assisted solution workflow for optimization problems.

quant-ph↗

arXiv2023

A Hybrid Classical Quantum Computing Approach to the Satellite Mission Planning Problem

Hundreds of satellites equipped with cameras orbit the Earth to capture images from locations for various purposes. Since the field of view of the cameras is usually very narrow, the optics have to be adjusted and rotated between single shots of different locations. This is even further complicated by the fixed speed -- determined by the satellite's altitude -- such that the decision what locations to select for imaging becomes even more complex. Therefore, classical algorithms for this Satellite Mission Planning Problem (SMPP) have already been proposed decades ago. However, corresponding classical solutions have only seen evolutionary enhancements since then. Quantum computing and its promises, on the other hand, provide the potential for revolutionary improvement. Therefore, in this work, we propose a hybrid classical quantum computing approach to solve the SMPP combining the advantages of quantum hardware with decades of classical optimizer development. Using the Variational Quantum Eigensolver (VQE), Quantum Approximate Optimization Algorithm (QAOA), and its warm-start variant (W-QAOA), we demonstrate the applicability of solving the SMPP for up to 21 locations to choose from. This proof-of-concept -- which is available on GitHub (https://github.com/cda-tum/mqt-problemsolver) as part of the Munich Quantum Toolkit (MQT) -- showcases the potential of quantum computing in this application domain and represents a first step toward competing with classical algorithms in the future.

quant-ph↗

arXiv2023

Reducing the Compilation Time of Quantum Circuits Using Pre-Compilation on the Gate Level

In order to implement a quantum computing application, problem instances must be encoded into a quantum circuit and then compiled for a specific platform. The lengthy compilation process is a key bottleneck in this workflow, especially for problems that arise repeatedly with a similar yet distinct structure (each of which requires a new compilation run thus far). In this paper, we aim to overcome this bottleneck by proposing a comprehensive pre-compilation technique that tries to minimize the time spent for compiling recurring problems while preserving the solution quality as much as possible. The following concepts underpin the proposed approach: Beginning with a problem class and a corresponding quantum algorithm, a predictive encoding scheme is applied to encode a representative problem instance into a general-purpose quantum circuit for that problem class. Once the real problem instance is known, the previously constructed circuit only needs to be adjusted -- with (nearly) no compilation necessary. Experimental evaluations on QAOA for the MaxCut problem as well as a case study involving a satellite mission planning problem show that the proposed approach significantly reduces the compilation time by several orders of magnitude compared to Qiskit's compilation schemes while maintaining comparable compiled circuit quality. All implementations are available on GitHub (https://github.com/cda-tum/mqt-problemsolver) as part of the Munich Quantum Toolkit (MQT).

quant-ph↗

arXiv2023

MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing

Quantum software tools for a wide variety of design tasks on and across different levels of abstraction are crucial in order to eventually realize useful quantum applications. This requires practical and relevant benchmarks for new software tools to be empirically evaluated and compared to the current state of the art. Although benchmarks for specific design tasks are commonly available, the demand for an overarching cross-level benchmark suite has not yet been fully met and there is no mutual consolidation in how quantum software tools are evaluated thus far. In this work, we propose the MQT Bench benchmark suite (as part of the Munich Quantum Toolkit, MQT) based on four core traits: (1) cross-level support for different abstraction levels, (2) accessibility via an easy-to-use web interface (https://www.cda.cit.tum.de/mqtbench) and a Python package, (3) provision of a broad selection of benchmarks to facilitate generalizability, as well as (4) extendability to future algorithms, gate-sets, and hardware architectures. By comprising more than 70,000 benchmark circuits ranging from 2 to 130 qubits on four abstraction levels, MQT Bench presents a first step towards benchmarking different abstraction levels with a single benchmark suite to increase comparability, reproducibility, and transparency.

quant-ph↗