Tutorials Abstracts

Sunday, Aug 31, 2025 — Tutorials Abstracts

TUT01 — Introduction to Quantum Computing

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — This tutorial offers a foundational introduction to quantum computing, tailored for participants with little or no prior experience. Attendees will gain practical insight into quantum models, algorithms, and hardware, preparing them to understand and eventually engage with emerging quantum technologies poised to reshape the future of computing. 

Abstract — Quantum computing offers the potential to revolutionize high-performance computing by providing a means to solve certain computational problems asymptotically faster than any classical computer. Relatively recently, quantum computing has advanced from a theoretical possibility to an engineered reality, with commercial entities offering early prototype quantum processors, including both special-purpose quantum annealers and general-purpose gate-model processors. The media have been showcasing each new development and implicitly conveying the message that the ubiquity of quantum computing is nigh. Here, we will respond to this hype and provide an overview of the exciting but still early state of the field. In this tutorial, we introduce participants to the computational models that underpin quantum computing’s immense computational power. We examine the thought processes that programmers need to map problems to various quantum-computing paradigms. We also discuss the hardware and algorithmic challenges that must be overcome before quantum computing becomes a standard component of every software developer’s repertoire. 

Target Audience — The tutorial targets a broad audience: essentially anyone who is curious about quantum computing and wants to learn how it works and what it can and cannot do. Those who are unfamiliar with quantum computing will likely benefit more from the tutorial than those who have existing expertise in quantum mechanics or prior experience with non-trivial exposure to quantum computing. Still, even professionals who have worked in the field will likely gain at least some knowledge.
TUT02 — Exploring the Challenges of Integrating HPC and Quantum Computing

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — This tutorial aims to ease participants’ journey into the joint quantum and high-performance computing field—an exciting area of research that may well hold the key to performant quantum computing. We recommend that any interested quantum or HPC practitioners attend an introduction to QHPC, where they can gain insight into our work, including code implementations and encourage active audience participation. 

Abstract — Supercomputers and quantum computers both aim to revolutionize the computing world by tackling challenges well beyond the reach of previous processing power. These technologies have, for the most part, been evolving in separate ways, but is this the best approach? We argue that the combination of quantum computing and HPC (QHPC) is not only possible, but also inevitable. In this tutorial, we delve into the challenges we have faced while creating hybrid quantum-classical pipelines. By raising these challenges, we aim to educate and inform HPC and quantum engineers about the integration pitfalls and best practices for overcoming them, thereby making the QHPC field more accessible. We will explore the need and challenges associated with building pipelines that require low-latency communication between QPUs and CPUs. This will involve exploring use cases that require such closely coupled architectures, the different ways these architectures can be built, and the development of an example workflow that takes advantage of fast information exchange between QPUs and CPUs. We will then examine how to best leverage HPC to mitigate QPU overhead. This will include an in-depth examination of an algorithm that dynamically switches between simulation and hardware runs to approximate varying problem sizes during training. These are open-ended questions, and we will explore the different approaches behind them before focusing on our own experiences. This will be done through open dialogue, interactive polls and Jupyter notebook coding implementations. We hope attendees will come away feeling equipped to embark on their journey into QHPC. 

Target Audience — This tutorial is designed for quantum and HPC engineers with an interest in QHPC. However, anyone with experience in mathematics, machine learning, and classical computation will also gain valuable insights. We expect attendees to already have some knowledge of quantum computers, including quantum logic gates and quantum circuits. It would be helpful but not necessary to have seen some basic implementations of variational quantum algorithms, such as Variational Quantum Eigensolver (VQE) and/or Quantum Approximate Optimization Algorithm (QAOA). Some of these prerequisites will be touched upon during the tutorial, but prior knowledge will be beneficial. Attendees should expect to come away with knowledge not only of the concepts of QHPC but also having seen some practical implementations.
TUT03 — Using Bartiq for Symbolic Resource Estimation of Fault-Tolerant Quantum Algorithms

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — In this tutorial, participants will learn to perform quantum resource estimation (QRE) for fault-tolerant algorithms. We will utilize Bartiq, an open-source QRE tool developed by PsiQuantum, to perform a cost analysis using symbolic expressions and to identify bottlenecks in the algorithm implementation.
 
Abstract — Quantum Resource Estimation (QRE) is an essential aspect of quantum information processing and quantum technologies. It refers to the process of quantifying the resources (time, qubits, magic states, etc.) required for performing a given quantum computation. QRE can be used to guide the development of new quantum algorithms and applications. Since many of these are still in early development, researchers often employ analytical tools, such as query complexity or Big O analysis. However, there are not many tools that enable such analysis. In this tutorial, we will demonstrate how Bartiq and other tools developed by PsiQuantum can help automate the analysis commonly performed by researchers of quantum algorithms. Bartiq is a software package developed to simplify the analysis of fault-tolerant quantum algorithms expressed symbolically. In the first part of the tutorial, we will introduce the concepts necessary to work with QRE and demonstrate how to use Bartiq for several basic QRE tasks. In the second part of the tutorial, we will explain how to utilize Bartiq in more advanced scenarios, such as identifying bottlenecks in an implementation or optimizing an algorithm’s hyperparameters. We will also show how to use Bartiq complements other QRE tools (for example, Qualtran) to enhance their capabilities.
 
Target Audience — This tutorial is designed for students, quantum computing researchers, and practitioners. The material will require a basic knowledge of quantum computing, but no prior knowledge of specific application domains, such as quantum chemistry. Attendees with practical experience in quantum computing will benefit the most from the tutorial.
TUT04 — Programming and Developing Quantum-Classical Kernels for Gate-Based Neutral-Atom Quantum Computers

    • Date — Sun, Aug 31, 2025
    • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
    • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
    • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
     
Summary — In this tutorial, QuEra brings a seasoned team of educators to help participants learn how to utilize QuEra’s new programming languages to interact with the most novel neutral-atom quantum computers available in the world. They will also learn how to utilize novel standard infrastructure for compiler development and, at the end of the tutorial, will be tooled to create their own compiling languages that can be developed to account for the particularities of any upcoming quantum computing architecture.
 
Abstract — Quantum computing is transitioning from NISQ to logical operations. In this field, the high flexibility and large scale of neutral-atom tech have played an increasingly driving role, enabling unprecedented levels of co-design between hardware and protocols. Engaging with this kind of development, however, requires new tools—compilers, SDKs, and programming languages—that enable an efficient workflow given the new design parameters available to users, allowing them to best leverage parallelized operations, logical and global transversal gates, and other features exclusive to neutral-atom platforms. Thus, the heralded rise of early error-corrected quantum computation comes with and is propelled by a new suite of programmatic skills and design mindset. In this two-part tutorial, we will provide an overview of QuEra’s upcoming gate-based neutral-atom quantum computer, Gemini, explaining to the audience the design parameters and preliminary device error model. We will also display how to use QuEra’s new SDK Bloqade-circuits to interact with Gemini both at the circuit (QASM) and atom moving level (QuEra’s atom coordination language). We will then proceed to a hands-on demonstration on how to utilize QuEra’s new compiler development infrastructure, Kirin, allowing users to develop their own compiling languages. We will illustrate this via an example involving a hybrid quantum-classical kernel on Bloqade. Participants will emerge from this tutorial equipped to start contributing to the era of early error-corrected quantum computing.
 
Target Audience — The contents of this tutorial will be most appreciated by researchers and students from academia, as well as researchers and developers from industry. The tutorial aims to address the interests of both application developers who need to be aware of hardware constraints and software workflows, as well as programming infrastructure developers interested in improving their software products or creating new ones.
TUT05 — Constraint-Driven QAOA Design: A Software Stack to Auto-Generate Efficient Optimization Pipelines

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Participants will learn to build customized QAOA versions for specific optimization problems, such as modeling one-hot constraints as QAOA mixers for a given graph coloring problem. We will show how to implement XY-mixers for one-hot constraints from scratch, how to achieve the same with an easy configuration in LunaSolve, as well as how to benchmark different QAOA pipelines.
 
Abstract — As quantum computing research progresses, an increasing number of problem-specific customizations to the Quantum Approximate Optimization Algorithm (QAOA) have emerged. Each addition, like integrating one-hot constraints through XY-mixers, demonstrates performance improvements for its specific domain. Real-world optimization problems consist of a variety of constraints. Hence, different customizations can be combined without overlap. Nevertheless, a customization is only applicable if the constraint is part of the model, so no one- size-fits-all combination of customizations is possible. To leverage the best set of customizations, a software architecture is required that can automatically deploy appropriate customizations based on input model domains. This tutorial introduces LunaSolve, part of Aqarios’ Luna platform, which can generate problem-specific QAOA instances. Users can select and combine specific QAOA customizations under LunaSolves’s concept of transformations. By applying these transformations iteratively, advanced circuit-generating pipelines are built. This tutorial showcases a pipeline for one-hot constraints through XY-mixers, together with a practical example of the graph coloring optimization problem. Participants will implement an example XY-mixer pipeline, and it will be shown how to configure the same pipeline easily with LunaSolve. The benchmarking tool in the Luna platform, LunaBench, compares the implemented and default QAOA pipelines to better visualize their respective performances. By understanding the modular setup, attendees are enabled to combine multiple QAOA customizations to model-specific, advanced pipelines. Additionally, attendees will learn how to run QAOA optimization pipelines and evaluate performance across different optimization approaches.
 
