Skip to main contentIBM 

New developer tools for quantum computational scientists

Today, a new kind of user is beginning to use our processors: quantum computational scientists. When it comes to using quantum computers, these users approach problems differently, and they require a distinct set of tools and capabilities.

New developer tools for quantum computational scientists

4 Dec 2023

Ismael Faro

Quantum computational scientists aren’t as interested in the inner working of our hardware. Rather, our research has shown that they want quantum computers to offer performance capable enough to advance their fields, compatibility with their current computing workflows, and ease-of-use so that they need not learn quantum physics just to solve their hard computational problems.

A new audience means that we must ensure our hardware, software, and services meets the needs of these quantum computational scientists. Most importantly, we must equip them with the tools they need to run the 100+ qubit circuits required to advance science in this era of quantum utility.

At this year’s IBM Quantum Summit, we showed off a suite of new high-performance tools for the era of utility. As users begin thinking about creating quantum functions, rather than writing circuits, we’ve designed Qiskit Patterns, a new simple collection of steps for tackling problems with quantum computers. We also announced the release of Qiskit 1.0 scheduled for February, a stable Qiskit focused on programming with Patterns, plus new set of tools using AI to help write and optimize Qiskit and QASM3 code. And we announced the beta release of Quantum Serverless on the IBM Quantum Platform, to facilitate run remote execution Qiksit Patterns, in a quantum function style.

Read more about the hardware and software for the era of quantum utility, here.

A new way to approach problems: Qiskit Patterns

Until relatively recently, all quantum computers were small, experimental devices primarily used for advancing the study of quantum computing itself. Entering the era of quantum utility means the quantum computers we have today are valuable, useful tools researchers can use to make scientific advances.

This means that users aren’t just thinking about how to run pre-built algorithms on quantum hardware. They must deconstruct their algorithms and figure out where and how to insert a quantum routine.

That’s the purpose of Qiskit Patterns — a four-step process for running algorithms on a quantum computer. Qiskit Patterns can be composed from reusable building blocks allowing for code reuse and simplification. Tailoring Patterns would then be a simple replacement of blocks with IBM-defined components by third parties code, services or open-source components. This will maximize compatibility, with existing software ecosystems for easier acceleration of workflows.

Qiskit Patterns code

Qiskit Patterns code.

So, what are those steps?

First, we must map the problem to abstract quantum circuits and operators. These operators and circuit represent the encoding of the the problem and inputs, and for example a chemistry problem would be represented by a quantum circuit that encodes the wave function and the operators could be the energy Hamiltonian.

Second, we must optimize our quantum circuits and operators to the hardware. This includes using a transpiler to transform our circuits so they respect the constraints and instructions of the hardware. It also includes optimizations that reduce circuit depth and gate count. The result of this step is an optimized IBM Quantum Instruction Set Architecture (QISA) representation of circuits and operators.

Third, we must execute our circuits in a runtime that includes both quantum, and near-time classical processing. During this step, we use Qiskit Primitives to run these QISA circuits on IBM quantum hardware, while performing any error mitigation using additional classical compute resources.

Finally, we must post-process our results to create outputs in the expected format like values or graphs.

As you’ll see, these patterns serve as the framework underlying our software and services.

Steps 1 and 2: Qiskit 1.0 New Tools for the Era of Utility

Back in 2017, we released Qiskit, an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives. Today, Qiskit has matured into the lingua franca of quantum computing, allowing programmers to write circuits, then execute them on hardware from more than eight different hardware manufacturers. And at this year’s IBM Quantum Summit, we announced our plan to release Qiskit 1.0 next February, now with increased performance, stability, and reliability.

For Step 1, Qiskit’s Circuit Toolkit continues to focus on the efficient construction and manipulation of quantum circuits. Its Operator Toolkit also provides tools for building and evaluating quantum operators. But now, in Qiskit 1.0, developers can construct dynamic circuits with loops, branches, and classical expressions. Qiskit 1.0 also comes with major improvements in memory footprint of circuits — a 55% decrease in memory usage compared to Qiskit 0.39; the version released at IBM Quantum Summit 2022.

Now, in Qiskit 1.0, developers can construct dynamic circuits with loops, branches, and classical expressions.

For Step 2, Qiskit converts abstract circuits to QISA circuits that respect the constraints of the target hardware and optimizes circuit performance. The pass manager lets you flexibly configure what optimizations are applied to your circuits. Qiskit 1.0 features updates to our industry-leading transpiler, allowing you to obtain shorter depth circuits with faster transpilation times — 16x faster binding and transpiling compared to Qiskit 0.33 and 23% fewer two-qubit gates compared to another popular quantum SDK.

