Chapter 12 of Quantum from the Ground Up covers NVIDIA Ising, two machine learning models that calibrate quantum hardware and decode its errors. Chapter 19 names Qiskit, Cirq, and PennyLane as the standard programming frameworks and moves on, which is about the attention most programmers give a compiler until it breaks. The software that turns a quantum idea into something a chip can run gets little space in the book. Two announcements from the past three months change that: IBM’s Qiskit v2.5 release in July, and a generative AI method from Oak Ridge National Laboratory, IonQ, NVIDIA, and the University of Tennessee, Knoxville in September.
 |
| A quantum program moves from algorithm to circuit to compiler to hardware. DQAOA-GPT generates circuits in simulation, and Qiskit v2.5 speeds up the compile step. Figures are reported by IBM and IonQ. Source: gordostuff.com |
What a Quantum Program Is
Start with what a quantum program is. A quantum program is a circuit: a list of gates applied to qubits, followed by measurements. A gate is a basic operation on one or two qubits. You write the circuit in a framework such as Qiskit, an open-source Python toolkit maintained by IBM. The circuit you write cannot run as written. Each chip supports only a small set of native gates, and on many chips a qubit can interact only with its neighbors. A compiler, which Qiskit calls a transpiler, rewrites your circuit using the gates the chip supports. It assigns the qubits in your circuit to physical qubits and adds extra operations to carry information between distant ones. It also trims the circuit where it can. Every added gate adds a chance of error, so a better compiler produces more reliable answers from the same hardware.
A Faster Compiler in Qiskit v2.5
Qiskit v2.5 improves this layer in several ways. IBM reports typical transpilation speedups of two to three times on its benchmark circuits, and a 115-qubit circuit now routes in about two thirds of the earlier time. Routing is the step that moves information between distant qubits. A new default optimization pass chooses gate decompositions with higher predicted fidelity, the estimated chance a circuit runs correctly. IBM notes that the pass can add gates or depth when that raises the prediction.
Compiling for Fault-Tolerant Machines
The larger change targets fault-tolerant machines, the error-corrected systems that Chapter 6 and Chapter 12 describe. Qiskit now ships two preset compilation pipelines for them. The first compiles to Clifford+T, a standard gate set for error-corrected hardware. Clifford gates are relatively inexpensive to run on such a machine. T gates require magic states, the costly resource behind the Quantinuum work in Chapter 6, so compilers try to use as few T gates as possible. Qiskit lets you adjust synthesis accuracy to trade T-gate count against approximation error. The second pipeline compiles to Pauli-based computation, which expresses a program as a sequence of rotations and measurements built from the three basic Pauli operators, X, Y, and Z. In IBM’s example, the LitinskiTransformation optimization pass cut a phase estimation circuit from 1,354 Pauli rotations to 443. Phase estimation is a common subroutine in quantum algorithms, including the factoring method behind the encryption threat in Chapter 13. Fewer rotations mean fewer expensive operations on a future error-corrected machine.
A New Framework and a New Name
Version 2.5 also adds a framework for compiling through several intermediate representations, which are program formats that sit between what you write and what the chip runs. IBM calls it an early step. The release also renames Qiskit Runtime Service to IBM Quantum Compute Service. The change is naming only, so current documentation may use either name for the same software.
AI/SI-Generated Circuits
The second announcement uses AI/SI to generate circuits. Many useful problems are optimization problems, which ask for the best choice among a huge number of combinations. DQAOA, the distributed quantum approximate optimization algorithm, splits a large problem into smaller subproblems, solves each with a small quantum circuit, and combines the results. Larger subproblems tend to give better answers. Each circuit has adjustable settings called parameters, and the standard method finds good values by looping: run the circuit, measure the result, adjust, and repeat, sometimes hundreds of times. That tuning time limits how large the subproblems can grow.
How the Model Works and What It Showed
The researchers ran the standard method on many sample problems and kept only the near-optimal circuits. They trained a transformer on those circuits. A transformer is the model type behind large language models. This one trained on circuits. At solve time it generates ten candidate circuits per subproblem, simulation scores all ten, and the best one updates the overall solution. The model skips the tuning loop. Circuit-finding time for the standard method rose from about 34 seconds at 4 qubits to over 11 minutes at 12 qubits. The AI/SI method stayed near 28 seconds at every size tested. IonQ reports that answer quality roughly doubled as subproblem size grew on a dense 100-variable Higher-Order Unconstrained Binary Optimization (HUBO) benchmark. The team presented the work at IEEE Quantum Week 2026 in Toronto, and reports say it won a best paper award.
Limits of the Results
Every test ran in simulation. The circuits ran on a single NVIDIA H200 GPU at Oak Ridge using CUDA-Q and cuQuantum, NVIDIA software that simulates quantum circuits on GPUs. Both circuit-generation methods used the same setup, so the comparison covers two ways of producing circuits, with no quantum hardware involved. The authors describe the results as benchmark-scale validation, and hardware runs remain a stated future goal. Both sets of figures in this post come from the organizations that built the tools.
What This Changes in the Book
In the book, Chapter 12 describes the NVIDIA Ising calibration agent as a vision-language model and its decoder as a 3D convolutional neural network, both machine learning tools applied to quantum data. DQAOA-GPT adds a transformer that generates circuits, which extends the same pattern to the programming layer. Chapter 18 lists machine learning model fine-tuning among the skills a candidate can bring without a physics PhD, and training a transformer on a library of good circuits fits that description. The Chapter 18 list also gains an entry: compiler and software tooling development. The Qiskit 2.5 work involves multithreading, a C interface, and compiler pipelines, all conventional software engineering. Chapter 19 names the computer science bachelor’s degree as the main path into quantum software, and the compiler work above is computer science.
This post will be folded into the next quarterly edition of Quantum from the Ground Up. Every edition of the book is available as a free download.
