Session K52: Quantum Software Stack

Qibo: an open-source hybrid quantum operating system

We present Qibolab, an open-source software library for quantum hardware control integrated with the Qibo quantum computing middleware framework. Qibolab provides the software layer required to automatically execute circuit-based algorithms on custom self-hosted quantum hardware platforms. We introduce a set of objects designed to provide programmatic access to quantum control through pulses-oriented drivers for instruments, transpilers and optimization algorithms. Qibolab enables experimentalists and developers to delegate all complex aspects of hardware implementation to the library so they can standardize the deployment of quantum computing algorithms in a hardware-agnostic way. We first describe the status of all components of the library, then we show examples of control setup for superconducting qubits platforms. Finally, we present successful application results related to circuit-based algorithms.   

Low-level programming of quantum computers with Amazon Braket

Current quantum computers are at a stage where they have similarities to early classical computers: huge in footprint, expensive, and experimental, with each of them having a unique design and capabilities. Typically, quantum developers expect to control these devices at the level of global qubit registers and assembly instructions, most often using the abstraction of quantum gates, while also desiring programming constructs such as modularity and control flow. At the same time, to allow further optimization of device performance, hardware providers have given access to pulse-level control, allowing developers to manipulate the analog signals or pulses that drive the qubits of a quantum processor.

In this talk, we will describe how Amazon Braket enables low-level programming of quantum devices. Developers can provide pulse-level instructions, design gates with custom pulse implementations, or modify the pulse implementation of standard gates to optimize their performance. We will also discuss a novel Python-native programming interface which facilitates writing quantum programs in an imperative style at various levels of abstraction, allowing the developer to move beyond unitary quantum circuits toward complex programs with built-in classical logic and control flow.   

Fast qubit experiments using Qiskit and Quantify - a control stack designed for Experimentalists

The coding of experiments has become increasingly complex. Different coding platforms/languages make up an indigestible forest of options to choose from. With increasing qubit numbers and experiment complexity, there is an ever growing need for faster execution of experiments. At the same time, control stack electronics have become more powerful and support more complex instruction sets. In order to both minimize the time required for coding and maximize the speed of execution it is crucial that the software stack is both highly modular and that it offers multiple abstraction levels.

We show how these challenges are overcome using Quantify, an open source platform for quantum experiments.

We will first introduce the full software stack for a quantum computer. We then show seamless mixing of Qiskit circuits and hybrid gate-pulse level Quantify schedules together with classical logic like fast parameter sweeps and active reset. This dramatically simplifies and speeds up characterization experiments. Finally, we show how backend optimizations improve hardware utilization with minimal overhead for the user. We show how subroutines increase the maximum length of a randomized benchmarking sequence by a factor of 3. Similarly, instruction selection allows to implement pulses much more efficiently, without user input.

Such optimizations allow for maximal efficiency when using control electronics, without burdening the user with the additional complexity that comes with manual implementation.   

XACC Quantum Execution Engine: Streamlining Quantum Computing through QIR Interpretation

The "Quantum Execution Engine" (QEE) marks a practical advancement in computational science, effectively bridging quantum and classical computing by interpreting Quantum Intermediate Representation (QIR). This engine supports a wide range of quantum instructions and manages quantum results, which is essential for researchers and developers working on quantum algorithms. By processing QIR, the QEE standardizes the execution of quantum programs, making it easier to work across different platforms and quantum hardware. This is particularly important in a field where hardware capabilities can vary significantly. The engine's compatibility with the XACC framework further enhances its utility, providing a hardware-agnostic environment that many researchers may find beneficial. In our presentation, we'll provide an overview of the QEE's architecture and its use of QIR. We'll explain how it handles quantum instructions, manages results, and integrates with existing quantum computing frameworks through XACC. The discussion will be straightforward, focusing on the engine's practical applications in quantum computational science. We want to highlight the QEE's robust support for variational methods, which are instrumental in advancing research in physics and chemistry. The QEE offers a tangible way forward in the complex landscape of quantum computing, presenting a pragmatic approach that could help many in the field.   

Build, test and run quantum-classical algorithms with Amazon Braket

Amazon Braket is a fully managed service that enables users to get started with quantum computing. With Braket, users can learn how to program quantum computers, explore potential applications, and design quantum-classical algorithms. Braket provides a Python SDK which can be used to develop on a local computer or in Amazon Braket’s fully managed notebook environment. With the SDK users can build quantum programs, test them on local or AWS-managed quantum circuit simulators, and eventually run them on Amazon Braket using physical quantum processing units (QPUs) from hardware providers.

