In 2019 a quantum computer took 200 seconds for a task for which a state-of-the-art classical supercomputer would need roughly 10,000 years. Quantum supremacy was shown and the development of quantum technology proceeds quickly. However, several aspects limit the implementation and execution of quantum circuits. The vendors of quantum computers provide their own proprietary software development kit (SDK) to execute quantum circuits on their quantum processing units (QPUs). Furthermore, the computers differ regarding various properties like the native gate set and the qubit connectivity. Therefore, quantum circuits cannot be executed on arbitrary QPUs, but there exists a tight coupling between a QPU and a quantum algorithm implementation. To decouple the development of a circuit from the QPU, this thesis proposes a quantum circuit analysis and transpilation framework that integrates quantum SDKs and enables the comparison and analysis of quantum circuits, as well as the export of executable circuits in the respective assembly language of QPUs from different vendors. Currently existing QPUs, also called Noisy Intermediate-Scale Quantum (NISQ) machines, have a very limited number of qubits and are prone to failure. Thus, the integration of different QPUs enhances the possibilities of quantum circuit developers and avoids the SDK lock-in. Additionally, a graphical user interface is developed to support the user in the whole process of importing, visualizing, editing, and simulating a quantum circuit, as well as, choosing a suitable QPU to execute the circuit.
In 2019 a quantum computer took 200 seconds for a task for which a state-of-the-art classical supercomputer would need roughly 10,000 years. Quantum supremacy was shown and the development of quantum technology proceeds quickly. However, several aspects limit the implementation and execution of quantum circuits. The vendors of quantum computers provide their own proprietary software development kit (SDK) to execute quantum circuits on their quantum processing units (QPUs). Furthermore, the computers differ regarding various properties like the native gate set and the qubit connectivity. Therefore, quantum circuits cannot be executed on arbitrary QPUs, but there exists a tight coupling between a QPU and a quantum algorithm implementation. To decouple the development of a circuit from the QPU, this thesis proposes a quantum circuit analysis and transpilation framework that integrates quantum SDKs and enables the comparison and analysis of quantum circuits, as well as the export of executable circuits in the respective assembly language of QPUs from different vendors. Currently existing QPUs, also called Noisy Intermediate-Scale Quantum (NISQ) machines, have a very limited number of qubits and are prone to failure. Thus, the integration of different QPUs enhances the possibilities of quantum circuit developers and avoids the SDK lock-in. Additionally, a graphical user interface is developed to support the user in the whole process of importing, visualizing, editing, and simulating a quantum circuit, as well as, choosing a suitable QPU to execute the circuit.
One of the major obstacles to the adoption of quantum computing is the requirement to define quantum circuits at the quantum gate level. Many programmers are familiar with high-level or low-level programming languages but not quantum gates nor the low-level quantum logic required to derive useful results from quantum computers. The steep learning curve involved when progressing from quantum gates to complex simulations such as Shor's algorithm has proven too much for many developers. The purpose of this paper and the software presented within, addresses this challenge by providing a Software Development Kit (SDK), translation layer, emulator and a framework of techniques for executing Intel 8080/Z80 assembler on a quantum computer, i.e. all salient points of CPU execution, logic, arithmetic and bitwise manipulation will be executed on the quantum computer using quantum circuits. This provides a novel means of displaying the equivalency and interoperability of quantum and classical computers. Developers and researchers can use the SDK to write code in Intel 8080/Z80 assembler which is executed locally via traditional emulation and remotely on a quantum computer in parallel. The emulator features side-by-side code execution with visibility of the running quantum circuit and re-usable/overridable methods. This enables programmers to learn, reuse and contrast techniques for performing any traditional CPU based technique/instruction on a quantum computer; e.g. a programmer may know how to multiply and perform checks on a classical CPU but is not able to perform the same tasks in a quantum implementation, this SDK allows the programmer to pick and choose the methods they would like to use to fulfil their requirements. The SDK makes use of open-source software, specifically Python and Qiskit for the emulation, translation, API calls and execution of user supplied code or binaries.
There is a steady growth in research and demand for real quan- tum hardware in the Noisy Intermediate-Scale Quantum (NISQ) era of quantum computing. This prompts many third-party cloud providers to set up quantum hardware as a service that includes a wide range of qubit technologies and architectures to maximize performance at minimal cost. Quantum circuits submitted to these services are the fruits of the efforts invested by the designers. But these third-party cloud compilers (who offer more efficient alter- natives to established compilers) can make user circuits/programs vulnerable to various security breaches. Communication channels for transmitting quantum information also need to be developed such that there is end to end encryption. There is little to no visibil- ity on where the execution of the circuit is actually taking place. The success of the user program is highly reliant on the backend that was used for execution. Besides, the third-party provider and/or tools (e.g., hardware mapper and allocator) may be untrustworthy and execute the quantum circuits on less efficient and more error- prone hardware to conserve resources and maximize profit. These vulnerabilities in the quantum system could leak confidential data, cause loss of intellectual property rights of designers, cause loss of access control, corrupt user programs et cetera. Thus, it is imper- ative to identify these security vulnerabilities and create defense strategies to protect quantum programs, thus helping to maintain the integrity of quantum information across the software stack. My thesis aims to help address these vulnerabilities and opacities and address them.
In this study, we present a comprehensive evaluation of popular SDK-to-SDK quantum transpilers (that is transpilers that takes a quantum circuit from an initial SDK and output a quantum circuit in another SDK), focusing on critical metrics such as correctness, failure rate, and transpilation time. To ensure unbiased evaluation and accommodate diverse quantum computing scenarios, we developed two dedicated tools: RandomQC, for generating random quantum circuits across various types (pure random, VQE-like, and SDK-specific circuits), and Benchmarq, to streamline the benchmarking process. Using these tools, we benchmarked prominent quantum transpilers as of February 2024. Our results highlight the superior performance of the qiskit-braket-provider, a specialized transpiler from Qiskit to Braket, achieving a remarkably low failure rate of 0. 2 %. The qBraid-SDK, offering generalized transpilation across multiple SDKs, demonstrated robust but slower performance. The pytket extensions, while fast, faced limitations with complex circuits due to their one-to-one transpilation approach. In particular, the exceptional performance of the qiskit-bracket-provider stems not only from its specialization but also from its architecture, which combines one-to-one transpilation with gate decomposition for unsupported gates, enhancing both speed and capability. This study aims to provide practical guidelines to users of SDK-to-SDK quantum transpilers and guidance to developers for improving the design and development of future tools.
Despite rapid progress in quantum computing in the last decade, the limited usability of quantum computers remains a major roadblock toward its wider adoption. Current noisy intermediate-scale quantum (NISQ) computers produce highly erroneous program outputs for quantum-advantage-proven algorithms - that is, algorithms that are infeasible or orders of magnitude slower on classical supercomputing and high-performance computing (HPC) clusters. Unfortunately, currently, quantum computing programmers lack robust system software tools and methods to make meaningful use of erroneous program executions on quantum computers. This lack of capability is the core motivation behind the fundamental question this dissertation poses: "Can we build system software tools for programmers to make the quantum program execution and output meaningful on NISQ machines?" This dissertation answers this question in the affirmative - experimentally demonstrating on real-system quantum computers that it is possible to extract near-accurate program output from noisy executions on today's erroneous quantum computers, ironically using classical HPC resources and knowledge. This dissertation demonstrates how to achieve this goal without requiring user intervention, domain knowledge about quantum algorithms, or additional quantum hardware support. Unfortunately, as this dissertation uncovers, progressing toward making quantum computers usable is a double-edged sword. In the near future, only a few entities in the world may have access to powerful quantum computers, and these quantum computers will be used to solve previously-unsolved large-scale optimization problems, possibly without an explicit trust model between the service provider and the customer. Therefore, this dissertation envisions that the solutions to such large-scale optimization problems will be considered sensitive and will need to be protected. This dissertation takes the first few steps toward preparing us for that future - by developing a novel method that intelligently obfuscates near-accurate program output and quantum circuit structure to preserve a customer's privacy under a specified computation model and resource availability. The approaches introduced in this dissertation open up new research avenues for hybrid quantum-classical computing. This dissertation also aims to lower the barrier to entry for quantum computing research for the experimental computer systems and HPC community by open-sourcing multiple novel datasets and software frameworks implemented for real-system quantum computers.--Author's abstract
Noisy Intermediate-Scale Quantum (NISQ) machines are not fault-tolerant, operate few qubits (currently, less than hundred), but are capable of executing interesting computations. Above the quantum supremacy threshold (approx. 60 qubits), NISQ machines are expected to be more powerful than existing classical computers. One of the most stringent problems is that computations (expressed as quantum circuits) have to be adapted (compiled) to the NISQ hardware, because the hardware does not support arbitrary interactions between the qubits. This procedure introduces additional gates (e.g. SWAP gates) into the circuits while leaving the implemented computations unchanged. Each additional gate increases the failure rate of the adapted (compiled) circuits, because the hardware and the circuits are not fault-tolerant. It is reasonable to expect that the placement influences the number of additionally introduced gates. Therefore, a combinatorial problem arises: how are circuit qubits allocated (placed) initially to the hardware qubits? The novelty of this work relies on the methodology used to investigate the influence of the initial placement. To this end, we introduce a novel heuristic and cost model to estimate the number of gates necessary to adapt a circuit to a given NISQ architecture. We implement the heuristic (source code available on github) and benchmark it using a standard compiler (e.g. from IBM Qiskit) treated as a black box. Preliminary results indicate that cost reductions of up to 10\% can be achieved for practical circuit instances on realistic NISQ architectures only by placing qubits differently than default (trivial placement).
Robust execution environments are important for addressing key challenges in quantum computing, such as application development, portability, and reproducibility, and help unlock the development of modular quantum programs, driving forward hybrid quantum workflows. In this work, we show progress towards a basic, but portable, runtime environment for developing and executing hybrid quantum-classical programs running in High Performance Computing (HPC) environments enhanced with Quantum Processing Units (QPUs). The middleware includes a second layer of scheduling after the main HPC resource manager in order to improve the utilization of the QPU, and extra functionality for observability, monitoring, and admin access. This approach enables managing multiple programming Software Development Kits (SDKs) as first-class citizens in the environment by building on a recently proposed vendor-neutral Quantum Resource Management Interface (QRMI). Lastly, we discuss and show a solution for the monitoring and observability stack, completing our description of the hybrid system architecture.