IBM aims to deliver quantum error suppression and mitigation as a product feature in 2024, and plans to increase accuracy and speed of quantum workflows with the integration of error correction beginning in 2026, according to its roadmap.

The company launched its open source Qiskit Runtime containerized service for quantum computers back in 2016, targeted at allowing “the next set of users of quantum computing,” Tushar Mittal, senior product manager of Qiskit Runtime at IBM Quantum, told SDxCentral.

Mittal noted the software has three pillars: it allows users to optimize the execution of variational workloads; it provides a layer of abstraction on top of a foundational interface to perform tasks that are at the foundation of most algorithms that run on quantum systems; and IBM rolled out Qiskit Runtime primitives functions in April that make it easier to define an algorithm and configure an algorithm on its quantum system.

During the IBM Quantum Summit in November, the vendor introduced more error mitigation capabilities for the Qiskit Runtime primitives.

Mittal explained IBM’s efforts and progress on quantum error suppression, mitigation, and correction in an earlier interview.

SDxCentral: How do those new error mitigation capabilities for the Qiskit Runtime primitives work? Does it allow users to trade speed for reduced error count?

Mittal: So basically we believe that in terms of evaluating quantum advantage, users need to be able to evaluate the trade off scale, speed, and accuracy of a program, or a workload, or an application.

And so when we talk about error mitigation or the principle of error mitigation, error mitigation requires you to go through a pre-processing and post-processing step as a part of minimizing your errors. And so as a part of that we rolled out this option called resilience levels, which as you increase your resilience level you trade off more time so you take a more aggressive strategy in pre-processing and post-processing your circuit to optimize its results to increase its accuracy.

What's essentially happening there is you're able to train a model of the noise of the system that informs how you should mitigate it for the execution of your circuit or for the execution of your workload. That's where the trade off between runtime and accuracy of that workload comes into play. Our hope is as users build on top of it [it] can evaluate what is the cost of runtime that they're willing to wait for in order to achieve a target accuracy. We're interested in how that changes [in] algorithm development and how users perceive optimizing their algorithms.

With Qiskit Runtime, we really think optimizing the performance of these processors is a full-stack effort, it's not just tied to the chip. So error mitigation, error suppression, these are software capabilities that we're able to implement and optimize for our users because we have a fully-integrated stack. Our services are able to learn from the performance of the system and figure out the most efficient way to mitigate the noise or the imperfections that a user may encounter with noisy systems in this era of computer quantum computing today.

SDxCentral: What are IBM’s full-stack quantum error and noise mitigation efforts?

Mittal: Let me break this up into three pieces. There is Qiskit, which is our open source SDK. In Qiskit, our goal is to really allow users to efficiently design and build circuits, compile circuits, and prepare them for execution. That's kind of the goal of the open source SDK. The reason it's open source [is] we want users to be able to iterate on what is most efficient for them for designing their workloads.

Then you have Qiskit Runtime, which is our service interface to our hardware. This is really taking that Qiskit code and making sure it efficiently runs on the hardware. Now with the Qiskit Runtime service, what you're able to do is you're able to tune these knobs on error mitigation and error suppression as a part of the constructs that are in Qiskit, like the estimator and sampler, these primitives were a big part of our announcements throughout this year. These primitive interfaces are supposed to provide the next level of abstraction that users need. We're able to bake in these performance advantages that marry up to these interfaces within our service.

Then ... it's the hardware. It's all about how we link that Qiskit Runtime service that's optimizing the hardware to provide you access to the latest and greatest capabilities on our hardware. Those are the three steps of the equation of our service.

SDxCentral: IBM set the goal to deliver quantum error suppression and mitigation as a product feature in 2024. What will this feature look like before reaching the goals on quantum error correction?

Mittal: There's a lot of work we can do. For example, we want to make these method mitigation methods more efficient, so maybe we can do the mitigation faster for you over that period of time. Or, we can mitigate a variety of our larger variety of types of workloads. What we want to do is we want to test these capabilities and make them more robust across the variety of use cases that users might want to use them for.

The key goal here is to enable users to experiment at larger scales. One example of the milestones that we're setting for ourselves is one of the other things we announced at the Quantum Summit, [which] was this 100x100 Challenge. That is really a story around bringing everything that we've talked about together, where this 100x100 Challenge is centered around enabling the challenge that we put out as we want to enable our users in 2024 to be able to run 100-depth circuits, so the complexity of the circuit is over the depth of 100 over 100 qubits, and then the key metric next to that is also within a day. So there's a speed story there, there's a scale story there, and then there's an accuracy story there. And these are milestones we've set for ourselves to be able to enable our users to be able to do this as we roll out these capabilities.

And we're going to continually try to optimize not only the capabilities we have for error mitigation and error suppression today, but maybe even explore new capabilities we need to integrate as a part of that.

We've launched two error mitigation methods, for example, as a part of the Summit, which was zero noise extrapolation and probabilistic error cancellation. And we're going to continue to look for ways to optimize those methods and even explore potentially new capabilities that fit into this regime that might be helpful for our users.

This interview was edited for length and clarity.