Target Audience — This self-contained tutorial is designed to serve a broad audience interested in quantum optimization, applying quantum computing to industry-relevant problems, and those seeking a well-prepared introduction to the topic of QAOA and its customizations. We welcome researchers and students from electrical and computer engineering, computer science, applied physics, and other related fields who possess a basic knowledge of quantum computing. The tutorial will feature applications of optimization and spark interest from professionals. Participants will gain access to a comprehensive toolbox that can help organizations exploit potential quantum advantages. Attendees can register for LunaSolve and LunaBench for free to execute all examples presented during the tutorial. If no sign-up is desired, attendees can still follow the implementation and simulation of the XY-mixer. While hands-on participation is encouraged, the content is structured to allow attendees to either actively implement the concepts or follow along passively, depending on their comfort level and interests. This flexibility makes the tutorial accessible to everyone, regardless of their prior experience with quantum optimization techniques.
TUT06 — Circuit Synthesis for Early Fault Tolerant Quantum Computers

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Attendees will learn techniques for program generation on NISQ and early fault-tolerant devices. These techniques rely on program synthesis and are implemented in the BQSKit framework: dynamic circuit generation, approximation generation, and FT synthesis using diagonalization. The target audience spans hardware, compiler, and algorithm designers. 
 
Abstract — This tutorial will introduce several techniques intrinsic to program generation for early fault-tolerant and FT devices. The target audience is broad: hardware designers, compiler writers and algorithm designers can all benefit. Code generation is performed through synthesis using the Berkeley Quantum Synthesis Toolkit (BQSKit). The techniques we introduce are novel, practical, and currently only supported in BQSKit. First, we will demonstrate how to utilize synthesis for generating circuits using mid-circuit measurement (MCM) and feed-forward operation to prepare an arbitrary state or implement an arbitrary unitary. With this technique, one can optimize circuit resources. Second, we will show how to build robust circuit approximations using ensembles. Approximations manipulate “error” and can be applied at the NISQ or FT level, serving as a resource optimization and error mitigation technique. Furthermore, all feasible methods for generating FT circuits are approximate. Third, we will introduce synthesis methods for FT devices, targeting RZ reduction and the Clifford+T gate set. The methods use matrix diagonalization rather than inversion and constrained optimization, and we will show how to extend them with other magic states (e.g., √ T, V). 
 
Target Audience — This tutorial introduces the practical challenges of compiling quantum programs for current NISQ-era and near-term future devices and teaches how to use BQSKit to overcome these challenges. Beginners, who only need to be familiar with the quantum circuit model, basic linear algebra terms, and the Python programming language, will learn how to utilize circuit transpilation methods to optimize programs for NISQ-era hardware. In addition, beginners and intermediate practitioners will be introduced to the challenges of fault-tolerant compilation and some state-of-the-art compilation techniques with hands-on examples. Advanced quantum computing users with a target application in mind will further benefit throughout the tutorial as they apply the lessons directly.
TUT07 — Exploring the Pulse-Level Programming of Superconducting Qubits

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — During this tutorial, attendees will gain practical experience working with pulse-level programming of superconducting qubits. Participants will work through hands-on examples, including using custom pulse shapes, and we will conclude by exploring examples of how this enables the exploration of the physics governing these systems.

 

Abstract — The past years have seen immense progress in the programming of quantum computers with widely available open-source software to support research and developer endeavors. Maintaining transparency in quantum circuit execution is crucial for quantum engineers to maintain visibility on what really happens when transitioning from circuit representation to pulse-level instructions. In this tutorial, we focus on discussing the pulse-level programming of superconducting qubits. We will rely on the Pulse-Level library Pulla, a Python package maintained by IQM Quantum Computers, aimed at granting end-users access and visibility to pulse-level details of quantum algorithms. We begin by discussing how quantum circuit execution works, with a focus on the importance of the final pulse scheduler. We will use it to explore how gate-based extractions are converted to pulse schedulers. We will work through other examples of pulse-level access, including the creation of custom implementations of quantum gates, and discuss how pulse-level access can be used to enhance quantum error suppression. To conclude this session, we utilize pulse-level access to study the physics unique to superconducting qubits by exploring qubit-resonator dynamics in star topology systems. At the start of the session, we will provide all participants with a Jupyter notebook to work through example problems alongside the presenter.

 
Target Audience — This tutorial’s content is targeted to a broad audience ranging from researchers, scientists, and engineers working in quantum science to students with a background in physics or computer science. The minimum requirements for attendees include a basic knowledge of modern programming and fundamental quantum computing concepts (such as qubits, quantum circuits, and quantum gates). Experience programming in Python with Jupyter notebooks is beneficial. For the final section of the tutorial, knowledge of superconducting qubits and quantum mechanics concepts at the undergraduate level is useful. Participants will gain an understanding of how quantum circuit execution works, in addition to understanding how they can implement custom pulses and why this may be beneficial to their work.
TUT08 — QICK: Quantum Instrumentation Control Kit

  •  
  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — In this tutorial, attendees will learn how to use the open-source Quantum Instrumentation Control Kit (QICK) system to control qubits. Examples of QICK applications will be presented, and the QICK hardware, firmware, and software stack will be explained through live demonstrations using QICK boards. 

Abstract — QICK is an open-source qubit controller that is used by hundreds of users worldwide in academia and industry. In this tutorial, we aim to engage those interested in quantum controls at any level of the stack and introduce them to the QICK hardware, firmware, and software, all of which are publicly available on GitHub. No familiarity with QICK is assumed. The core topic will be an exploration of QICK’s capabilities for quantum control using RF pulse synthesis, pulse sequencing, and readout; other QICK features, such as photon timing, will also be demonstrated. Much of the tutorial will consist of live demonstrations, giving attendees a firsthand understanding of how QICK works. Current and prospective QICK users, experts in control electronics, and those interested in the open-source quantum ecosystem will find this tutorial of interest. 

GitHub Repo

Target Audience — The tutorial targets a broad audience, ranging from researchers to students with some background in engineering, math, computer science, or physics, who are willing to get started using the QICK for quantum experimentation. Attendees will learn how the QICK system works and be provided with the tools to describe single- or multi-qubit experiments using this system for themselves. Current or potential users of QICK will benefit from this tutorial, as will attendees with a general interest in instrumentation. No prior knowledge of either quantum computing or QICK is required. Basic concepts are introduced to build up knowledge gradually. 

TUT09 — Security of Quantum Computing Systems

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
  •  
Summary — The participants will learn what threats to the security of quantum computing systems are, the types of attacks that these systems could be vulnerable to, and the types of defences that can be applied to secure quantum computing systems from both local and remote attacks. 
 

Abstract — This revised, 3rd edition of the tutorial will introduce the audience to the emerging field of secure quantum computing, which focuses on research on how to make quantum computing systems secure from attacks. By design, this tutorial will not cover post-quantum cryptography as that is an essential but orthogonal topic. The tutorial focuses on the security of quantum computing systems, as rapid advances in quantum computer technologies hold the promise of enabling quantum computers to run algorithms for generating novel drugs or material compounds. Once quantum computers are generating or processing sensitive data or valuable intellectual property, they will become a target for attacks that aim to disrupt their operation, modify computations, or even attempt to steal data or quantum circuit code. Moreover, many quantum computers are already cloud-based, and with remote, on-demand cloud access, they make them vulnerable to remote security attacks, no different from those in today’s classical cloud computing. First, this tutorial will introduce the audience to classical computer security concepts, including threat modelling, confidentiality, integrity, and availability, as well as information leaks, side-channel and covert-channel attacks. Second, this tutorial will demonstrate examples of security attacks prototyped on real cloud-based NISQ quantum computers available today, as well as prototype attacks of FTQC quantum computers. Third, the tutorial will present designs for securing the cloud-based NISQ and FTQC quantum computers. Lastly, the tutorial will present challenges and opportunities to build quantum computer security from the ground up, rather than patch them later once security attacks have occurred in the wild. 

Target Audience — 
A. Expected background and prerequisites of the tutorial attendees: The audience does not require a computer security background. Expected background includes basic knowledge of computers and an interest in learning about cloud-based quantum computers and making them secure.
B. What will the target audience learn? Quantum computing engineers and researchers will learn how to design more secure quantum computers and protect computing machines from vulnerabilities, as many quantum computers are now connected to the internet (e.g., IBM Quantum, Amazon Braket, Microsoft Azure).
TUT10 — Hands-on Introduction to Quantum Machine Learning

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — Attendees will embark on an immersive, hands-on journey into Quantum Machine Learning (QML) using an open-source quantum computer simulator. This beginner-friendly tutorial covers foundational concepts in quantum information science (QIS), introduces key quantum computing (QC) and QML principles, explores various QML models, and provides practical coding exercises to reinforce learning. Designed to make QML accessible, the session equips participants with the essential knowledge and skills to begin exploring this cutting-edge field, requiring no prior quantum experience, just curiosity and a passion for innovation.

 