Finally, at this year’s IBM Quantum Summit, we announced our new Transpiler Service and tools that will make it even easier to run circuits in the utility era. This service is based in Qiskit and in our new AI models trained using reinforcement learning. The new AI Transpiler passes produce highly optimized circuits. We observe a 20-50% improvement in circuit depth and CNOT count compared to equivalent Qiskit transpiler passes. This service is available to Premium user as an alpha release, and it is going to be a important piece of how to use Qiskit Patterns in an efficient way.

Circuit routing

Circuit routing.

Step 3: Execution modes

Execution modes

Execution modes.

Creating value with utility-era quantum requires that you run circuits on real, 100+ qubits quantum systems as part of Step 3. In many quantum algorithms users will be running lots of circuits in parallel taking advantage of IBM Quantum System Two and speeding up the execution.

Therefore, we are further optimizing our existing execution modes available via Qiskit Runtime and expanding to more efficiently support utility-scale work. As always, you can submit single jobs — a single primitive request that contains all the context for executing your workload. This execution mode locks a quantum processing unit for your use solely for the length of the job.

Last year, we introduced Sessions alongside the Qiskit Runtime Primitives. A session is a context manager designed to optimize the execution of iterative workloads like VQE and QAOA. It enables these multi-job workloads to run efficiently by automatically prioritizing the intermittent jobs that are recursively submitted until the larger algorithm converges. This minimizes the queuing delays that the workload would otherwise incur if it were independently scheduling these related jobs.

And this year, we’re introducing a new execution mode: Batch.

Batch mode is a context manager that allows users to more efficiently run an experiment that is made up of a collection of independently executable jobs. This execution mode offers up to a 5x speedup by threading the compilation of each primitive job in the batch such that it can pack the quantum execution across jobs tighter together.  This has proved to be an efficient way to speedup the runtimes of some of the recent utility scale demonstrations, including the original utility experiment published this past summer.

Build, deploy, run with execution modes and Quantum Serverless

But easy-to-use, compatible quantum requires that you can deploy and run your patterns remotely without having to manage the complex dance of running code across different compute infrastructures. That’s the purpose of Quantum Serverless, enabling you to easily build, deploy, and execute your Qiskit Patterns.

Qiskit Patterns contain a combination of quantum and classical tasks. While building these patterns, we can incorporate Quantum Serverless to distribute or parallelize tasks for more efficient execution. Additionally, after we’ve built our Qiskit Pattern, we can upload it to a remote environment (HPC or cloud) with the Quantum Serverless provider. Our pattern is now ready to be called and executed. Finally, we execute the Qiskit Pattern on a remote, managed environment.

Quantum Serverless simplifies your experience — you no longer have to sit at your laptop and maintain a network connection while your job is queued and executed. You can submit your Qiskit Patterns for managed execution, leave, and come back when the results are ready for you. With this ability to upload patterns and in the future to share them as a quantum function the end user need not be fluent in quantum circuits to be able to utilize quantum computing.

We announced Quantum Serverless as an alpha at last year’s IBM Quantum Summit. Today are announcing its Quantum Serverless beta release as a managed service in the IBM Quantum Platform to facilitate its use with Qiskit Patterns. And soon, Qiskit Patterns will serve as the basis for the future Quantum Functions, which we plan to release in 2025.

AI to help develop and use quantum computing

As part of our strategy to facilitate the usage of quantum, we have presented other important tool in this summit, a generative AI code assistant called Qiskit Code Assistant. This is a powerful tool that will help you learn the best ways to use both Qiskit and IBM Quantum Platform services.

Qiskit code assistant

Qiskit code assistant.

This project started as a collaboration with IBM watsonx, and we have used the knowledge and services of our colleagues to bring you this tool. The base of the project is a Large Language Model created in IBM and based in a huge code dataset of about 110 programming languages called IBM Granite 20B Code. This Granite model is the Foundation Model we have extended and fine-tuned using Qiskit code and examples to create the new model, IBM Granite 20B Code Qiskit.

This model has 20B parameters, 8,000 context length, and was trained with about 370 million text tokens, based in a large collection of Qiskit examples thanks to all the content that we have been created over years. The model also is going to be updated and improved with the release of new features like Qiskit Patterns to improve your development and learning workflows and to take advantage of the new capabilities and functionalities that we are developing. This model is going to be accessible as a service in our IBM Quantum Platform, and early next year our premium users are going to be the first users invited to use the alpha version.

In order to facilitate the use of this service, we will also release also a Visual Studio Code extension to use these generative AI features so you can integrate this new complement in your developer workflow. We see the usage of AI tools as one of the critical paths to leveraging the full potential of quantum computing and empower our users to push the current boundaries.

View documentation