IBM Circuit function

Overview

The IBM® Circuit function takes abstract PUBs as inputs, and returns mitigated expectation values as outputs. This circuit function includes an automated and customized pipeline to enable researchers to focus on algorithm and application discovery.

Description

After submitting your PUB, your abstract circuits and observables are automatically transpiled, executed on hardware, and post-processed to return mitigated expectation values. To do so, this combines the following tools:

• Qiskit Transpiler Service, including auto-selection of AI-driven and heuristic transpilation passes to translate your abstract circuits to hardware-optimized ISA circuits
• Error suppression and mitigation required for utility-scale computation, including measurement and gate twirling, dynamical decoupling, Twirled Readout Error eXtinction (TREX), Zero-Noise Extrapolation (ZNE), and Probabilistic Error Amplification (PEA)
• Qiskit Runtime Estimator, to execute ISA PUBs on hardware and return mitigated expectation values

Get started

Authenticate using your IBM Quantum™ Platform API token, and select the Qiskit Function as follows:

from qiskit_ibm_catalog import QiskitFunctionsCatalog
 
catalog = QiskitFunctionsCatalog()
function = catalog.load("ibm/circuit-function")

Example

To get started, try this basic example:

from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService
 
# You can skip this step if you have a target backend, e.g.
# backend_name = "ibm_sherbrooke"
# You'll need to specify the credentials when initializing QiskitRuntimeService, if they were not previously saved.
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
 
circuit = random_circuit(num_qubits=2, depth=2, seed=42)
observable = "Z" * circuit.num_qubits
pubs = [(circuit, observable)]
 
job = function.run(
  backend=backend.name,  # Or `backend=backend_name`, if you didn't initialize a backend object
  pubs=pubs
)

Check your Qiskit Function workload's status or return results as follows:

print(job.status())
result = job.result()

The results have the same format as an Estimator result:

print(f'The result of the submitted job had {len(result)} PUB and has a value:\n {result}\n')
print(f'The associated PubResult of this job has the following DataBins:\n {result[0].data}\n')
print(f'And this DataBin has attributes: {result[0].data.keys()}')
print(f'The expectation values measured from this PUB are: \n{result[0].data.evs}')

Parameters

See the following table for all input parameters the IBM Circuit function accepts. The subsequent Options section goes into more details about the available options.

Options

Structure

Similar to Qiskit Runtime primitives, options for IBM Circuit function can be specified as a nested dictionary. Commonly used options, such as optimization_level and mitigation_level, are at the first level. Other, more advanced options are grouped into different categories, such as resilience.

Defaults

If you do not specify a value for an option, the default value specified by the service is used.

Mitigation level

IBM Circuit function also supports mitigation_level. The mitigation level specifies how much error suppression and mitigation to apply to the job. Higher levels generate more accurate results, at the expense of longer processing times. The degree of error reduction depends on the method applied. The mitigation level abstracts the detailed choice of error mitigation and suppression methods to allow users to reason about the cost/accuracy trade-off appropriate to their application. The following table shows the corresponding methods for each level.

Similar to resilience_level in Qiskit Runtime Estimator, mitigation_level specifies a base set of curated options. Any options you manually specify in addition to the mitigation level are applied on top of the base set of options defined by the mitigation level. Therefore, in principle, you could set the mitigation level to 1, but then turn off measurement mitigation, although this is not advised.

The following example demonstrates setting the mitigation level:

options = {"mitigation_level": 2}
 
job = function.run(
  backend=backend.name,
  pubs=pubs,
  options=options
)

All available options

In addition to mitigation_level, the IBM Circuit function also provides a select number of advanced options that allow you to fine-tune the cost/accuracy trade-off. The following table shows all the available options:

In the following example, setting the mitigation level to 1 initially turns off ZNE mitigation, but setting zne_mitigation to True overrides the relevent setup from mitigation_level.

options = {
  "mitigation_level": 1,
  "resilience": {"zne_mitigation": True}
}

Fetching error messages

If your workload status is ERROR, use job.result() to fetch the error message to help debug as follows:

print(job.result())

Get support

Reach out to IBM Quantum support, and include the following information:

• Qiskit Function Job ID (qiskit-ibm-catalog), job.job_id
• A detailed description of the issue
• Any relevant error messages or codes
• Steps to reproduce the issue

Next steps