Abstract — This tutorial will cover a hands-on introduction to quantum machine learning. Foundational concepts of quantum information science (QIS) will be presented (qubits, single and multiple qubit gates, measurements, and entanglement). Building on that, foundational concepts of quantum machine learning (QML) will be introduced (parametrized circuits, data encoding, and feature mapping). Then, QML models will be discussed (quantum support vector machine, quantum feedforward neural network, and quantum convolutional neural network). Finally, the cutting-edge QML models such as quantum recurrent neural networks, quantum reinforcement learning, and quantum federated learning will be introduced with concrete programming examples. All the aforementioned topics and concepts will be examined using codes run on a quantum computer simulator. All the covered materials assume a novice audience interested in learning about QML. Further reading, software packages and frameworks will also be shared with the audience.

 
Target Audience — The tutorial is designed for practitioners and researchers with a basic understanding of machine learning concepts. Attendees should have a general knowledge of quantum computing principles (e.g. know how to do matrix multiplication, understand what an expectation value is). Still, no prior experience in quantum machine learning is required. The tutorial aims to equip participants with the skills necessary to begin working on quantum machine learning projects.
TUT11 — Introduction to SeQUeNCe, a Customizable Discrete-Event Simulator of Quantum Networks

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — This tutorial introduces SeQUeNCe, an open-source simulator for modeling quantum networks. It covers quantum communication fundamentals, SeQUeNCe’s architecture, and includes hands-on exercises, along with a live demo. Advanced topics, such as parallel execution for large-scale simulations, will also be explored. The session is beginner-friendly and relevant to researchers and infrastructure providers in the field of quantum networking. 

Abstract — Quantum networks promise to deliver new, revolutionary applications that include distributing cryptographic keys with provable security, synchronizing clocks with unprecedented accuracy, and distributed quantum computing. Recent breakthroughs in quantum engineering have enabled the experimental realization of quantum network prototypes. One of the most significant engineering challenges is building networks that scale both in terms of the number of users and the communication distance. Achieving this goal requires a combination of advances in hardware, standardization of network architectures, development of robust control plane protocols, and techniques that allow reproducible performance testing. Quantum network simulations can help in understanding the tradeoffs of alternative quantum network architectures, optimizing quantum hardware, and developing a robust control plane. Simulator of QUantum Network Communication (SeQUeNCe) is a customizable discrete-event quantum network simulator that models quantum hardware and network protocols. SeQUeNCe employs a modularized design that separates functionality across different network layers into distinct modules. This modularized design enables the testing of alternative quantum network protocols and hardware models, as well as the study of their interactions. In this tutorial, we will start with a brief overview of quantum communications, their potential benefits, use cases, and challenges. Then, we will introduce SeQUeNCe and present its design, interface, capabilities, and limitations. We will discuss recent publications that have utilized SeQUeNCe and how it distinguishes itself from other available quantum network simulators. We will show a live demo of SeQUeNCe followed by hands-on exercises. We will then present some advanced capabilities, including the ability to parallelize the execution of large-scale quantum network simulations on high-performance computers. 

Target Audience —
• Undergrad and graduate students who want to learn and enter the field of quantum networks. They will learn how to use SeQUeNCe in their quantum network course projects. Prerequisite: minor knowledge of quantum networks and simulation software.
• Scientists and faculty who work on quantum networking devices, quantum communication protocols, and distributed quantum computing. They will learn how to use SeQUeNCe in their research projects and proposals. Prerequisite: good knowledge of quantum networks and simulation software.
• Infrastructure providers interested in building quantum networks. Prerequisite: some knowledge of quantum networks and simulation software.
TUT12 — Automated Topological Quantum Error Correction Using 3D Primitives

  • Date — Sun, Aug 31, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — In this tutorial, participants will use TQEC’s design-automation tool to build and simulate fault-tolerant quantum circuits based on surface codes and lattice surgery with only 3D blocks. A theoretical overview will explain the fundamentals of error correction for the surface code, followed by hands-on programming exercises to design logical circuits and simulate logical error rates. 

Abstract — Quantum computers require fault tolerance to achieve reliable, large-scale performance. While many architectures for topological quantum error correction have been proposed, implementing non-trivial quantum operations remains challenging due to the complexity of specifying software instructions. As a result, resource estimates and error suppression rates are often insufficiently tested. In this tutorial, we present an automated method for representing and compiling design hypotheses for surface code-protected quantum operations using TQEC, an open-source and flexible Python tool. TQEC models logical operations using three-dimensional spacetime blocks, compiling them into Stim circuit instances that can be simulated or prepared for hardware implementation. These simulations generate plots that link logical error rates to parameters, including code distance and physical error rates, providing a practical way to evaluate circuit performance and validate error suppression. When multiple fault-tolerant implementations are possible, TQEC enables direct performance comparisons through simulation-based feedback. The tutorial begins with a conceptual overview of surface code quantum computation, designed to help attendees with no prior background understand the fundamentals. The hands-on portion will guide participants through the iterative process of building fault-tolerant quantum circuits from surface code memory experiments to complete quantum algorithm constructions using TQEC for simulation and visualization. We will also outline the future roadmap for TQEC, encouraging attendees to explore further and contribute to its development. 

Target Audience —
• This tutorial is designed for researchers, engineers, and practitioners in quantum computing who are interested in error-corrected quantum computation under the surface codes framework. No prior experience with quantum error correction is required; however, a basic understanding of quantum circuits and linear algebra will be beneficial for understanding the theoretical concepts. Familiarity with Python programming is also recommended for participants to fully engage with the hands-on components of the tutorial.
• The tutorial is suitable for both newcomers looking to build foundational knowledge and experienced developers aiming to explore automated design and simulation workflows for large-scale fault-tolerant quantum computations.

Monday, Sep 1, 2025 — Tutorials Abstracts

TUT13 — AI Methods for Quantum Circuit Optimization

  • Date — Mon, Sep 1, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — Participants will learn how to leverage existing AI transpiling passes to produce highly optimized circuits for current quantum hardware and to train their own AI-powered transpiler passes for their specific needs.

 

Abstract — Quantum circuit optimization is a challenging but necessary task to get the best out of current quantum hardware. Recently, AI methods have emerged as a practically useful tool for circuit optimization and transpilation, providing a good balance between circuit quality and computational effort. Last year, we made some of these AI methods available as Qiskit transpiler passes through the Qiskit IBM Transpiler, and showed how they can provide substantial improvements in circuit depths and gate counts within a reasonable time. In this tutorial, we will do a comprehensive and practical walk-through of this topic. In the first half of the tutorial, we will provide an overview of the existing AI passes available and demonstrate hands-on how users can utilize them to produce highly optimized circuits, along with some guidelines indicating when they work best. In the second half, we will delve into the methods used and provide a practical demonstration on how users can train their own models tailored to their specific problems, as well as how to integrate them into Qiskit as transpiler passes.

 
Target Audience — Beginners and intermediate users will learn how to leverage the latest AI models for circuit optimization, and advanced users and researchers will learn how to apply AI methods in practice to develop their own AI-based transpiling and optimization passes for their problems. The content will be presented in a way that is accessible to quantum practitioners, assuming foundational knowledge of Python and familiarity with quantum computing. Some familiarity with AI is beneficial, but not necessary. Familiarity with Qiskit would also be beneficial, but not required.
TUT14 — Quantum-Technology Computer-Aided Design of Spin Qubits in Semiconductor Quantum Dots

  • Date — Mon, Sep 1, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — In this tutorial, we will first present physics-based spin-qubit models employed by quantum scientists from academia and industry to describe their systems. We will then introduce the audience to 3D TCAD simulations of realistic spin-qubit devices through practical examples that illustrate typical design and simulation workflows.

 

Abstract — As quantum technologies mature and gain industrial relevance, it becomes imperative to accelerate design, prototyping, and manufacturing cycles by reducing trial and error. Akin to the situation that prevails in the semiconductor industry, quantum device design workflows increasingly leverage digital simulation tools to predict hardware performance before fabrication, and analyze characterization outcomes thanks to physics-based modeling. This Tutorial aims to introduce the participants of the IEEE Quantum Week to Technology Computer-Aided Design (TCAD) of quantum devices. We will introduce the spin-qubit technology to the audience, along with the main theoretical techniques used to model these systems. We will then demonstrate how to create 3D models of typical spin qubit systems that are currently explored by the emerging quantum hardware industry in potentially scalable quantum computer architectures and present basic simulation workflows using Nanoacademic’s finite-element modeling (FEM) tool QTCAD R. Finally, we will present new features recently introduced in QTCAD R 2.0, such as superconducting qubits and multiscale modeling combining atomistic methods with FEM to address key materials challenges that arise in qubit design.

 
Target Audience — The target audience is all quantum scientists and engineers with an interest in quantum hardware design. This includes quantum device engineers in industry (startups and established companies), government laboratories, and academia. We also expect interest from experimental and theoretical physicists from academia. Finally, based on tutorials provided in the past, we expect a large portion of the audience to consist of graduate students interested in learning about software tools currently used in the industry. We expect attendees to have a basic knowledge of physics, Python programming, and quantum computing; however, we do not expect them to be spin-qubit experts. A background in any quantum technology should suffice, as we will introduce the spin-qubit technology in the tutorial. In addition, this tutorial will focus on practical aspects of spin-qubit modeling, and a step-by-step pedagogical approach leveraging 3D visualization will make the presentation intuitive to beginners.
TUT15 — QubiC: An Open-Source Full-Stack Scalable Real-Time Quantum Bit Controller

  • Date — Mon, Sep 1, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 

