qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0__cp38-abi3-win32.whl

qiskit/providers/fake_provider/fake_backend.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2019, 2023.
+# (C) Copyright IBM 2019, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -17,28 +17,14 @@ Base class for dummy backends.
 """
 
 import warnings
-import collections
-import json
-import os
-import re
-
-from typing import List, Iterable
 
 from qiskit import circuit
-from qiskit.providers.models import BackendProperties, BackendConfiguration, PulseDefaults
-from qiskit.providers import BackendV2, BackendV1
+from qiskit.providers.models import BackendProperties
+from qiskit.providers import BackendV1
 from qiskit import pulse
 from qiskit.exceptions import QiskitError
 from qiskit.utils import optionals as _optionals
 from qiskit.providers import basic_provider
-from qiskit.transpiler import Target
-from qiskit.providers.backend_compat import convert_to_target
-
-from .utils.json_decoder import (
-    decode_backend_configuration,
-    decode_backend_properties,
-    decode_pulse_defaults,
-)
 
 
 class _Credentials:
@@ -50,397 +36,6 @@ class _Credentials:
         self.project = "project"
 
 
-class FakeBackendV2(BackendV2):
-    """A fake backend class for testing and noisy simulation using real backend
-    snapshots.
-
-    The class inherits :class:`~qiskit.providers.BackendV2` class. This version
-    differs from earlier :class:`~qiskit.providers.fake_provider.FakeBackend` (V1) class in a
-    few aspects. Firstly, configuration attribute no longer exsists. Instead,
-    attributes exposing equivalent required immutable properties of the backend
-    device are added. For example ``fake_backend.configuration().n_qubits`` is
-    accessible from ``fake_backend.num_qubits`` now. Secondly, this version
-    removes extra abstractions :class:`~qiskit.providers.fake_provider.FakeQasmBackend` and
-    :class:`~qiskit.providers.fake_provider.FakePulseBackend` that were present in V1.
-    """
-
-    # directory and file names for real backend snapshots.
-    dirname = None
-    conf_filename = None
-    props_filename = None
-    defs_filename = None
-    backend_name = None
-
-    def __init__(self):
-        """FakeBackendV2 initializer."""
-        self._conf_dict = self._get_conf_dict_from_json()
-        self._props_dict = None
-        self._defs_dict = None
-        super().__init__(
-            provider=None,
-            name=self._conf_dict.get("backend_name"),
-            description=self._conf_dict.get("description"),
-            online_date=self._conf_dict.get("online_date"),
-            backend_version=self._conf_dict.get("backend_version"),
-        )
-        self._target = None
-        self.sim = None
-
-        if "channels" in self._conf_dict:
-            self._parse_channels(self._conf_dict["channels"])
-
-    def _parse_channels(self, channels):
-        type_map = {
-            "acquire": pulse.AcquireChannel,
-            "drive": pulse.DriveChannel,
-            "measure": pulse.MeasureChannel,
-            "control": pulse.ControlChannel,
-        }
-        identifier_pattern = re.compile(r"\D+(?P<index>\d+)")
-
-        channels_map = {
-            "acquire": collections.defaultdict(list),
-            "drive": collections.defaultdict(list),
-            "measure": collections.defaultdict(list),
-            "control": collections.defaultdict(list),
-        }
-        for identifier, spec in channels.items():
-            channel_type = spec["type"]
-            out = re.match(identifier_pattern, identifier)
-            if out is None:
-                # Identifier is not a valid channel name format
-                continue
-            channel_index = int(out.groupdict()["index"])
-            qubit_index = tuple(spec["operates"]["qubits"])
-            chan_obj = type_map[channel_type](channel_index)
-            channels_map[channel_type][qubit_index].append(chan_obj)
-        setattr(self, "channels_map", channels_map)
-
-    def _setup_sim(self):
-        if _optionals.HAS_AER:
-            from qiskit_aer import AerSimulator
-
-            self.sim = AerSimulator()
-            if self.target and self._props_dict:
-                noise_model = self._get_noise_model_from_backend_v2()
-                self.sim.set_options(noise_model=noise_model)
-                # Update fake backend default too to avoid overwriting
-                # it when run() is called
-                self.set_options(noise_model=noise_model)
-
-        else:
-            self.sim = basic_provider.BasicSimulator()
-
-    def _get_conf_dict_from_json(self):
-        if not self.conf_filename:
-            return None
-        conf_dict = self._load_json(self.conf_filename)
-        decode_backend_configuration(conf_dict)
-        conf_dict["backend_name"] = self.backend_name
-        return conf_dict
-
-    def _set_props_dict_from_json(self):
-        if self.props_filename:
-            props_dict = self._load_json(self.props_filename)
-            decode_backend_properties(props_dict)
-            self._props_dict = props_dict
-
-    def _set_defs_dict_from_json(self):
-        if self.defs_filename:
-            defs_dict = self._load_json(self.defs_filename)
-            decode_pulse_defaults(defs_dict)
-            self._defs_dict = defs_dict
-
-    def _load_json(self, filename: str) -> dict:
-        with open(os.path.join(self.dirname, filename)) as f_json:
-            the_json = json.load(f_json)
-        return the_json
-
-    @property
-    def target(self) -> Target:
-        """A :class:`qiskit.transpiler.Target` object for the backend.
-
-        :rtype: Target
-        """
-        if self._target is None:
-            self._get_conf_dict_from_json()
-            if self._props_dict is None:
-                self._set_props_dict_from_json()
-            if self._defs_dict is None:
-                self._set_defs_dict_from_json()
-            conf = BackendConfiguration.from_dict(self._conf_dict)
-            props = None
-            if self._props_dict is not None:
-                props = BackendProperties.from_dict(self._props_dict)
-            defaults = None
-            if self._defs_dict is not None:
-                defaults = PulseDefaults.from_dict(self._defs_dict)
-
-            self._target = convert_to_target(
-                configuration=conf, properties=props, defaults=defaults
-            )
-        return self._target
-
-    @property
-    def max_circuits(self):
-        return None
-
-    @classmethod
-    def _default_options(cls):
-        """Return the default options
-
-        This method will return a :class:`qiskit.providers.Options`
-        subclass object that will be used for the default options. These
-        should be the default parameters to use for the options of the
-        backend.
-
-        Returns:
-            qiskit.providers.Options: A options object with
-                default values set
-        """
-        if _optionals.HAS_AER:
-            from qiskit_aer import AerSimulator
-
-            return AerSimulator._default_options()
-        else:
-            return basic_provider.BasicSimulator._default_options()
-
-    @property
-    def dtm(self) -> float:
-        """Return the system time resolution of output signals
-
-        Returns:
-            The output signal timestep in seconds.
-        """
-        dtm = self._conf_dict.get("dtm")
-        if dtm is not None:
-            # converting `dtm` in nanoseconds in configuration file to seconds
-            return dtm * 1e-9
-        else:
-            return None
-
-    @property
-    def meas_map(self) -> List[List[int]]:
-        """Return the grouping of measurements which are multiplexed
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            The grouping of measurements which are multiplexed
-        """
-        return self._conf_dict.get("meas_map")
-
-    def drive_channel(self, qubit: int):
-        """Return the drive channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            DriveChannel: The Qubit drive channel
-        """
-        drive_channels_map = getattr(self, "channels_map", {}).get("drive", {})
-        qubits = (qubit,)
-        if qubits in drive_channels_map:
-            return drive_channels_map[qubits][0]
-        return None
-
-    def measure_channel(self, qubit: int):
-        """Return the measure stimulus channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            MeasureChannel: The Qubit measurement stimulus line
-        """
-        measure_channels_map = getattr(self, "channels_map", {}).get("measure", {})
-        qubits = (qubit,)
-        if qubits in measure_channels_map:
-            return measure_channels_map[qubits][0]
-        return None
-
-    def acquire_channel(self, qubit: int):
-        """Return the acquisition channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            AcquireChannel: The Qubit measurement acquisition line.
-        """
-        acquire_channels_map = getattr(self, "channels_map", {}).get("acquire", {})
-        qubits = (qubit,)
-        if qubits in acquire_channels_map:
-            return acquire_channels_map[qubits][0]
-        return None
-
-    def control_channel(self, qubits: Iterable[int]):
-        """Return the secondary drive channel for the given qubit
-
-        This is typically utilized for controlling multiqubit interactions.
-        This channel is derived from other channels.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Args:
-            qubits: Tuple or list of qubits of the form
-                ``(control_qubit, target_qubit)``.
-
-        Returns:
-            List[ControlChannel]: The multi qubit control line.
-        """
-        control_channels_map = getattr(self, "channels_map", {}).get("control", {})
-        qubits = tuple(qubits)
-        if qubits in control_channels_map:
-            return control_channels_map[qubits]
-        return []
-
-    def run(self, run_input, **options):
-        """Run on the fake backend using a simulator.
-
-        This method runs circuit jobs (an individual or a list of QuantumCircuit
-        ) and pulse jobs (an individual or a list of Schedule or ScheduleBlock)
-        using a :class:`.BasicSimulator` or Aer simulator and returns a
-        :class:`~qiskit.providers.Job` object.
-
-        If qiskit-aer is installed, jobs will be run using AerSimulator with
-        noise model of the fake backend. Otherwise, jobs will be run using
-        :class:`.BasicSimulator` without noise.
-
-        Currently noisy simulation of a pulse job is not supported yet in
-        FakeBackendV2.
-
-        Args:
-            run_input (QuantumCircuit or Schedule or ScheduleBlock or list): An
-                individual or a list of
-                :class:`~qiskit.circuit.QuantumCircuit`,
-                :class:`~qiskit.pulse.ScheduleBlock`, or
-                :class:`~qiskit.pulse.Schedule` objects to run on the backend.
-            options: Any kwarg options to pass to the backend for running the
-                config. If a key is also present in the options
-                attribute/object then the expectation is that the value
-                specified will be used instead of what's set in the options
-                object.
-
-        Returns:
-            Job: The job object for the run
-
-        Raises:
-            QiskitError: If a pulse job is supplied and qiskit-aer is not installed.
-        """
-        circuits = run_input
-        pulse_job = None
-        if isinstance(circuits, (pulse.Schedule, pulse.ScheduleBlock)):
-            pulse_job = True
-        elif isinstance(circuits, circuit.QuantumCircuit):
-            pulse_job = False
-        elif isinstance(circuits, list):
-            if circuits:
-                if all(isinstance(x, (pulse.Schedule, pulse.ScheduleBlock)) for x in circuits):
-                    pulse_job = True
-                elif all(isinstance(x, circuit.QuantumCircuit) for x in circuits):
-                    pulse_job = False
-        if pulse_job is None:  # submitted job is invalid
-            raise QiskitError(
-                "Invalid input object %s, must be either a "
-                "QuantumCircuit, Schedule, or a list of either" % circuits
-            )
-        if pulse_job:  # pulse job
-            raise QiskitError("Pulse simulation is currently not supported for fake backends.")
-        # circuit job
-        if not _optionals.HAS_AER:
-            warnings.warn("Aer not found using BasicProvider and no noise", RuntimeWarning)
-        if self.sim is None:
-            self._setup_sim()
-        self.sim._options = self._options
-        job = self.sim.run(circuits, **options)
-        return job
-
-    def _get_noise_model_from_backend_v2(
-        self,
-        gate_error=True,
-        readout_error=True,
-        thermal_relaxation=True,
-        temperature=0,
-        gate_lengths=None,
-        gate_length_units="ns",
-    ):
-        """Build noise model from BackendV2.
-
-        This is a temporary fix until qiskit-aer supports building noise model
-        from a BackendV2 object.
-        """
-
-        from qiskit.circuit import Delay
-        from qiskit.providers.exceptions import BackendPropertyError
-        from qiskit_aer.noise import NoiseModel
-        from qiskit_aer.noise.device.models import (
-            _excited_population,
-            basic_device_gate_errors,
-            basic_device_readout_errors,
-        )
-        from qiskit_aer.noise.passes import RelaxationNoisePass
-
-        if self._props_dict is None:
-            self._set_props_dict_from_json()
-
-        properties = BackendProperties.from_dict(self._props_dict)
-        basis_gates = self.operation_names
-        num_qubits = self.num_qubits
-        dt = self.dt
-
-        noise_model = NoiseModel(basis_gates=basis_gates)
-
-        # Add single-qubit readout errors
-        if readout_error:
-            for qubits, error in basic_device_readout_errors(properties):
-                noise_model.add_readout_error(error, qubits)
-
-        # Add gate errors
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                module="qiskit_aer.noise.device.models",
-            )
-            gate_errors = basic_device_gate_errors(
-                properties,
-                gate_error=gate_error,
-                thermal_relaxation=thermal_relaxation,
-                gate_lengths=gate_lengths,
-                gate_length_units=gate_length_units,
-                temperature=temperature,
-            )
-        for name, qubits, error in gate_errors:
-            noise_model.add_quantum_error(error, name, qubits)
-
-        if thermal_relaxation:
-            # Add delay errors via RelaxationNiose pass
-            try:
-                excited_state_populations = [
-                    _excited_population(freq=properties.frequency(q), temperature=temperature)
-                    for q in range(num_qubits)
-                ]
-            except BackendPropertyError:
-                excited_state_populations = None
-            try:
-                delay_pass = RelaxationNoisePass(
-                    t1s=[properties.t1(q) for q in range(num_qubits)],
-                    t2s=[properties.t2(q) for q in range(num_qubits)],
-                    dt=dt,
-                    op_types=Delay,
-                    excited_state_populations=excited_state_populations,
-                )
-                noise_model._custom_noise_passes.append(delay_pass)
-            except BackendPropertyError:
-                # Device does not have the required T1 or T2 information
-                # in its properties
-                pass
-
-        return noise_model
-
-
 class FakeBackend(BackendV1):
     """This is a dummy backend just for testing purposes."""
 

qiskit/providers/fake_provider/generic_backend_v2.py

@@ -48,22 +48,22 @@ from qiskit.utils import optionals as _optionals
 #   if the defaults are ranges.
 # - (duration, error), if the defaults are fixed values.
 _NOISE_DEFAULTS = {
-    "cx": (8e-8, 9e-7, 1e-5, 5e-3),
-    "ecr": (8e-8, 9e-7, 1e-5, 5e-3),
-    "cz": (8e-8, 9e-7, 1e-5, 5e-3),
-    "id": (3e-8, 6e-8, 9e-5, 1e-4),
+    "cx": (7.992e-08, 8.99988e-07, 1e-5, 5e-3),
+    "ecr": (7.992e-08, 8.99988e-07, 1e-5, 5e-3),
+    "cz": (7.992e-08, 8.99988e-07, 1e-5, 5e-3),
+    "id": (2.997e-08, 5.994e-08, 9e-5, 1e-4),
     "rz": (0.0, 0.0),
-    "sx": (3e-8, 6e-8, 9e-5, 1e-4),
-    "x": (3e-8, 6e-8, 9e-5, 1e-4),
-    "measure": (7e-7, 1.5e-6, 1e-5, 5e-3),
+    "sx": (2.997e-08, 5.994e-08, 9e-5, 1e-4),
+    "x": (2.997e-08, 5.994e-08, 9e-5, 1e-4),
+    "measure": (6.99966e-07, 1.500054e-06, 1e-5, 5e-3),
     "delay": (None, None),
     "reset": (None, None),
 }
 
 # Fallback values for gates with unknown noise default ranges.
 _NOISE_DEFAULTS_FALLBACK = {
-    "1-q": (3e-8, 6e-8, 9e-5, 1e-4),
-    "multi-q": (8e-8, 9e-7, 1e-5, 5e-3),
+    "1-q": (2.997e-08, 5.994e-08, 9e-5, 1e-4),
+    "multi-q": (7.992e-08, 8.99988e-07, 5e-3),
 }
 
 # Ranges to sample qubit properties from.
@@ -424,6 +424,12 @@ class GenericBackendV2(BackendV2):
                 )
             else:
                 calibration_entry = None
+            if duration is not None and len(noise_params) > 2:
+                # Ensure exact conversion of duration from seconds to dt
+                dt = _QUBIT_PROPERTIES["dt"]
+                rounded_duration = round(duration / dt) * dt
+                # Clamp rounded duration to be between min and max values
+                duration = max(noise_params[0], min(rounded_duration, noise_params[1]))
             props.update({qargs: InstructionProperties(duration, error, calibration_entry)})
         self._target.add_instruction(instruction, props)
 
@@ -520,12 +526,18 @@ class GenericBackendV2(BackendV2):
 
     @classmethod
     def _default_options(cls) -> Options:
-        if _optionals.HAS_AER:
-            from qiskit_aer import AerSimulator
+        with warnings.catch_warnings():  # TODO remove catch once aer release without Provider ABC
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=".+abstract Provider and ProviderV1.+",
+            )
+            if _optionals.HAS_AER:
+                from qiskit_aer import AerSimulator
 
-            return AerSimulator._default_options()
-        else:
-            return BasicSimulator._default_options()
+                return AerSimulator._default_options()
+            else:
+                return BasicSimulator._default_options()
 
     def drive_channel(self, qubit: int):
         drive_channels_map = getattr(self, "channels_map", {}).get("drive", {})

qiskit/providers/models/__init__.py

@@ -19,8 +19,8 @@ Backend Objects (:mod:`qiskit.providers.models`)
 
 Qiskit schema-conformant objects used by the backends and providers.
 
-Backend Objects
-===============
+Classes
+=======
 
 .. autosummary::
    :toctree: ../stubs/

qiskit/providers/provider.py

@@ -15,6 +15,7 @@
 from abc import ABC, abstractmethod
 
 from qiskit.providers.exceptions import QiskitBackendNotFoundError
+from qiskit.utils import deprecate_func
 
 
 class Provider:
@@ -28,12 +29,27 @@ class Provider:
 
     version = 0
 
+    @deprecate_func(
+        since=1.1,
+        additional_msg="The abstract Provider and ProviderV1 classes are deprecated and will be "
+        "removed in 2.0. You can just remove it as the parent class and a `get_backend` "
+        "method that returns the backends from `self.backend`.",
+    )
+    def __init__(self):
+        pass
+
 
 class ProviderV1(Provider, ABC):
     """Base class for a Backend Provider."""
 
     version = 1
 
+    @deprecate_func(
+        since=1.1,
+        additional_msg="The abstract Provider and ProviderV1 classes are deprecated and will  be "
+        "removed in 2.0. You can just remove it as the parent class and a `get_backend` "
+        "method that returns the backends from `self.backend`.",
+    )
     def get_backend(self, name=None, **kwargs):
         """Return a single backend matching the specified filtering.
 