In this talk, we describe how Amazon Braket Hybrid Jobs make the execution of hybrid quantum-classical workloads easier, faster, and more predictable. Hybrid Jobs provide better performance than running hybrid algorithms from a local environment by leveraging parametric compilation and circuit caching. Moreover, a Hybrid Job has priority access to the selected QPU during the entire time that it is running. This ultimately leads to better results by reducing the detrimental effects of slowly-changing device characteristics on algorithm performance.   

Introduction to the Intel Quantum SDK Version 1.1

The Intel Quantum SDK is a comprehensive platform that enables developers to craft applications on a full-stack system integrated with an LLVM-based industry standard compiler, which offers user-friendly C++ extensions for the construction and optimization of quantum circuits. This SDK provides dynamic quantum instructions to perform the execution of hybrid quantum-classical applications. The recent version 1.1 introduces a tensor network simulator and a Clifford simulator, broadening its applicability in quantum algorithm development. Additionally, a custom backend wrapper has been unveiled, allowing users to link their distinct quantum backend with the SDK. The compiler optimization passes have been made open source, granting all users the capability to design and contribute their own optimization processes. The Intel Quantum SDK v1.1, with its adaptability in creating custom compiler passes and quantum backends, serves as an invaluable resource for researchers pushing the boundaries of quantum computing.   

High-level Domain-specific Circuit Compilation using the Functional Language Extension to the Intel® Quantum Software Development Kit (SDK)

The Intel Quantum SDK uses quantum extensions to C++ to describe circuit-based quantum-hybrid algorithms. To go beyond basic circuit-level descriptions, the Functional Language Extension for Quantum (FLEQ) has been recently added to the Intel Quantum SDK to facilitate higher-level and extensible development of quantum algorithms, with which complex circuits can be built at compile time using a modular functional design. In this talk, we introduce a toy example of a quantum domain-specific language implemented using FLEQ in such a way that no circuit description is required, but rather only domain-specific knowledge of the problem.   

Comprehensive Quantum Computing Simulation with Intel Quantum SDK v1.1

The Intel Quantum SDK is a C++ based toolchain for compiling and executing workloads for seamless classical/quantum program execution. This system is naturally suited for execution of hybrid algorithms due to the tight integration allowed between the classical and quantum code. Simulations using qubit simulators has been a valuable resource for assessing feasibility, establishing limits, and studying scaling aspects of quantum algorithms. The Intel Quantum SDK with v1.1 will allow convenient targeting of four different kinds of qubit simulators each with their own strengths, combined with the powerful optimization capabilities of the compiler toolchain. In this talk I will discuss the capabilities and limitations of each of the simulator backends and provide recommended use cases based on examples. We will also explore the asynchronous mode of simulators which allows parallel execution of simulations.   

Performant Quantum-Classical Application Development with CUDA Quantum

CUDA Quantum is a software development kit for quantum and integrated quantum-classical programming. It consists of the CUDA Quantum intermediate representation and compiler toolchain, language expressions in Python and C++, and the ability to execute jobs either on GPUs accelerated via cuQuantum or QPUs spanning superconducting, ion traps, photonics and other qubit modalities.  As high-performance computing (HPC) trends towards heterogeneous architectures, CUDA Quantum enables a dynamic workflow with a kernal based programming model allowing users to offload onto various backends leading to scalable hybrid applications. 

We'll delve into other distinguishing and future-forward attributes of CUDA Quantum, such as the distributed quantum processing and the asynchronous task scheduling. Additionally, CUDA Quantum is interoperable with modern parallel programming models such as MPI, OpenMP, etc., allowing it to leverage parallelization within and across classical compute nodes.

To aid rapid prototyping and testing, it abstracts away the low-level details of diverse architectures from the application developer. CUDA Quantum has a user-friendly Python API and we will present results from simulations that leverage the multi-node multi-gpu simulations in quantum chemistry, quantum condensed matter physics, high energy physics, quantum machine learning, computational fluid dynamics at scale.   

Maximizing Quantum Computing Capabilities with High-Performance Computing

In this presentation, we will discuss how quantum computing (QC) and high-performance computing (HPC) complement each other. Various models for HPC and QC integration will be discussed. The emphasis will be placed on how quantum circuit simulators running on supercomputers can help maximize the potential of quantum computing. In particular, we will discuss how Argonne-developed tensor network quantum circuit simulator QTensor [1,2] running on supercomputers located in Argonne Leadership Computing Facility [3] can help to achieve this goal. The use cases for quantum circuits simulators include the design of new quantum algorithms and finding optimal parameters, verification of quantum supremacy and advantage, and co-design of QC+HPC architecture at both hardware and software system levels, to name a few. We will present the current progress on the development of QTensor and future directions.   

