run(), added a check to whether the input circuits are actually dynamic. Issue a warning if the user specifies
dynamic=False, while the circuits are actually dynamic.
Python 3.11 is now supported.
Removed support for input circuit as Schedule to IBMBackend.run(). Use
pulse gatesinstead. See tutorial on how to use pulse gates.
Fix mapping for qubit registers when padding for fast-path cases, after transpiling. This mapping is required due to qiskit-terra #9332 <https://github.com/Qiskit/qiskit-terra/issues/9332>
Fixed a bug where the backend target
qubit_propertieswere not being decoded correctly.
Allow for users to retrieve all backends even if one of the backends has a missing configuration. The backend without a configuration will not be returned.
dynamicparameter is set to
run()and the backend being used does not support dymamic circuits, a warning will be raised.
When constructing a backend
qiskit.transpiler.Target, faulty qubits and gates from the backend configuration will be filtered out.
Match the adjustment of measurements for devices with odd short gate lengths.
Fixed a bug where
status()was not returning pending jobs.
An unnecessary call to
refresh()has been removed from
status(). Circuits and other job attributes were being re-fetched unnecessarily, causing slow job retrieval times.
The dynamic circuit odd cycle delay has been bumped from 1 cycle to 4 cycles to address hardware limitations.
run()now checks if the input circuits use a faulty qubit or a faulty edge.
Fixed an issue where instances were not being set when backend configurations were loaded in
Backend configurations are no longer loaded when
IBMProvideris initialized. Instead, the configuration is only loaded and cached during
Added the method
target_history(). This method is similar to
target(). The difference is that the new method enables the user to pass a datetime parameter, to retrieve historical data from the backend.
There will now be a warning if a boolean is passed in for the
Removed additional decomposition of
BlueprintCircuits in the JSON encoder. This was introduced as a bugfix, but has since been fixed. Still doing the decomposition led to possible problems if the decomposed circuit was not in the correct basis set of the backend anymore.
CZGatemappings have been added to the
Targetconstructor to fix a tranpile bug.
Support has been added for applying scheduling and dynamical decoupling for circuits with new format control flow (including nested control-flow).
from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister from qiskit.circuit.library import XGate from qiskit.transpiler.passmanager import PassManager from qiskit_ibm_provider.transpiler.passes.scheduling import DynamicCircuitInstructionDurations from qiskit_ibm_provider.transpiler.passes.scheduling import ALAPScheduleAnalysis from qiskit_ibm_provider.transpiler.passes.scheduling import PadDynamicalDecoupling from qiskit.providers.fake_provider import FakeJakarta backend = FakeJakarta() durations = DynamicCircuitInstructionDurations.from_backend(backend) qc = QuantumCircuit(2, 2) with qc.if_test((0, 1)): qc.x(0) qc.measure(0, 1) with qc.if_test((1, 1)): qc.measure(1, 1) dd_sequence = [XGate(), XGate()] pm = PassManager( [ ALAPScheduleAnalysis(durations), PadDynamicalDecoupling(durations, dd_sequence), ] ) qc_dd = pm.run(qc)
Scheduling support for
c_ifhas been removed. Please run the pass
qiskit.transpiler.passes.ConvertConditionsToIfOpson your circuit before scheduling to convert all old format
c_ifstatements to new format
if_testcontrol-flow that may be scheduled.
from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister from qiskit.transpiler.passes import ConvertConditionsToIfOps from qiskit.transpiler.passmanager import PassManager from qiskit_ibm_provider.transpiler.passes.scheduling import DynamicCircuitInstructionDurations from qiskit_ibm_provider.transpiler.passes.scheduling import ALAPScheduleAnalysis from qiskit_ibm_provider.transpiler.passes.scheduling import PadDynamicalDecoupling from qiskit.providers.fake_provider import FakeJakarta backend = FakeJakarta() durations = DynamicCircuitInstructionDurations.from_backend(backend) qc = QuantumCircuit(1, 1) qc.x(0).c_if(0, 1) pm = PassManager( [ ConvertConditionsToIfOps(), ALAPScheduleAnalysis(durations), PadDelay(), ] ) qc_dd = pm.run(qc)
IBMBackendnow returns the
ibm_dynamic_circuitstranslation stage as its plugin translation stage. This will automatically add custom transformations when calling the transpiler that are tuned for IBM quantum hardware.
If an instance is passed in when initializing
IBMProvider, the instance will be used for filtering backends and jobs in
retrieve_job()now only retrieve jobs that are run with the
qasm3-runnerprograms. Jobs run from
qiskit-ibm-runtimewill not be retrievable because their results are in an unsupported format.
Fixed a bug where users could not initialize
IBMProviderif they were in a h/g/p without any backends.
The meth:~qiskit_ibm_provider.IBMProvider.instances was added to list all the available instances in a provider instance.
A new transpiler pass
qiskit_ibm_provider.transpiler.passes.basis.ConvertIdToDelay was added which converts an :class:`qiskit.circuit.library.IGateto
qiskit.circuit.Delay. This was added to the default transpiler plugin
Users can now retrieve jobs run from the previous provider,
retrieve_job(). There is also a new
jobs()for retrieving these jobs in bulk.
A bug was fixed in
qiskit.transpiler.passes.scheduling.LAPScheduleAnalysiswhich was caused by an bad interaction between duration-less gates such as
A bug was fixed where conditional
qiskit.circuit.library.IGatewere being converted to unconditional
qiskit.circuit.Delayoperations rather than conditional operations.
Fixed an issue where filtering by instance with
jobs()was not working correctly.
Filtering backends with the parameter
backends()has been removed because it is no longer in use and not supported by the runtime api.
transpiler module has been added. It will contain routines that are specific to IBM hardware backends and which consequently can not be placed directly within Qiskit Terra.
qiskit-ibm-provider is a new Python API client for accessing the quantum systems and simulators at IBM Quantum.
This new package is built upon the work already done in qiskit.providers.ibmq.backend module in the qiskit-ibmq-provider package and replaces it going forward. The backend module in qiskit-ibmq-provider package is now deprecated. Please take a look at the mirgraion guide here.
qiskit-ibm-provider is not included as part of Qiskit meta package and thereby you have to install it separately using
pip install qiskit-ibm-provider.
A scheduling analysis pass,
ASAPScheduleAnalysishas been added for Qiskit dynamic circuit (OpenQASM 3) backends. This is capable of handling scheduling for deterministic regions of a quantum circuit and may combined with a padding pass such as
PadDelayto pad schedulable sections of a circuit with delays.
For an example see the
A dynamical decoupling pass has been added for IBM Quantum dynamic circuit backends
PadDynamicalDecouplingto pad schedulable sections of a circuit with dynamical decoupling sequences. It relies on having run the
ALAPScheduleAnalysisanalysis prior to the padding sequence.
For an example see the
Measurements no longer interrupt scheduling regions on dynamic circuit backends using the
Measurements and resets now merged topologically when scheduling
transpiler`has been added.
Primarily, it will contain all specialized Qiskit routines for running applications on IBM’s next-generation quantum devices that support dynamic capabilities such as control-flow(feedforward) and classical compute.
Python 3.10 is now supported.
You can now use the
qiskit_ibm_provider.ibm_backend_service.IBMBackendService.backends()to find backends that support dynamic circuits.
It is now possible to select the Qiskit runtime program ID to use for
run()through the input argument
IBMQglobal variable which was an instance of the
IBMQFactoryhas been removed.
AccountProviderclasses have been removed and the functionality provided by these two classes have been combined and refactored in the new
IBMProviderclass. This class will provide a simplified interface as shown below and serve as the entrypoint going forward.
save_account()- Save your account to disk for future use and optionally set a default instance (hub/group/project) to be used when loading your account.
IBMProvider()- Load account using saved credentials.
saved_accounts()- View the accounts saved to disk.
delete_account()- Delete the saved account from disk.
IBMProvider(token="<insert_api_token>")- Enable your account in the current session.
active_account()- List the account currently active in the session.
Use the examples below to migrate your existing code:
Load Account using Saved Credentials
from qiskit import IBMQ IBMQ.save_account(token='MY_API_TOKEN') provider = IBMQ.load_account() # loads saved account from disk
from qiskit_ibm_provider import IBMProvider IBMProvider.save_account(token='MY_API_TOKEN') provider = IBMProvider() # loads saved account from disk
Load Account using Environment Variables
# export QE_TOKEN='MY_API_TOKEN' (bash command) from qiskit import IBMQ provider = IBMQ.load_account() # loads account from env variables
# export QISKIT_IBM_TOKEN='MY_API_TOKEN' (bash command) from qiskit_ibm_provider import IBMProvider provider = IBMProvider() # loads account from env variables
from qiskit import IBMQ IBMQ.stored_account() # get saved account from qiskitrc file
from qiskit_ibm_provider import IBMProvider IBMProvider.saved_accounts() # get saved accounts from qiskit-ibm.json file
from qiskit import IBMQ IBMQ.delete_account() # delete saved account from qiskitrc file
from qiskit_ibm_provider import IBMProvider IBMProvider.delete_account() # delete saved account from saved credentials
from qiskit import IBMQ provider = IBMQ.enable_account(token='MY_API_TOKEN') # enable account for current session
from qiskit_ibm_provider import IBMProvider provider = IBMProvider(token='MY_API_TOKEN') # enable account for current session
from qiskit import IBMQ provider = IBMQ.load_account() # load saved account IBMQ.active_account() # check active account
from qiskit_ibm_provider import IBMProvider provider = IBMProvider() # load saved account provider.active_account() # check active account
IBMBackendclass now implements the
qiskit.providers.BackendV2interface and provides flatter access to the configuration of a backend, for example:
# BackendV1: backend.configuration().n_qubits # BackendV2: backend.num_qubits
Only breaking change when compared to BackendV1 is backend.name is now an attribute instead of a method.
Refer to the
IBMBackendclass doc string for a list of all available attributes.
It is now optional to specify a hub/group/project upfront when connecting to the IBM Quantum account. The hub/group/project is selected in the following order.
hub/group/project if passed via
instanceparameter when calling
hub/group/project if passed via
instanceparameter when initializing
the default set previously via
a premium hub/group/project in your account
open access hub/group/project
You can now use
run()to submit a long list of circuits/schedules like you would for a single circuit/schedule. If the number of circuits/schedules exceeds the backend limit,
run()will automatically divide the list into multiple sub-jobs and return a single
IBMCompositeJobinstance. You can use this
IBMCompositeJobinstance the same way you used
IBMJobbefore. For example, you can use
status()to get job status,
result()to get job result, and
cancel()to cancel the job. You can also use the
jobs()methods to retrieve a single
IBMCompositeJob(by passing its job ID) or multiple jobs.
IBMCompositeJobalso has a
rerun_failed()method that will re-run any failed or cancelled sub jobs and a
report()method that returns a report on current sub-job statuses.
This feature replaces the
qiskit-ibmq-provider, which is the predecessor of
from qiskit.providers.ibmq.managed import IBMQJobManager job_manager = IBMQJobManager() job_set = job_manager.run(long_list_of_circuits, backend=backend) results = job_set.results()
job = backend.run(long_list_of_circuits) result = job.result()
The dynamic circuits scheduling class (
DynamicCircuitScheduleAnalysis) has been renamed to
run()has been updated so circuits with
idinstructions that are replaced with
delayinstructions do not mutate the original circuit.
Floats can now be used when setting the number of
run(). Now instead of having to type larger values like 100000 you can just do 1e5.
Scheduling has been updated to reflect dynamic circuit backends. Measurements no longer interrupt scheduling. ALAP scheduling has now been implemented in
ALAPScheduleAnalysisand should be the standard scheduling policy that is used.
A custom instruction durations class has been added for dynamic circuit backends
Currently it only patches the durations of measurement instructions.
This should be used temporarily while we port legacy backends to dynamic circuit backends.
run()has been updated to give a warning if the backend selected is paused.
my_reservations()have been added to
IBMProviderso they can all be directly accessible from the provider.
qiskit.providers.ibmq.IBMQBackend.retrieve_job() and qiskit.providers.ibmq.IBMQBackend.jobs() have been removed. The IBMBackendService methods
jobs()can be used instead.
run()method has been removed.
Scheduleshould now be used instead.
The db_filter parameter has been removed from
jobs()due to low adoption.
The deprecated qiskit.providers.ibmq.IBMQDeprecatedBackendService has now been removed. Backends can still be returned with
Job share level is no longer supported due to low adoption and the corresponding interface has been removed. This means you can no longer pass share_level when creating a job. The qiskit.providers.ibmq.job.IBMQJob.share_level method to get a job’s share level has also been removed.
backends()method has now been removed.
IBMProviderand the h/g/p is not specified, users can see the auto-selected h/g/p with
The default number of
shots(represents the number of repetitions of each circuit, for sampling) in
run(), has been increased from 1024 to 4000.
The reservations, job_limit, and remaining_jobs_count methods have been removed from
IBMBackend. The BackendJobLimit and BackendReservation classes have also been removed.
run()now submits the
A warning log message when loading an invalid backend has had the core message switched to a debug log message as certain backends were causing issues for all users upon loading the provider. Now a much less verbose message is emitted.