Summary — Gain practical expertise in advanced quantum control using QubiC, an open-source system with mid-circuit measurement and feedforward. This tutorial combines simulation and real hardware experiments for a comprehensive learning experience.

 

Abstract — This hands-on tutorial provides a comprehensive overview of QubiC’s architecture and capabilities, focusing on the unique challenges of controlling superconducting qubits. We’ll also explore advanced features like real-time decision-making, flexible hardware integration, and AI/ML-powered calibration and measurement. Participants will gain practical experience through hands-on exercises, including simulations using our QuTiP-integrated emulator (allowing pulse- and gate-level design) and, time permitting, experiments on actual QubiC hardware. This tutorial is perfect for physicists, engineers, and quantum enthusiasts eager to leverage QubiC to advance their quantum computing projects. Ultimately, you can utilize QubiC’s powerful control system features in your quantum system development.

 
Target Audience — This tutorial is for the multi-disciplinary quantum community of experimentalists, hardware designers, and software engineers working with superconducting (and other) quantum technologies. Participants will learn how to leverage QubiC, a cost-effective, open-source quantum control system, to design, build, and control their own quantum systems. They’ll gain hands-on experience with QubiC’s software and hardware, including advanced features like real-time control and AI-assisted state discrimination.
TUT16 — Modeling and Simulation of Quantum Repeaters and Networks

  • Date — Mon, Sep 1, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
  •  

Summary — This tutorial will provide an overview of quantum repeaters and networks, the NetSquid simulation package, and experience in simulating quantum repeater chains under a variety of different scenarios. Memory-based and all-photonic quantum repeaters are in scope. 

Abstract — Quantum networks are envisioned to achieve novel capabilities that are provably impossible using classical networks. These novel capabilities range from cryptography, sensing and metrology to distributed systems. As with classical networks, quantum networks must be large enough to facilitate a practical level of communication, information sharing, or collaboration. Scaling quantum networks to longer distances requires advanced quantum repeater (QR) technologies. Depending on the error mitigation mechanisms adopted to suppress loss and errors, QRs are typically classified into two categories: “memory-based” and “all-photonic” QRs. Each type of QR may be best suited for a specific type of underlying quantum technology, for a particular scale of quantum network, and for a specific regime of operational parameters. NetSquid is a software package used for the modeling and simulation of scalable quantum networks developed at QuTech. Modeling and simulation of quantum repeaters and networks using NetSquid can help in understanding the relative performance and resource requirements of different types of QRs, tradeoffs of alternative quantum network architectures, optimizing quantum hardware, and developing a robust control plane. In this tutorial, we will start with a brief overview of quantum repeaters and networks, their potential benefits and challenges. Then, we will introduce NetSquid and present its design and features. Finally, we will demonstrate how to use a quantum repeater toolkit based on NetSquid to model and simulate “all-photonic” quantum repeaters and networks, and “memory-based” trapped ion quantum repeaters and networks. We will also compare the relative performance and resource requirements of these two different types of QRs and networks. 

Target Audience — This tutorial is designed for researchers and scientists working on quantum networking devices, quantum communication protocols, and distributed quantum computing, as well as infrastructure providers interested in building quantum networks. The tutorial assumes working knowledge of Python programming.
TUT39 — Characterization-based Error Mitigation for Quantum Computation

  • Date — Mon, Sep 1, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — This session offers a deep dive into quantum error mitigation (EM) techniques that extend the capabilities of noisy quantum devices, including methods like Zero-Noise Extrapolation, Probabilistic Error Cancellation, and QESEM. Attendees will explore recent experimental advances, hybrid quantum-classical workflows, and participate in a hands-on lab to plan and optimize quantum experiments using the Kicked Ising model.
 
Abstract — As quantum computing technologies advance, addressing errors remains one of the central challenges for utilizing quantum computers. Quantum error mitigation (EM) is a family of hybrid quantum-classical methods for eliminating or reducing the effect of errors in quantum hardware. Such methods are critical for extending the reach of noisy quantum devices, offering an alternative (or a complement) to error correction with no qubit overhead. As new generations of quantum processors increase in scale and improve in fidelity, understanding the benefits provided by EM, as well as its limitations, becomes key to unlocking and scaling up quantum advantage.
This tutorial begins with a conceptual overview of the role of EM in quantum computation. We discuss how EM can realistically enable quantum advantage—even as it falls short of supporting exponential speedups in the asymptotic limit, introducing key concepts such as active volume, circuit volume boost, and finite quantum advantage.
We then provide a detailed review of characterization-based EM techniques, including Zero Noise-Extrapolation (ZNE) based on Probabilistic Error Amplification (PEA); Probabilistic (or Pauli) Error Cancellation (PEC); and QESEM, a recent method based on quasi-probabilistic decompositions for both Clifford and non-Clifford gates, which leverages efficient sampling based on active volume identification and QPU-time optimization techniques. We also discuss the characterization protocols underlying these methods
Next, we present prospects for near-term quantum advantage with error mitigation, and recent state-of-the-art experimental results. We demonstrate how the timeline for quantum advantage can be accelerated by combining error mitigation with error correction and with classical supercomputing. In particular, we show how EM integrates with high-performance computing (HPC) to simulate long-time quantum dynamics, combining classical and quantum resources in a powerful hybrid quantum-classical workflow.
The final part of the tutorial focuses on planning and executing mitigation experiments. Participants will engage with a hands-on lab based on the Kicked Ising model, a benchmark for quantum many-body dynamics. They will learn techniques to estimate quantum runtime, and investigate how runtime scales with parameters such as active volume, observable structure, and desired precision.
 
Target Audience — Quantum computing researchers, quantum engineers, quantum computer hardware or SDK providers, and quantum computer users.

Tuesday, Sep 2, 2025 — Tutorials Abstracts

TUT17 — 10 Things Ruining Code in Your Research Project – Do This Instead!

  • Date — Tue, Sep 2, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — In this tutorial, we discuss how to avoid common problems encountered in scientific software. We focus on various aspects of software development, ranging from reducing code complexity at the local level to writing idiomatic code, modularization, and the utilization of polymorphism.
 
Abstract — Nowadays, research is frequently facilitated by scientific software, which is frequently developed in-house by the researchers. The quality of this software is a key factor influencing both the quality of the research results and the velocity of the research. Despite that, scientific software is often seen as a ”means to an end”, and little attention is paid to its quality. Properly designing and polishing the software is often seen as a waste of time that could be better allocated. Even if the need to ensure software quality is recognized, the task is often perceived as difficult, requiring a significant amount of experience that researchers do not possess. In this tutorial, we aim to demonstrate that taking proper care of scientific software is not only worthwhile but also not as difficult as it might seem at first glance. We will discuss several problems that often plague research code and some of the best practices for avoiding them. The tutorial is divided into two parts. In the first part, we focus on the “local“ quality of the code. We discuss topics such as reducing complexity, improving style, formatting, and writing idiomatic code. In the second part, we shift our focus to the big picture. In this section, we discuss how to enhance interactions between software components, covering topics such as modularization, decoupling, and effective polymorphism usage. Practical examples and hands-on exercises will accompany all of the topics.
 
Target Audience — This tutorial is designed for researchers in quantum computing who write software as part of their work. We will share some universal advice and techniques that will help both novice and experienced researchers. The tutorial will also be relevant for individuals who have recently transitioned from a research role to a software engineering role.
TUT18 — Implementation of Discrete Optimization Problems Made Simple

  • Date — Tue, Sep 2, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — This tutorial will teach the basic algorithms and concepts to solve discrete optimization problems on quantum hardware, show how to formulate these using the quark software and demonstrate how to interface the resulting QUBOs against different classical and quantum backends.
 
Abstract — Solving discrete optimization problems is one of the promising use cases of quantum computers with tremendous potential in both research and industry. In this tutorial, we present two Python libraries quark and quapps, which provide an easily usable, modular workflow to encode discrete optimization problems. We will learn how to formulate, transform and interface these problems intuitively to both classical and quantum hardware. At the end of this tutorial, every attendee will be able to formulate their discrete optimization problem of choice as Quadratic Unconstrained Binary Optimization problem (QUBO) and to run it against different solvers. Additionally we will provide a set of already implemented optimization problems which can be easily loaded by the user and learn how to adapt these to their needs. In summary, we will enable both expert and non-expert users to easily implement optimization problems, to understand the underlying library’s mathematical workflow, and to run the problems on classical and quantum machines.
 