qiskit/pulse/builder.py

@@ -531,7 +531,10 @@ class _PulseBuilder:
             self._context_stack.append(root_block)
 
         # Set default alignment context
-        alignment = _PulseBuilder.__alignment_kinds__.get(default_alignment, default_alignment)
+        if isinstance(default_alignment, AlignmentKind):  # AlignmentKind instance
+            alignment = default_alignment
+        else:  # str identifier
+            alignment = _PulseBuilder.__alignment_kinds__.get(default_alignment, default_alignment)
         if not isinstance(alignment, AlignmentKind):
             raise exceptions.PulseError(
                 f"Given `default_alignment` {repr(default_alignment)} is "

qiskit/pulse/parameter_manager.py

@@ -52,8 +52,9 @@ and thus this parameter framework gives greater scalability to the pulse module.
 """
 from __future__ import annotations
 from copy import copy
-from typing import Any
+from typing import Any, Mapping, Sequence
 
+from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parameterexpression import ParameterExpression, ParameterValueType
 from qiskit.pulse import instructions, channels
@@ -61,7 +62,11 @@ from qiskit.pulse.exceptions import PulseError
 from qiskit.pulse.library import SymbolicPulse, Waveform
 from qiskit.pulse.schedule import Schedule, ScheduleBlock
 from qiskit.pulse.transforms.alignments import AlignmentKind
-from qiskit.pulse.utils import format_parameter_value
+from qiskit.pulse.utils import (
+    format_parameter_value,
+    _validate_parameter_vector,
+    _validate_parameter_value,
+)
 
 
 class NodeVisitor:
@@ -360,7 +365,10 @@ class ParameterManager:
     def assign_parameters(
         self,
         pulse_program: Any,
-        value_dict: dict[ParameterExpression, ParameterValueType],
+        value_dict: dict[
+            ParameterExpression | ParameterVector | str,
+            ParameterValueType | Sequence[ParameterValueType],
+        ],
     ) -> Any:
         """Modify and return program data with parameters assigned according to the input.
 
@@ -372,7 +380,10 @@ class ParameterManager:
         Returns:
             Updated program data.
         """
-        valid_map = {k: value_dict[k] for k in value_dict.keys() & self._parameters}
+        unrolled_value_dict = self._unroll_param_dict(value_dict)
+        valid_map = {
+            k: unrolled_value_dict[k] for k in unrolled_value_dict.keys() & self._parameters
+        }
         if valid_map:
             visitor = ParameterSetter(param_map=valid_map)
             return visitor.visit(pulse_program)
@@ -387,3 +398,48 @@ class ParameterManager:
         visitor = ParameterGetter()
         visitor.visit(new_node)
         self._parameters |= visitor.parameters
+
+    def _unroll_param_dict(
+        self,
+        parameter_binds: Mapping[
+            Parameter | ParameterVector | str, ParameterValueType | Sequence[ParameterValueType]
+        ],
+    ) -> Mapping[Parameter, ParameterValueType]:
+        """
+        Unroll parameter dictionary to a map from parameter to value.
+
+        Args:
+            parameter_binds: A dictionary from parameter to value or a list of values.
+
+        Returns:
+            A dictionary from parameter to value.
+        """
+        out = {}
+        param_name_dict = {param.name: [] for param in self.parameters}
+        for param in self.parameters:
+            param_name_dict[param.name].append(param)
+        param_vec_dict = {
+            param.vector.name: param.vector
+            for param in self.parameters
+            if isinstance(param, ParameterVectorElement)
+        }
+        for name in param_vec_dict.keys():
+            if name in param_name_dict:
+                param_name_dict[name].append(param_vec_dict[name])
+            else:
+                param_name_dict[name] = [param_vec_dict[name]]
+
+        for parameter, value in parameter_binds.items():
+            if isinstance(parameter, ParameterVector):
+                _validate_parameter_vector(parameter, value)
+                out.update(zip(parameter, value))
+            elif isinstance(parameter, str):
+                for param in param_name_dict[parameter]:
+                    is_vec = _validate_parameter_value(param, value)
+                    if is_vec:
+                        out.update(zip(param, value))
+                    else:
+                        out[param] = value
+            else:
+                out[parameter] = value
+        return out