Qiskit 1.0: A Milestone For The World’s Most Popular Quantum Software

IBM has introduced the 1.0 release of Qiskit, a software stack for quantum computing that includes a hardware-agnostic, open-source software development kit. More importantly, it simplifies quantum programming. Qiskit 1.0 enables users to build and compile circuits with 100-plus qubits, and—as indicated by IBM’s long-term quantum roadmap—it lays the groundwork for future 1,000-plus-qubit workloads. Other notable changes in this release improve its stability policy, release cycles and versioning.

The Qiskit stack aims to help users discover new quantum algorithms, explore computational spaces where quantum excels and support the integration of quantum and classical resources in a quantum-centric supercomputing paradigm.

The interface for Qiskit 1.0 has also been revised based on user feedback to better adapt it to how it is used in practice. One of Qiskit’s significant changes is its formal adoption of semantic versioning. This is important because, throughout the lifecycle of the 1.x release series, the project will be committed to maintaining backward compatibility for publicly documented APIs.

Qiskit’s Development And Reach

Over its seven-year history, Qiskit has made significant contributions to quantum computing. Since its first release in 2017, IBM has tested, iterated and improved more than a hundred Qiskit point-releases. Today, Qiskit has evolved from a quantum SDK into a comprehensive software stack aimed at maximizing performance on advanced quantum hardware and enabling the discovery of quantum algorithms and applications.

Qiskit has a large and growing community of users. It has been downloaded more than 6 million times, and more than 550,000 users have also used Qiskit to construct and execute over 3 trillion quantum circuits. With those stats, it is easy to understand why many users view Qiskit as the de facto standard for creating, optimizing and executing quantum circuits and operators.

Qiskit 1.0 Capabilities

When Qiskit 1.0 came out, it became compatible with the new release of Qiskit Runtime, a quantum app that uses containers to increase computing efficiency by eliminating back-and-forth trips between separated quantum resources and classical resources. Among other things, this speeds up the number of quantum circuits that can be run in a given time.

Components of the Qiskit stack include the Qiskit SDK 1.x, AI-powered circuit optimization via the Qiskit Transpiler Service, execution modes via the Qiskit Runtime Service, a Qiskit Code Assistant and a serverless tool called Qiskit Serverless.

As another plus, Qiskit 1.0 provides users access to IBM’s fleet of quantum systems, including a 133-qubit Heron processor and multiple 127-qubit Eagle processors. If a user has a preference for a different system or is interested in comparing different quantum computers, Qiskit can run on hardware from Alpine Quantum Technologies, Amazon Braket, IonQ, IQM, Quantinuum and Rigetti.

Over seven years, IBM has learned what’s helpful in Qiskit and what isn’t. In some ways, Qiskit has become smaller even though the company has added more features. IBM has started trimming down excess applications and focusing on a smaller set of features representing users’ fundamental needs.

Changes To Qiskit 1.0 Primitives

IBM developed Sampler and Estimator primitives in earlier versions of Qiskit Runtime to optimize how code is sent to a quantum computer. The Sampler primitive samples from the output of a quantum circuit, returning bitstrings. Meanwhile, as its name implies, Estimator includes expected values of quantum operators so that users can calculate and interpret these values, which are needed for many algorithms.

The Estimator’s interface has been updated to make it convenient for users who want to use one circuit and many observables, which is the predominant use case. It has different execution modes that allow a user to tailor its interaction with hardware to match application needs.

In Qiskit 1.0, these primitives have been reversioned as SamplerV2 and EstimatorV2. Besides other advantages, these components make it easier to run complex quantum experiments by allowing more data to be handled simultaneously. Here are some of the updates:

1. Vectorized inputs make it easier for users to perform experiments with different parameters and observables. Vectors also allow users to run many different experiments at once and simultaneously collect all the results, making the whole process much more efficient.
2. Primitive Unified Blocs is a new concept introduced in Qiskit 1.0. A PUB is a group that contains circuits, parameters (values that can change in each experiment) and observables (what you’re measuring). The new system allows multiple PUBs to be inputted at once. Each PUB will be processed separately but within a single job.
3. EstimatorV2 has a “precision” argument that lets users specify measurement accuracy. SamplerV2 has a “shots” argument determining how often each experiment will be repeated. Specifying the precision of measurements provides more detailed results from experiments.

Other significant changes in Qiskit 1.0 relate to policy stability, release cycles and versioning. Qiskit 1.0 will have less-frequent breaking changes and better bug support, and it will provide better backward compatibility to support earlier releases.

In earlier iterations of Qiskit, when quantum research was ramping up, it was essential to have tools that could rapidly adapt. Quantum is still a nascent field, so we do still need tools with rapid adaptability—but it doesn’t have to be so fast. Rather, we need it to be more stable and reliable for users trying to use these tools for research and operational work.

The Xs, Ys And Zs Of Semantic Versioning

One of the reasons that IBM has committed to an 18-month support cycle for each major version of Qiskit is that it has officially changed to semantic versioning, which has three components designated as X.Y.Z.

X represents a major version that can be issued once a year. It is the only release that can contain breaking changes to the Qiskit SDK.

Minor versions (Y) will come between major version releases and will be released about every three months. Bug support for previous minor releases will end once a new minor version is published.