Target Audience — The tutorial is aimed at participants with beginner and intermediate level knowledge in quantum computing. Basic Python programming knowledge is required. Beyond that, no specific prerequisite knowledge is needed. Basics in quantum mechanics and discrete optimization can be helpful.
TUT19 — Practical Quantum Algorithm Design with Qmod

  • Date — Tue, Sep 2, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — Attendees will learn to approach quantum algorithm design with a high-level quantum programming language, using the Qmod language and the Classiq platform. The tutorial will cover unique language concepts and abstractions, as well as how they can simplify and generalize the implementation of quantum algorithms.
 
Abstract — High-level quantum programming languages are rapidly evolving to elevate quantum programming well above circuit-level descriptions. By introducing higher abstractions, a programming language enhances the ability of programmers to reason about and communicate the functional intent and to capture it in terms that are flexible and reusable. Moreover, abstractions enable powerful compiler optimizations that are not possible at the gate level. Language constructs that align well with the domain's concepts serve as cognitive tools, facilitating a more intuitive and productive approach to algorithm design. This tutorial introduces attendees to the unique concepts of the Qmod language, including quantum numeric types, digital arithmetic expressions, phase- and amplitude-encoded expressions, and other key features. Attendees will engage in hands-on exercises, using Qmod’s high-level constructs to design, compile, visualize, execute, and analyze realistic quantum applications.
 
Target Audience — The tutorial is suited for practitioners, researchers, and students interested in acquiring tools to explore and gain insight into quantum algorithms. We expect attendees to have at least a basic understanding of quantum algorithms and some experience with Python.
TUT20 — Electrical Circuit and Qubit Interactions in Silicon and Superconducting Qubits

  • Date — Tue, Sep 2, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — The attendees will learn the basic and essential hardware operations of qubits and their realization through interactions with classical control circuits. Silicon qubits and superconducting qubits will be used as examples.
 
Abstract — Electrical engineers play a critical role in quantum computers. This is because a quantum computer is just an array of passive qubits controlled by sophisticated classical electronics. Low-power, high-speed, low-noise, and integrated circuits are essential for building future large-scale quantum computers. However, many electrical engineers are unaware of their pivotal role in quantum computing. Many outstanding circuit designers and microwave engineers are also unaware of the basics of quantum computers and the interactions between qubits and control circuits. This tutorial aims to educate engineering communities by bridging the aforementioned knowledge gap, simplifying complex quantum mechanics theory into a language familiar to engineers. The tutorial has 6 sections (each 30 mins). In section I, an overview of qubit operations and the role of control electronics will be discussed. In sections II-IV, the operation of Si qubits and the corresponding classical control and detector circuits (e.g. DAC, TIA, RF reflectometry) will be covered. In sections V-VI, we will discuss superconducting (SC) qubit operations and qubit interaction with classical electronics. Particularly, we will highlight common microwave components on SC qubit-integrated chip and their roles. The authors have offered the same tutorial in QCE 2024 with many enthusiastic attendees. In this tutorial, the content will be improved based on the feedback received and a new textbook published.
 
Target Audience — We expect there are three types of attendees. The first type is the electrical engineers who are familiar with circuit design. They will learn basic qubit operations and appreciate why electrical circuits (digital, analog, and microwave circuits) play a pivotal role in qubit control. They will be ready to design the microwave components on superconducting (SC) chips after the tutorial. The second type is the physicists who know qubit physics but not much about electrical circuits. They will learn the basics of electrical circuits and understand what to keep in mind when they design qubits in the future (e.g. why SC needs to be at the GHz range instead of THz due to the limitation of microwave circuits). The last type of attendees are those who are familiar with algorithms but not hardware. They will appreciate the constraints in the physical realization of qubit operations, although they might not fully understand the material; however, the experience of seeing qubit-classical circuit interaction can be transformative for them.
TUT21 — Evaluate or Design Quantum Computers: Automated FTQC Architecture Design and Resource Estimation Using TopQAD

  • Date — Tue, Sep 2, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Tutorial Agenda & Sign-up — 1qbit.com/qce25-tutorial/
 
</div
Summary — In this tutorial, attendees will learn how to use TopQAD, a software suite that automates decisions on the assembling of fault-tolerant quantum computing architectures based on the trade-offs involved in their design, to assist individuals in their research and decision making.
 
Abstract — This tutorial is designed to enable users to explore the costs and capabilities of utility-scale quantum computers. Quantum computers have the potential to solve problems beyond the reach of classical machines, but noisy qubits and faulty operations make quantum error correction essential for practical applications. Running large-scale quantum algorithms reliably requires fault-tolerant quantum computing (FTQC) architectures that strike a balance between hardware constraints and computational accuracy. Designing such architectures involves the making of key decisions, such as selecting an error-correction scheme, determining how to execute logical operations, and assembling FTQC structures within a physical system. Each choice impacts the number of qubits required, the runtime, and the overall success probability, making their automation a helpful tool for identifying efficient designs that balance with these trade-offs and enabling concrete resource estimations that consider these operational factors to provide realistic assessments of FTQC requirements. In this tutorial, we introduce the TopQAD™ (or “Topological Quantum Architecture Design”) software suite, which performs this automation. TopQAD enables users, for example, to explore how different hardware parameters affect resource requirements, offering multiple architecture choices based on the aforementioned trade-offs. As an attendee, you will be introduced to concepts that underpin a fair technological assessment of quantum computers and their likelihood to have utility. Then, through hands-on examples, you will learn how to use the TopQAD portal and the TopQAD Python API for FTQC design and evaluation, with metrics ranging from financial cost to qubit requirements. You will have the chance to compile quantum algorithms, profile the impact of noise on FTQC protocols, compare FTQC architectures, and generate detailed resource estimates for running any quantum algorithm. We will show how to use TopQAD to configure error-correction settings, interpret performance trade-offs, and generate reports that guide hardware and software design decisions. By the end of the tutorial, you will have a clear understanding of how resource requirements scale with different algorithm and hardware choices, and will be equipped with the tools and knowledge to apply TopQAD for your unique needs, whether this means helping you to develop quantum policy and investment strategies or using it in your own research goals aimed towards supporting utility-scale quantum computing R&D.

To get the most out of the tutorial, we recommend signing up in advance if you plan to follow along hands-on.

 
Target Audience — This tutorial is relevant to scientists and software developers seeking to expand their skill set, as well as business stakeholders and policymakers evaluating quantum computers and their economic, infrastructure, and technological implications. We will provide a brief introduction to quantum error correction and FTQC, and returns from the tutorial will be commensurate with the attendees’ quantum computing experience. All audiences, regardless of their quantum computing experience, will be able to engage hands-on with 1QBit’s software suite, TopQAD, during the session. Results from TopQAD can be analyzed to guide strategic decisions, whether for research and development, product development, investment, or policy. Those individuals with some experience in Python will have the opportunity to work with TopQAD’s software development kit (SDK). Those without this experience will be able to trial TopQAD through its web portal. Quantum computing graduate students and technical industry professionals working on quantum algorithms and their resource requirements or on quantum computing technologies and architectures will be able to experiment with how TopQAD can be used to support and accelerate their R&D through its automated framework. Public and private stakeholders will see how TopQAD can be used to evaluate key metrics for a fair technological assessment of quantum computers. Our tutorial will help stakeholders gain insights into the relationships between the commonly reported hardware specifications of quantum processors and the ultimate utility of the quantum computers built from them at scale.

Wednesday, Sep 3, 2025 — Tutorials Abstracts

TUT23 — Quantum Chemistry on Quantum Computers

  • Date — Wed, Sep 3, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — This tutorial will cover the basics of quantum chemistry on quantum computers by introducing the scope of the field, the basics of VQE, fermion-to-qubit mappings, and a brief discussion on error correction. The tutorial will cover the theoretical concepts alongside a hands-on component. Attendees will have submitted a chemistry problem to a quantum simulator and understood the theory + code by the end of the tutorial.
 
Abstract — Quantum chemistry is a promising application for quantum computing, and extensive research has gone towards harnessing quantum computing’s strengths toward applications for chemistry. Many software packages have also been developed for this purpose, either as standalone modules or as connectors between quantum and chemistry software. Given the nature of both fields, it can be difficult to know where to start and how. This tutorial is aimed at beginners who are curious to learn more about chemistry applications. It will teach all the required basics before going into detail about how quantum computing can be used for a chemistry problem. While it will cover all required theoretical concepts, the tutorial will be hands-on, with attendees working their way to submitting a chemistry calculation on a quantum simulator. It will cover quantum chemistry on a classical computer, the Variational Quantum Eigensolver (VQE), fermion-to-qubit mappings, and the application of the VQE in chemistry. Multiple fermion-to-qubit mappings will be explored. There will also be a brief discussion on errors and the role it plays in calculations. The hands-on portion of the tutorial will be done in Python, using popular scientific libraries such as Qiskit and PySCF. Attendees will be provided with a template Python notebook that will be filled out throughout the tutorial. qBraid accounts with some basic credits will be provisioned for every attendee to ensure ease of set-up, runtime, and access to simulators.
 
