Added support for using session. The syntax here is slightly different than that in
qiskit-ibm-runtime, but the functionality is similar. Here is an example using session as a context manager:
with backend.open_session() as session: job = backend.run(ReferenceCircuits.bell())
And here is an example of session not as a context manager:
backend = IBMProvider().get_backend("ibmq_qasm_simulator") backend.open_session() job = backend.run(circ) backend.cancel_session()
coupling_map.graph.subgraph(nodes)to apply DD on a disjoint coupling map. See discussion in https://github.com/Qiskit/qiskit-terra/pull/9710 (opens in a new tab)
IBMProvider.get_backend()returns the backend with its default options. At the end of this example,
backend1 = provider.get_backend("xxx") backend1.options.shots = 100 backend2 = provider.get_backend("xxx")
backend2.options.shotshas the default value (4000).
backend1.options.shotsalso has the default value, because backend1 and backend2 are the same instance.
- Added a new property,
usage_estimation()that returns the estimated running time,
quantum_seconds. Quantum time represents the time that the QPU complex is occupied exclusively by the job.
Job error messages now include the error code. Error codes can be found in https://quantum-computing.ibm.com/lab/docs/iql/manage/errors (opens in a new tab).
For each qubit, add the ability to select one of two different sets of spacings between dynamical decoupling pulses, based on the input coupling map.
Fixes a bug in the function
jobs(). Refer to #586 (opens in a new tab) for more details.
A transpilation error will no longer occur when attempting to transpile a circuit containing a conditional
IGatewith Qiskit 0.44.
2pi wrapping cannot be applied on a parameterized global phase. Use the DAGCircuit
global_phasesetter to wrap the phase for floats only.
Staggered inter-pulse spacings allow the user to disable certain interactions between neighboring qubits by Refer to #539 <https://github.com/Qiskit/qiskit-ibm-provider/issues/539 (opens in a new tab)> for more details
Raise an exception if the number of circuits passed to IBMBackend.run() exceeds IBMBackend._max_circuits.
Support has been added to select the Qiskit runtime image to invoke the program with for testing purposes with the
- Fixes an issue where submitting a large job failed due to a write operation timeout.
When retrieving a job with
paramswill no longer be returned from the API. They will instead be loaded lazily when they are actually needed.
In ‘time_per_step’, if ‘time_per_step_local’ is None, print None, rather than converting with ‘utc_to_local’, because this resulted in a bug.
- Added error message if the circuit contains more qubits than supported on the backend. Previously, this validation was done on the server side.
Fixed infinite recursion when attempting to deepcopy an IBMBackend.
Fixed an issue where circuit metadata was not being serialized correctly resulting in a type error.
A bug that the backend target generation fails with an error in some edge cases is fixed. See Qiskit/qiskit-ibm-provider/#650 for more details.
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 (opens in a new tab) 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 (opens in a new tab)>
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.
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.
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
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 (opens in a new tab). 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
# 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.
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.
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.
qiskit.providers.ibmq.IBMQBackend.retrieve_job() and qiskit.providers.ibmq.IBMQBackend.jobs() have been removed. The IBMBackendService methods
jobs()can 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.
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.