As needed, IBM will release patch versions (Z) to publish backward-compatible bug fixes. These releases will come out as needed as bugs are identified. No new deprecations, features or public API changes will be made between these patch versions.

IBM also plans to further improve Qiskit security and usability. That plan includes a six-month support overlap when a new major version is released to provide a transition period between major versions. The release schedule was designed with those plans in mind.

Improving Implementation Of Quantum Algorithms And Applications

IBM is also working on a plan to increase Qiskit’s ability to help users implement quantum algorithms and applications. Qiskit already has a robust framework for understanding the complexity of quantum algorithms. The process includes mapping, optimizing, executing and post-processing. To improve the overall process, IBM is examining and tweaking each step.

Qiskit provides a robust circuit and operator toolkit in the mapping step. Qiskit 1.0 allows users to create a wider variety of circuits, including dynamic circuits that can change during operation. It also supports the creation of larger circuits because it has reduced the memory footprint of Qiskit’s quantum circuit by 32x. IBM plans to reduce that footprint even further, but this is a significant step towards enabling users to work with larger, utility-scale circuits within its system constraints.

IBM provides examples of dynamic circuits that can be created with OpenQASM and its more expressive circuit construction features. Elements such as branches, loops and classical expressions now have native support within the Python-based circuit SDK.

The company has also improved the ability to import and export OpenQASM circuits, which facilitates the exchange of other tools as well. Suppose a user must use a different tool to construct or transpile circuits. In that case, the OpenQASM import/export feature links Qiskit and the broader quantum software ecosystem.

IBM has also made significant progress in memory reduction, as demonstrated by the system measurements while running variational algorithms with TwoLocal circuits, a classic ansatz for certain variational algorithms. This reduction in memory usage is a major improvement because it allows more complex or larger quantum circuits to run, potentially leading to more powerful quantum computations. The reduction is achieved mainly by reusing data and converting some essential parts of Qiskit’s quantum circuit structure into Rust rather than Python. Basically, it’s a Python interface to Rust internals.

So, can this technique of reducing memory usage in Qiskit potentially be used to achieve quantum advantage? After all, it allows more complex or larger quantum circuits to be run and results in more powerful quantum computations.

The problem is that achieving quantum advantage also depends on many other factors, including the specific problem being solved, the design of the quantum algorithm and the capabilities of the quantum hardware. So while this technique might be a step forward, it’s only one part of a more extensive set of strategies and technologies needed to achieve quantum advantage.

Optimization With Rust

Qiskit’s transpiler and pass manager infrastructure now allow users to compose an optimization pipeline by connecting different components. In support of this, it has taken IBM two years to make the performance improvements needed to convert Qiskit from a pure Python project to one with Rust inside. This process involved identifying hotspots and converting performance bottlenecks into Rust.

The new Qiskit stack has enabled several performance improvements, such as 16x faster circuit optimization, 3x memory usage reduction, 5x faster utility-scale workloads and 40% reduction in circuit depth using AI and heuristic passes.

Internally, Qiskit represents circuits as graphs, with each operation in the quantum circuit being a node in a directed graph. Graph manipulations are the core of every algorithm and the core data structure that every algorithm in the transpiler needs to work with. The system conversion process started by replacing a pure Python graph representation library with a new Rust library for representing and manipulating graphs. This process is still ongoing, but efforts have already yielded impressive results.

Most of what is provided in the package that runs locally on a user’s laptop for circuit optimization are heuristic methods. The problem of taking an input quantum circuit and its more abstract form and finding the optimal circuit is an NP-hard classical problem. So, the doable task becomes finding efficient approximate methods and efficient heuristic methods that provide good, but not necessarily optimum, circuits.

Qiskit And AI

The Qiskit Transpiler Service is now available to premium customers. Qiskit is already equipped with robust and best-of-breed approximations. IBM is now supplementing hand-crafted algorithms with AI and machine learning techniques.

The above graph shows the result of Qiskit’s built-in passes versus the new AI approach. There are specific circuits where it effectively produces equivalent outputs. Still, there’s a much broader range of circumstances where AI reinforcement learning methods beat human-generated heuristics.

Wrapping Up

The Qiskit stack supports IBM’s Quantum Development and Innovation Roadmap for error-corrected systems. The stack enables open, iterative and collaborative development of quantum algorithms and applications across industries and domains. The release of Qiskit 1.0.0 SDK is one of the most significant quantum milestones after seven years of incremental improvements.

Qiskit 1.0 eliminates old technical issues accumulated over seven years of development. If you look at the documentation, you’ll notice that the Qiskit 1.0.0 release is free of deprecation warnings, and that the upgrade section is longer than usual. These details are directly related to the technical debt cleanup.

As IBM continues to scale Qiskit for larger qubit counts and circuit sizes to match the quantum roadmap, maintaining the balance between Qiskit performance and usability will be an ongoing challenge. To this end, IBM has just begun to integrate AI and machine learning techniques into core Qiskit features such as circuit optimization. While this approach shows promise, further integration of AI into Qiskit development is still an emerging area with open questions about scalability and interpretability. However, success in this area will produce major benefits and increased functionality for users in future versions.