Target Audience — Attendees are expected to be familiar with coding in Python, though quantum or chemistry-specific experience is not necessary. The target audience is anyone who is curious about chemistry applications of quantum computing. All theoretical and programming knowledge required will be provided throughout the tutorial. Attendees should bring a laptop. qBraid accounts will be provisioned to easily provide all the necessary software, compute resources, and access to simulators. Students and professionals who are eager to explore a new field or develop a new skill set will particularly benefit from attending.
TUT24 — Hybrid HPC-QC Workflows for Solving Quantum Many-Body Systems on AWS

  • Date — Wed, Sep 3, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — Participants will gain hands-on experience in utilizing cloud-native HPC and QC technologies for hybrid workloads. They can follow along with instructor-led labs in pre-provisioned AWS environments provided free of charge and leave with code examples they can use as a foundation for their own projects.
 
Abstract — Classical Quantum Monte Carlo (QMC) methods leverage High Performance Computing (HPC) resources to simulate complex quantum many-body systems. Quantum computing (QC) has the potential to provide new routes to tackling these problems. Recently, a series of hybrid quantum-classical QMC methods have been proposed. These approaches seek to advance classical QMC by augmenting the classical algorithm with a quantum processing unit. In this tutorial, we demonstrate a solution to a quantum many-body problem using distributed heterogeneous classical and quantum computing resources on Amazon Web Services (AWS). To solve the problem, we utilize cloud-based batch and quantum computing to run a Quantum Monte Carlo (QMC) algorithm. The tutorial introduces QMC and QC basics to the participants and enables them to utilize cloud-native HPC and QC technologies for hybrid workloads. During the tutorial, participants will get free access to temporary AWS accounts and can follow the guided steps in the QMC workflow. All attendees leave with code examples they can use as a foundation for their own projects.
 
Target Audience — This tutorial is aimed at diverse audiences including students, researchers and engineers in computer science, quantum physics and chemistry, quantum computing, and HPC. Attendees from academia and industry gain a practical understanding of QC and QMC and hands-on experience running hybrid HPC-QC applications using real quantum computers in cloud-based HPC environments. Some familiarity with basic quantum computing terminology, Monte Carlo methods, and high-performance computing (HPC) is recommended. For the hands-on part, a basic understanding of the Python programming language and Jupyter Notebooks is required. The services AWS Batch and Amazon Braket, used to access and manage cloud-based HPC and QC resources, will be introduced during the first session of the tutorial.
TUT25 — Step-by-Step Guide to Solving Nonlinear Optimization with Quantum Computers

  • Date — Wed, Sep 3, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — In this tutorial, the attendees will learn the quantum optimization algorithms (e.g., Quantum Hamiltonian Descent (QHD)) for nonlinear nonconvex optimization problems and how to step-by-step modeling and solving optimization problems with the open-source software QHDOPT.
 
Abstract — Nonlinear optimization is a vibrant field of research with wide-ranging applications in engineering and science. However, classical algorithms often struggle with local minima, limiting their effectiveness in tackling nonconvex problems. Recently, the pursuit of quantum advantage in numerical optimization has become an active research direction, driving extensive algorithmic development. A notable candidate is the Quantum Hamiltonian Descent (QHD) algorithm, which enhances the exploration of complex optimization landscapes through the quantum tunneling effect, leading to improved performance in nonlinear optimization problems. In this tutorial, we introduce QHDOPT, an opensource, end-to-end software designed to solve nonlinear optimization problems using the QHD algorithm. With an intuitive interface and fully automated compilation procedures, QHDOPT enables users, including those without prior knowledge or experience in quantum computing, to harness the power of various quantum devices for nonlinear and nonconvex optimization tasks. We will provide step-by-step demonstrations on how to use QHDOPT to model and solve nonlinear optimization problems in real-world applications. Our use cases will cover a range of popular quantum computing platforms, including gate-based quantum computers (e.g., IonQ) and analog quantum computers (e.g., D-Wave).
 
Target Audience — This tutorial aims to address the needs of a broad spectrum of audiences in quantum computing, quantum technology, computer science, and electrical engineering. Specifically, we hope to target the following groups:

1) Industry professionals pursuing an off-the-shelf nonlinear optimization solver to tackle problems in electrical engineering and computer science (e.g., power engineering, networking, computer vision, and signal processing).
2) Research scientists interested in state-of-art research on quantum optimization for engineering problems.
3) Quantum computing experts interested in softwarehardware co-design for practical applications.
4) Undergraduate and graduate students interested in learning quantum optimization algorithm, software, and applications.

We will begin with a gentle introduction to quantum computing and quantum technology, focusing on quantum algorithms for optimization and their implementation on quantum computing hardware. The lack of automated tools for deploying quantum applications has motivated our development of QHDOPT, an open-source software that provides a unified optimization model and is compatible with various mainstream quantum computing platforms. This tutorial will also help quantum hardware providers better envision the possible form of automated software that leverages quantum computers to solve practical problems.
TUT26 — Encoders, Networks, and Circuits: Improving Variational Quantum Algorithms with Machine Learning

  • Date — Wed, Sep 3, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Participants will get hands-on experience with training quantum machine learning models and classical neural networks through the framework of neural-network-assisted quantum auto-encoded VQE (NN-AE-VQE). In the implementation, they are free to experiment with their own design choices and benchmark against well-known standards.
 
Abstract — Accurately simulating many-body particle systems, such as high-entropy alloys (HAE), remains challenging, as classical models often fail to capture complex dynamics or are too costly beyond small samples. Quantum computing offers a promising alternative, especially when integrated with machine learning. In our work, we enhanced the variational quantum eigensolver (VQE) by introducing a neural-network-assisted quantum autoencoder VQE (NN-AE-VQE), which reduces circuit parameters and eliminates costly optimizations. In this tutorial, we introduce the participant to quantum machine learning (QML), by walking through the steps required for training the NN-AE-VQE model. This includes quantum auto-encoding for qubit reduction of an atomic system and classical neural networks for parameter prediction of the reduced VQE ansatz. We will use the H2 case as an example, allowing participants to experiment with different QML kernels and settings. This provides an accessible hands-on experience to dive into QML. The skills gained in this workshop can be applied to various other applications, providing participants with a broad and versatile toolkit. The main framework and datasets will be readily available, allowing participants to focus on their design choices and the effects on the model. Similarly, benchmarking data will be available to allow participants to gauge the performance of their model.
 
Target Audience — This tutorial is intended for all who are interested in quantum algorithms, machine learning or simply quantum computing in general. The tutorial should serve as both an entryway to quantum machine learning and an opportunity for the more experienced audience to gain hands-on practice with more advanced elements. In general, this tutorial will align well with students and researchers with a background in (quantum) physics, computer science and engineering, electrical engineering and chemistry.
TUT27 — Accelerating Learning and Research in Quantum Error Correction with Loom

  • Date — Wed, Sep 3, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Attendees will gain a solid practical understanding of quantum error correction, along with an overview of key open research directions, and how Loom can be used to accelerate learning and research.
 
Abstract — Quantum error correction will be essential for large-scale quantum computation, yet there is a high barrier to entering the field for both education and research. This tutorial will provide a streamlined introduction to key concepts and cutting-edge problems in the field, with a minimum of theoretical complexity. The focus will be strongly hands-on, with all material introduced through examples coded in Loom, a software suite for designing, constructing, and analyzing quantum error correction codes and circuits. The tutorial will begin with a brief overview of quantum error correction codes, using the repetition and surface codes as working examples. We will see how to construct and simulate quantum memory circuits in Loom for both schemes. We will then study the basic lattice surgery building blocks for the surface code, aided by several simple experiments. In the second part of the tutorial, we examine how logic gates such as Hadamard and CNOT are compiled from sequences of surface code lattice surgery operations. We then construct and simulate physical-level circuits for generating small logical GHZ states in the surface code. Finally, we demonstrate how custom quantum error correction codes can be defined and analyzed in Loom, providing practical examples of how this approach supports novel research.
 
Target Audience — This tutorial is designed for undergraduate or graduate students working on quantum computing and/or quantum error correction and researchers who wish to learn how software can be used to accelerate or expand their work in quantum error correction. No background in error correction is required, however basic knowledge of quantum computing will be necessary. Basic programming skills in Python, as well as familiarity with working with Jupyter Notebooks, will also be essential.

Thursday, Sep 4, 2025 — Tutorials Abstracts

TUT28 — Quantum-Centric Supercomputing with Sample-Based Quantum Diagonalization and Qiskit Addons

  • Date — Thu, Sep 4, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Attendees will be introduced to sample-based quantum diagonalization (SQD)—a new technique for finding the eigenvalues of quantum Hamiltonians that have been shown to scale past variational and exact classical diagonalization methods. Attendees will gain hands-on experience with this technique, available as a Qiskit add-on, through concrete examples of applications in chemistry and lattice models.
 