Modular software stacks for quantum computing at scale

The path to scalable quantum computation is increasingly relying on advanced software tools to design, simulate, and run circuits on noisy quantum hardware for current-day NISQ applications and on long-term fault tolerant system development. Today the ecosystem consists of compilers and transpilers, circuit- and pulse-level program definition, and a multitude of domain-specific languages, often derived from full-stack solutions. ParTec AG approaches the software stack from the perspective of an HPC-QC systems integrator. In this talk, we will discuss the current challenges and opportunities in modular systems from the software side. We will review the state of play in the software domain at the different levels of the stack, with an emphasis on commercial development, modularity, and cross-QPU compatibility. Finally, we will present ParTec’s software at the quantum-HPC interface, QBridge, in the context of quantum computing solutions delivered via HPC clusters.

  

Software Stack Requirements for Quantum Computer Testbeds

Quantum testbed systems are a new domain where quantum computing systems are being deployed. Testbed systems, by the nature of their intended usage scenario, introduce new demands on the software stack. We have identified several key requirements for testbed systems that differ from small-scale, lab-based quantum computers. These include: larger quantities of data, multi-user access, higher uptime, better resource utilization, user role specialization, user interaction, well-defined APIs, and integration with HPC systems. These requirements are ill-served by the existing software stacks that have been developed for quantum computing systems thus far. The challenges of operating quantum computer systems at this new level of scale mirrors those experienced (and solved) in other emerging domains such as ML Ops (operating Machine Learning systems end-to-end). In this talk we will present the emerging challenges we foresee and the software solutions required to continue to push the bounds of the experiments and workloads that an experimentalist can run on quantum computers.   

Multi-level scheduling supports scalable quantum computing

Quantum computing architectures have expanded to systems with quantum processing units (QPU) that operate hundreds of qubits. Over the next years, these systems will increasingly be combined with cloud-based access and integrated into readily available high-performance computing (HPC) clusters. To achieve such goals, there are several critical points that need to be addressed: First, the quantum computing resource should be efficiently distributed between multiple users. Second, the shared QPU resource should have minimal downtime, i.e. duty cycle should be maximized. Here, we present how our open-source control software framework (LabOne Q) addresses these challenges by introducing quantum job scheduling on multiple levels. Efficient scheduling of jobs in both the hardware and the software levels optimizes queues and priorities among jobs submitted by multiple users, making LabOne Q an ideal platform for HPC integration. Additionally, through this job scheduler functionality, we achieve a significant decrease in QPU idle time. Finally, the hardware level abstraction in LabOne Q enables a framework for automated QPU tune-up/maintenance, which in combination with job scheduling further reduces QPU idle time.   

Evaluation of Quantum Machines by Combining Gate Expressivity, Entanglement Capability, and Fidelity Metrics

The design space of current quantum computers has become expansive, with no technology or architecture clearly asserting themselves as the only viable candidate. From this fact, a clear question arises: "How well can a particular machine represent a given a quantum algorithm?''. This paper explores and analyzes generic fidelity models that directly compare the performance of two quantum machines for a given algorithm. This procedure allows us to evaluate the trade off between gate expressivity, entanglement capability, and fidelity. Utilizing a bottom-up synthesis technique, we run these models on a wide range of quantum algorithms, and show that the decision boundaries between machines differ greatly with respect to the incoming algorithm. We see that for several low-entanglement gates such as the  ₄√ (CNOT) and √(ISWAP) are able to offer similar performance to maximum entangling gates at similar gate fidelities for important circuits such as TFIM, QFT, and QAE. On the other hand, high expressibility gates such as the B Gate seem to offer limited advantage across many circuits.  We offer insight into these differences by looking at the underlying structures that appear at the unitary level and how they vary by gate set.   

Quantum Error Correction Modeling using the Intel® Quantum Software Development Kit (SDK)

A common use for quantum simulation is the evaluation and vetting of quantum error correction (QEC) protocols. In this talk, we provide an example of the use of the full-stack-in-simulation capabilities of the Intel Quantum SDK for this purpose. We start by demonstrating scaling simulations using a Clifford simulation backend to investigate the existence of an error threshold. Due to the hybrid design of the Intel Quantum SDK, we show how the classical decoding implementation can be written in C++ and seamlessly integrated with the quantum syndrome extraction circuit. We also demonstrate the simulation of smaller code instances with more realistic simulation modeling .This is done through tomography on a full-stack simulation to extract chi matrix representations of the gates. These chi matrices are then fed into the custom error modeling interface for the Intel Quantum Simulator state vector qubit backend to scale to code sizes of near-term interest.