Abstract — Calculating the ground state and low-energy spectrum of quantum systems, such as molecules and materials, is a significant computational challenge for strongly correlated systems. Quantum computing promises to speed up these calculations: fault-tolerant algorithms like phase estimation have the potential for an advantage over classical methods but require circuits too deep for pre-fault-tolerant devices. On the other hand, the VQE algorithm has been a cornerstone of quantum computer applications over the last decade but cannot scale to realistic use cases due to the large number of measurements required. In this tutorial, participants will learn about a new technique called sample-based quantum diagonalization (SQD), which is used to find eigenvalues and eigenvectors of quantum Hamiltonians. It can be run on pre-fault-tolerant quantum computers and has been shown to scale to problem sizes beyond what was possible with variational and exact classical diagonalization methods, making it a very exciting algorithm of recent interest [1], [2]. Participants will learn the theory of SQD and its open-source implementation as a Qiskit addon (a collection of modular software for building utility-scale workflows). We will cover concrete applications of SQD to chemistry Hamiltonians and lattice models. For each, we will provide a Jupyter notebook implementing the workflow, starting from circuit creation and quantum execution with Qiskit Runtime Primitives to energy estimation with the SQD Qiskit addon [3]. Participants will gain a foundational understanding of this technique and its potential for scaling up applications in chemistry and physics, and develop a working knowledge of the software and its applications to their own use cases.
 
Target Audience — The target audience of this tutorial includes researchers, quantum computational scientists, developers, and educators interested in learning how to use quantum computing for applications in chemistry and physics, and specifically, estimating the low-energy spectrum of quantum systems using state-of-the-art techniques in quantum-centric supercomputing. It is helpful, but not required if participants have a basic working knowledge of Python, Qiskit, and quantum computing concepts as they relate to chemistry and physics applications.
TUT30 — Entropy Quantum Computers — Principles and Applications

  • Date — Thu, Sep 4, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — This tutorial introduces the hardware engineering principles and practical applications of Dirac optimization devices. It covers entropy quantum computing, the photon temporal model framework, and Dirac devices' use for solving complex optimization problems, with hands-on exercises based on real-world applications in machine learning, financial modeling, and logistics optimization.
 
Abstract — This tutorial introduces participants to the hardware engineering principles and practical application of Quantum Computing Inc's Dirac optimization devices through the eqc-models and qci-client open-source software packages. We will explore the fundamentals of entropy quantum computing as it pertains to optimization models, explaining the photon temporal model framework for QIS and showcasing how Dirac devices can be leveraged to solve complex computational tasks. The session will cover the installation and configuration of the eqc-models package, provide hands-on demonstrations on programming and executing quantum optimization algorithms, and discuss real-world applications where these quantum technologies excel. Attendees will gain insights into the unique capabilities of Dirac devices, such as their use in machine learning, financial modeling, and logistics optimization, while learning to navigate the two interfaces.
 
Target Audience — Electrical engineers with some familiarity with optics, quantum mechanics, and optimization will learn the operational principles of entropy quantum computers, how to formulate optimization problems on them, and how to execute computations on them.
TUT31 — Adventures in High-Dimensional Quantum Error Correction in Python

  • Date — Thu, Sep 4, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — Attendees will learn about high-dimensional quantum computing, with a review of the setting and a basic overview of current experimental efforts, and stabilizer codes, the broadest class of quantum error correcting codes used to construct fault-tolerant computers. Participants will study and characterize these codes via concrete, hands-on programming in sdim, a qudit simulator made to study high-dimensional stabilizer codes.
 
Abstract — Despite the remarkable progress in the construction of noisy intermediate-scale quantum (NISQ) systems, the future of computing is the construction of fault-tolerant quantum computing (FTQC) systems. These systems involve encoding and operating on information via a quantum error correcting code (QECC), but currently, these codes require an overwhelming- ing number of qubits to practically implement FTQC. Most quantum devices support states beyond the lowest two typically used to encode qubits, which are appropriately called qudits. Recent developments have shown remarkable progress in their control, and qudits harbor attractive theoretical properties for error correction. This tutorial provides engineers and scientists an introduction to high-dimensional quantum computing. We will present a comprehensive foundation for stabilizer codes in all dimensions, accompanied by concrete examples and protocols. Afterward, participants will understand everything needed to define a QECC and perform computation within it. A key feature of these codes is that they are classically tractable to simulate and are thus extensively characterized via computation. The software is a stabilizer circuit simulator that has long since existed for qubit systems, but only recently has an open-source simulator for all dimensions been made available. Attendees will learn how to use this simulator through guided examples in the tutorial, as well as hands-on programming exercises. The session will culminate in attendees simulating and characterizing codes sourced from either provided examples or standard online resources.
 
Target Audience — This is a beginner-focused tutorial designed for all scientists and engineers interested in designing and realizing the first generation of fault-tolerant quantum computers and beyond. Fault tolerance is an effort across many design layers in computing, and so the intended audience is broadly distributed among hardware designers who suppress sources of noise, coding theorists who correct noise, and computer architects who tolerate noise. Their collaboration is necessary to cope with realistic noise conditions. While our focus is on qudits, the material serves as an introduction to quantum error correction in general, so those with little to no familiarity may greatly benefit. Theorists will learn how to utilize stabilizer simulation as a discovery and benchmarking tool, while engineers and architects will learn how to employ it as a validation and characterization tool. Basic knowledge of (qubit) quantum computing is assumed, but this tutorial is largely self-contained. Familiarity with Python is strongly encouraged; however, all relevant coding tasks can be accomplished by following guided examples as needed.
TUT32 — Quantum Communications and Sensing from Space

  • Date — Thu, Sep 4, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 13:00 – 14:30 & 15:00 – 16:30
 
Summary — In this tutorial, you will learn the theoretical foundations that underpin quantum communications and understand the engineering challenges faced when deploying this technology in the hostile space environment of space.
 
Abstract — The main aim of this tutorial is to develop amongst engineers from diverse backgrounds a solid understanding of the key concepts and principles that underpin the emerging and exciting new world of quantum communications. The tutorial is designed for graduate electrical engineers seeking to gain a deeper understanding of quantum communications, specifically those involving satellite transmissions. Quantum networks are anticipated to be the core networking technologies of the 21st century. In fact, these communication systems have already been introduced in the commercial world in various forms, including those used in space environments. The tutorial introduces the key concepts important for understanding, testing, analyzing and improving the performance of quantum communication systems. It will focus on actual quantum networks currently being deployed and their use for secure information transfer. Designed from an engineering perspective, the tutorial will first introduce the fundamental quantum concepts that underlie quantum technology, before exploring the applications of these concepts. The tutorial will focus on current developments in quantum communications via satellites and present aspects of quantum sensing from space.
 
Target Audience — This course is aimed at graduate-level engineers with a solid background in engineering principles and classical signal-processing techniques. The quantum mechanics required to understand the course will be presented from the ground up in an easy-to-understand vector and matrix formalism, material familiar to the IEEE Quantum Week community. It will assume no pre-requisite knowledge of quantum mechanics or telecommunications. The course should be interesting for those who wish to have an insight into emerging quantum technologies and the intersection of quantum mechanics with communications and sensing.
TUT37 — Accelerate Your Quantum Coding with Q#, VS Code and the GitHub Copilot

  • Date — Thu, Sep 4, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — This tutorial explores how to accelerate quantum programming using GitHub Copilot integrated with Microsoft’s Quantum Development Kit (QDK) and Q#. Participants will learn practical techniques and best practices for using AI-assisted coding in Visual Studio Code to write, debug, and optimize Q# programs more efficiently, with a focus on reducing boilerplate and enhancing algorithm development.
 
Abstract — Quantum coding meets AI in this session, which showcases the integration of Microsoft’s Quantum Development Kit (QDK) and Q# with GitHub Copilot. You’ll see how an AI pair programmer built into Visual Studio Code can suggest, generate, and even explain Q# code on demand, dramatically reducing the complexity of quantum programming and helping you get results faster. Boost your productivity with practical examples of Copilot accelerating quantum development. We’ll demonstrate how Copilot’s AI-driven assistance (from natural-language code prompts to leveraging QDK’s tools) empowers you to focus on algorithm logic instead of boilerplate. Whether you’re new to quantum or an experienced Q# coder, you’ll learn best practices to harness this integration for writing, debugging, and iterating on quantum solutions – faster and with far less friction.
 
Target Audience — The target audience for this tutorial includes:
  • Quantum computing beginners who want to explore Q# with the help of AI-guided support
  • Experienced Q# developers looking to boost productivity and streamline their development workflow
  • Software engineers and researchers interested in integrating AI tools like GitHub Copilot into quantum programming environments
  • Educators and students aiming to reduce the learning curve for quantum coding through practical, hands-on examples.

Friday, Sep 5, 2025 — Tutorials Abstracts

TUT33 — Operator Back Propagation (OBP) in Large Scale Quantum-Classical Environments

  • Date — Fri, Sep 5, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — Attendees will be introduced to Operator Back Propagation (OBP), a new technique that provides a way to reduce circuit depth in exchange for classical and quantum overhead. Attendees will gain an understanding of the working principle of OBP and also hands-on exposure to using this technique, available as a Qiskit addon, through concrete examples of applications in a condensed matter Hamiltonian, as well as an open coding session to try and apply to their problem of interest.
 
Abstract — Quantum computing is an increasingly popular field due to its potential to outperform classical computers in tasks like optimization, material design, and chemistry. However, scaling the size of problems run is limited by a variety of errors which persist in the existing systems. Developing novel encoding schemes or methods to mitigate the impact of these errors is essential for successfully simulating practical problems in the near term. Operator Back Propagation (OBP) integrates the Schrödinger and Heisenberg approach to quantum mechanics by evolving the quantum wavefunction as well as the observable. This implies that a portion of the computation is performed classically to update the observable, resulting in a lower-depth circuit that can be executed on the quantum computer. In other words, the observable backpropagates over a few slices of gates in the circuit, thus modifying itself while producing a new circuit with fewer slices. This technique, however, can cause the new observable to have more non-commuting terms, thus requiring more circuit executions. The number of non-commuting terms can be reduced by leveraging truncation, which, in its own right, will introduce some approximation error. However, with the appropriate selection of truncation and backpropagation, it is possible to achieve improved computational accuracy. This tutorial session explores the execution of OBP in Quantum-centric supercomputing (QCSC) software stack. The proposed approach utilizes distributed workflows and error management strategies in large-scale quantum-classical environments to discover the best slicing and truncation options, which reduces the circuit depth while keeping a check on the number of non-commuting terms in the modified observable. Broadly this tutorial session will demonstrate advanced techniques that enhance the practical applicability of supercomputing resources for quantum computation. Participants will specifically learn the theory of OBP, its open-source implementation, and distributed computation techniques to efficiently minimize the classical overhead and time of computation when using OBP for improving large-scale quantum algorithms.
 
Target Audience — The target audience of this tutorial includes researchers, quantum computational scientists, developers, and educators interested in learning how to use HPC resources for improved quantum computing application workflows and specifically, determine optimal parameters for operator backpropagation of quantum circuits. It is helpful, but not required if participants have a basic working knowledge of Python, Qiskit, and quantum computing concepts as they relate to physics lattice models.
TUT34 — Accelerating Quantum Computing Adoption: A Hands-on Tutorial With CUDA-Q and Amazon

  • Date — Fri, Sep 5, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — This tutorial provides an interactive introduction to quantum computing using CUDA-Q by running code on Amazon Braket. While it primarily focuses on leveraging learnable quantum walks to model financial data, participants will gain a variety of transferable skills, code samples, and resources they can apply to their own projects and potentially incorporate into their teaching curricula.
 
Abstract — As quantum computing evolves, the integration of quantum and classical systems will become a cornerstone of high-performance computing strategies, driving advancements in various scientific and commercial fields. Developing a skilled quantum workforce is vital to unlocking the full potential of quantum computing. To address this need, this tutorial introduces NVIDIA’s CUDA-Q, a programming model that integrates het- erogeneous QPU, CPU, GPU, and emulated quantum systems in both Python and C++. Access to classical and quantum resources will be made available through Amazon Braket, a fully managed quantum computing service designed to help speed up scientific research and software development for quantum computing. This tutorial provides an interactive introduction to quantum computing, focusing on programming variational algorithms with CUDA-Q. Participants will learn how to model complex systems, such as financial data, using a learnable multi-split-step quantum walk, and gain the skills to accelerate simulation on GPUs as well as execute programs on quantum hardware through Braket. Although the primary focus is on learnable quantum walks, the variational algorithm is general enough that attendees will take away transferable skills, including Jupyter notebooks and Python code, to apply to their own projects, enabling them to explore the potential of quantum computing in their fields. Additionally, faculty attending the session can use this material in their quantum computing courses, providing students with hands-on experience and practical skills in programming variational algorithms with CUDA-Q. This will help accelerate the development of a quantum-ready workforce and facilitate the integration of quantum computing into undergraduate and graduate curricula.
 
Target Audience — Participants should have a basic understanding of quantum computing concepts (quantum circuits, sampling, etc.) and have familiarity with a few quantum algorithms. Since we will be covering quantum walks, prior knowledge of them is neither necessary nor assumed. We expect learners to have some experience with Python and Jupyter notebooks.
TUT35 — Quantum Software Stacks: Overview, Requirements and Experiences

  • Date — Fri, Sep 5, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — In this tutorial, we will present the current challenges and requirements in setting up a comprehensive quantum software stack and discuss the current state of the art in this growing area. We will then discuss tradeoffs and possible architectures and design decisions, in many cases driven by our experiences in developing the Munich Quantum Software Stack (MQSS), which we use to operate the systems developed and deployed in the Munich Quantum Valley (MQV).
 
Abstract — As Quantum Computing systems mature and make their way out of laboratories into production computing environments, we also must rethink the needed software environments. For one, we must transition from supporting individual physics researchers, who are experts in quantum science, to a wide range of user communities in the various science disciplines wanting to use the power of quantum computing; at the same time, we also must ensure proper integration into workflows, schedulers, and system software environments used in existing computing environments without which a quantum system will not be practically usable. This requires the establishment of comprehensive software stacks beyond the currently often prevailing monolithic single-vendor approaches. On one hand, we must be able to support many programming abstractions and languages and, on the other, connect to a wide variety of backends with different scales and properties as well as different feedback mechanisms and capabilities. Between these two sides, we then require a sophisticated compilation and runtime stack that can coordinate and optimize quantum executions. Finally, we must connect the quantum systems to High Performance Computing (HPC) systems to integrate them into the existing ecosystem. In this tutorial, we will cover the necessary requirements for quantum software stacks, highlight the current state-of-the-art from both vendor and research perspectives, and lay out possible tradeoffs for the required software efforts and infrastructures. We will augment this with our experiences in building and operating a leading-edge software environment, the Munich Quantum Software Stack (MQSS) as part of the Munich Quantum Valley (MQV).
 
Target Audience — As the main audience, we target developers and users of software for quantum computing. However, we also aim to end-users/domain experts (who, eventually, will have to rely on this software to realize their applications) and physicists/experimentalists (who will have to run their devices via this software stack). Indeed, we strongly believe that more exchange among these groups is essential and urgently needed, especially in the development of the needed software intended to connect the different communities.
TUT36 — Photonic Quantum Information Processing: From Basics to Applications

  • Date — Fri, Sep 5, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — In this tutorial, the participants will be introduced to the experimental side of quantum information processing with photons. We will cover the basics and key techniques of generating, manipulating, and detecting quantum information encoded in single photons, as well as provide an overview of advanced applications in quantum communication, sensing, and computing technology.
 
Abstract — Optical qubits and qudits, encoded in discrete vari- able (single-photon) or continuous variable quantum states of light, offer a powerful platform for quantum information science applications. Naturally fast-travelling and resilient to noise, photons are ideal for applications that require remote information sharing, such as sensing, communication, and distributed computing. Several quantum computing industries are exploring optical approaches to building large-scale, fault-tolerant quantum computers. This tutorial focuses primarily on optical quantum technology’s experimental and hardware side. We will begin by outlining the fundamental concepts of photonics, with a focus on the tools used to generate, manipulate, and detect single photons. Key degrees of freedom, such as polarization, time-bin, spatial modes, and orbital angular momentum, will be introduced alongside experimental techniques for encoding quantum information into these degrees of freedom. Building on this foundation, we explore the creation, verification and distribution of entangled photonic states and their role in demonstrating quantum nonlocality and enabling entanglement-based quantum protocols in communication and metrology. We will conclude with an overview of important information processing routines that can be implemented with existing optical hardware.
 
Target Audience — This tutorial targets students and quantum computing researchers. It requires basic knowledge of optics and quantum physics.
TUT38 — Real-time Ultra-large-scale QEC Compilation and Execution

  • Date — Fri, Sep 5, 2025
  • Time — 10:00 – 16:30 Mountain Time (MDT) — UTC-6
  • Duration — Each tutorial is 3 hours long (2 sessions of 1.5 hours)
  • Fixed time slots — 10:00 – 11:30 & 13:00 – 14:30
 
Summary — This tutorial is presenting an open-source, full-stack compilation and execution framework for quantum computations protected by the surface code. You will learn the stages of the workow, how to compile, optimize and to congure each stage of the workow. Moreover, we will oer insights on how to build future software platforms on top of this open-sourced framework
 
Abstract — The execution of error-corrected computations requires the real-time compilation of high-level quantum computations into elementary native gates to be run on the physical hardware. We present a tool for compiling ultra-large scale computations, such as Fermi-Hubbard simulations, into surface code lattice surgery operations. The latter are automatically executed at the rate of a superconducting quantum computer. Our tool can collect the classical information generated by the surface code primitives and send it to decoders in order to track the necessary corrections imposed by the way non-Clifford gates are implemented. Moreover, we demonstrate the automatic tracking of so-called correlation surfaces, which are necessary for decoding correlated logical errors. In a nutshell, our tool is the foundation of an open-sourced real-time operating system for executing ultra-large scale quantum computations.
 
Target Audience — The minimum background required is a basic understanding of surface codes. You will learn how quantum computations are automatically compiled into surface code instructions, and how these instructions are then translated on-the-y in real-time into native quantum computer gates and measurements. Finally, the output of the quantum gates is interpreted by quantum error-correction decoders in order to maintain the fault-tolerance of the computation. The intended audience includes:
1. graduate students and researchers into QEC
2. quantum computing engineers
3. quantum software developers