qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/providers/backend_compat.py

@@ -0,0 +1,347 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Backend abstract interface for providers."""
+
+from __future__ import annotations
+
+from typing import List, Iterable, Any, Dict, Optional
+
+from qiskit.exceptions import QiskitError
+
+from qiskit.providers.backend import BackendV1, BackendV2
+from qiskit.providers.backend import QubitProperties
+from qiskit.utils.units import apply_prefix
+from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
+from qiskit.circuit.measure import Measure
+from qiskit.providers.models.backendconfiguration import BackendConfiguration
+from qiskit.providers.models.backendproperties import BackendProperties
+from qiskit.providers.models.pulsedefaults import PulseDefaults
+from qiskit.providers.options import Options
+from qiskit.providers.exceptions import BackendPropertyError
+
+
+def convert_to_target(
+    configuration: BackendConfiguration,
+    properties: BackendProperties = None,
+    defaults: PulseDefaults = None,
+    custom_name_mapping: Optional[Dict[str, Any]] = None,
+    add_delay: bool = False,
+    filter_faulty: bool = False,
+):
+    """Uses configuration, properties and pulse defaults
+    to construct and return Target class.
+
+    In order to convert with a ``defaults.instruction_schedule_map``,
+    which has a custom calibration for an operation,
+    the operation name must be in ``configuration.basis_gates`` and
+    ``custom_name_mapping`` must be supplied for the operation.
+    Otherwise, the operation will be dropped in the resulting ``Target`` object.
+
+    That suggests it is recommended to add custom calibrations **after** creating a target
+    with this function instead of adding them to ``defaults`` in advance. For example::
+
+        target.add_instruction(custom_gate, {(0, 1): InstructionProperties(calibration=custom_sched)})
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.transpiler.target import (
+        Target,
+        InstructionProperties,
+    )
+
+    # Standard gates library mapping, multicontrolled gates not included since they're
+    # variable width
+    name_mapping = get_standard_gate_name_mapping()
+    target = None
+    if custom_name_mapping is not None:
+        name_mapping.update(custom_name_mapping)
+    faulty_qubits = set()
+    # Parse from properties if it exsits
+    if properties is not None:
+        if filter_faulty:
+            faulty_qubits = set(properties.faulty_qubits())
+        qubit_properties = qubit_props_list_from_props(properties=properties)
+        target = Target(
+            num_qubits=configuration.n_qubits,
+            qubit_properties=qubit_properties,
+            concurrent_measurements=getattr(configuration, "meas_map", None),
+        )
+        # Parse instructions
+        gates: Dict[str, Any] = {}
+        for gate in properties.gates:
+            name = gate.gate
+            if name in name_mapping:
+                if name not in gates:
+                    gates[name] = {}
+            else:
+                raise QiskitError(
+                    f"Operation name {name} does not have a known mapping. Use "
+                    "custom_name_mapping to map this name to an Operation object"
+                )
+
+            qubits = tuple(gate.qubits)
+            if filter_faulty:
+                if any(not properties.is_qubit_operational(qubit) for qubit in qubits):
+                    continue
+                if not properties.is_gate_operational(name, gate.qubits):
+                    continue
+
+            gate_props = {}
+            for param in gate.parameters:
+                if param.name == "gate_error":
+                    gate_props["error"] = param.value
+                if param.name == "gate_length":
+                    gate_props["duration"] = apply_prefix(param.value, param.unit)
+            gates[name][qubits] = InstructionProperties(**gate_props)
+        for gate, props in gates.items():
+            inst = name_mapping[gate]
+            target.add_instruction(inst, props)
+        # Create measurement instructions:
+        measure_props = {}
+        for qubit, _ in enumerate(properties.qubits):
+            if filter_faulty:
+                if not properties.is_qubit_operational(qubit):
+                    continue
+            try:
+                duration = properties.readout_length(qubit)
+            except BackendPropertyError:
+                duration = None
+            try:
+                error = properties.readout_error(qubit)
+            except BackendPropertyError:
+                error = None
+            measure_props[(qubit,)] = InstructionProperties(
+                duration=duration,
+                error=error,
+            )
+        target.add_instruction(Measure(), measure_props)
+    # Parse from configuration because properties doesn't exist
+    else:
+        target = Target(
+            num_qubits=configuration.n_qubits,
+            concurrent_measurements=getattr(configuration, "meas_map", None),
+        )
+        for gate in configuration.gates:
+            name = gate.name
+            gate_props = (
+                {tuple(x): None for x in gate.coupling_map}  # type: ignore[misc]
+                if hasattr(gate, "coupling_map")
+                else {None: None}
+            )
+            if name in name_mapping:
+                target.add_instruction(name_mapping[name], gate_props)
+            else:
+                raise QiskitError(
+                    f"Operation name {name} does not have a known mapping. "
+                    "Use custom_name_mapping to map this name to an Operation object"
+                )
+        target.add_instruction(Measure())
+    # parse global configuration properties
+    if hasattr(configuration, "dt"):
+        target.dt = configuration.dt
+    if hasattr(configuration, "timing_constraints"):
+        target.granularity = configuration.timing_constraints.get("granularity")
+        target.min_length = configuration.timing_constraints.get("min_length")
+        target.pulse_alignment = configuration.timing_constraints.get("pulse_alignment")
+        target.acquire_alignment = configuration.timing_constraints.get("acquire_alignment")
+    # If a pulse defaults exists use that as the source of truth
+    if defaults is not None:
+        inst_map = defaults.instruction_schedule_map
+        for inst in inst_map.instructions:
+            for qarg in inst_map.qubits_with_instruction(inst):
+                try:
+                    qargs = tuple(qarg)
+                except TypeError:
+                    qargs = (qarg,)
+                # Do NOT call .get method. This parses Qpbj immediately.
+                # This operation is computationally expensive and should be bypassed.
+                calibration_entry = inst_map._get_calibration_entry(inst, qargs)
+                if inst in target:
+                    if inst == "measure":
+                        for qubit in qargs:
+                            if filter_faulty and qubit in faulty_qubits:
+                                continue
+                            target[inst][(qubit,)].calibration = calibration_entry
+                    elif qargs in target[inst]:
+                        if filter_faulty and any(qubit in faulty_qubits for qubit in qargs):
+                            continue
+                        target[inst][qargs].calibration = calibration_entry
+    combined_global_ops = set()
+    if configuration.basis_gates:
+        combined_global_ops.update(configuration.basis_gates)
+    for op in combined_global_ops:
+        if op not in target:
+            if op in name_mapping:
+                target.add_instruction(name_mapping[op], name=op)
+            else:
+                raise QiskitError(
+                    f"Operation name '{op}' does not have a known mapping. Use "
+                    "custom_name_mapping to map this name to an Operation object"
+                )
+    if add_delay and "delay" not in target:
+        target.add_instruction(
+            name_mapping["delay"],
+            {(bit,): None for bit in range(target.num_qubits) if bit not in faulty_qubits},
+        )
+    return target
+
+
+def qubit_props_list_from_props(
+    properties: BackendProperties,
+) -> List[QubitProperties]:
+    """Uses BackendProperties to construct
+    and return a list of QubitProperties.
+    """
+    qubit_props: List[QubitProperties] = []
+    for qubit, _ in enumerate(properties.qubits):
+        try:
+            t_1 = properties.t1(qubit)
+        except BackendPropertyError:
+            t_1 = None
+        try:
+            t_2 = properties.t2(qubit)
+        except BackendPropertyError:
+            t_2 = None
+        try:
+            frequency = properties.frequency(qubit)
+        except BackendPropertyError:
+            frequency = None
+        qubit_props.append(
+            QubitProperties(  # type: ignore[no-untyped-call]
+                t1=t_1,
+                t2=t_2,
+                frequency=frequency,
+            )
+        )
+    return qubit_props
+
+
+class BackendV2Converter(BackendV2):
+    """A converter class that takes a :class:`~.BackendV1` instance and wraps it in a
+    :class:`~.BackendV2` interface.
+
+    This class implements the :class:`~.BackendV2` interface and is used to enable
+    common access patterns between :class:`~.BackendV1` and :class:`~.BackendV2`. This
+    class should only be used if you need a :class:`~.BackendV2` and still need
+    compatibility with :class:`~.BackendV1`.
+
+    When using custom calibrations (or other custom workflows) it is **not** recommended
+    to mutate the ``BackendV1`` object before applying this converter. For example, in order to
+    convert a ``BackendV1`` object with a customized ``defaults().instruction_schedule_map``,
+    which has a custom calibration for an operation, the operation name must be in
+    ``configuration().basis_gates`` and ``name_mapping`` must be supplied for the operation.
+    Otherwise, the operation will be dropped in the resulting ``BackendV2`` object.
+
+    Instead it is typically better to add custom calibrations **after** applying this converter
+    instead of updating ``BackendV1.defaults()`` in advance. For example::
+
+        backend_v2 = BackendV2Converter(backend_v1)
+        backend_v2.target.add_instruction(
+            custom_gate, {(0, 1): InstructionProperties(calibration=custom_sched)}
+        )
+    """
+
+    def __init__(
+        self,
+        backend: BackendV1,
+        name_mapping: Optional[Dict[str, Any]] = None,
+        add_delay: bool = False,
+        filter_faulty: bool = False,
+    ):
+        """Initialize a BackendV2 converter instance based on a BackendV1 instance.
+
+        Args:
+            backend: The input :class:`~.BackendV1` based backend to wrap in a
+                :class:`~.BackendV2` interface
+            name_mapping: An optional dictionary that maps custom gate/operation names in
+                ``backend`` to an :class:`~.Operation` object representing that
+                gate/operation. By default most standard gates names are mapped to the
+                standard gate object from :mod:`qiskit.circuit.library` this only needs
+                to be specified if the input ``backend`` defines gates in names outside
+                that set.
+            add_delay: If set to true a :class:`~qiskit.circuit.Delay` operation
+                will be added to the target as a supported operation for all
+                qubits
+            filter_faulty: If the :class:`~.BackendProperties` object (if present) for
+                ``backend`` has any qubits or gates flagged as non-operational filter
+                those from the output target.
+        """
+        self._backend = backend
+        self._config = self._backend.configuration()
+        super().__init__(
+            provider=backend.provider,
+            name=backend.name(),
+            description=self._config.description,
+            online_date=getattr(self._config, "online_date", None),
+            backend_version=self._config.backend_version,
+        )
+        self._options = self._backend._options
+        self._properties = None
+        if hasattr(self._backend, "properties"):
+            self._properties = self._backend.properties()
+        self._defaults = None
+        self._target = None
+        self._name_mapping = name_mapping
+        self._add_delay = add_delay
+        self._filter_faulty = filter_faulty
+
+    @property
+    def target(self):
+        """A :class:`qiskit.transpiler.Target` object for the backend.
+
+        :rtype: Target
+        """
+        if self._target is None:
+            if self._defaults is None and hasattr(self._backend, "defaults"):
+                self._defaults = self._backend.defaults()
+            if self._properties is None and hasattr(self._backend, "properties"):
+                self._properties = self._backend.properties()
+            self._target = convert_to_target(
+                self._config,
+                self._properties,
+                self._defaults,
+                custom_name_mapping=self._name_mapping,
+                add_delay=self._add_delay,
+                filter_faulty=self._filter_faulty,
+            )
+        return self._target
+
+    @property
+    def max_circuits(self):
+        return self._config.max_experiments
+
+    @classmethod
+    def _default_options(cls):
+        return Options()
+
+    @property
+    def dtm(self) -> float:
+        return self._config.dtm
+
+    @property
+    def meas_map(self) -> List[List[int]]:
+        return self._config.meas_map
+
+    def drive_channel(self, qubit: int):
+        return self._config.drive(qubit)
+
+    def measure_channel(self, qubit: int):
+        return self._config.measure(qubit)
+
+    def acquire_channel(self, qubit: int):
+        return self._config.acquire(qubit)
+
+    def control_channel(self, qubits: Iterable[int]):
+        return self._config.control(qubits)
+
+    def run(self, run_input, **options):
+        return self._backend.run(run_input, **options)

qiskit/providers/basicaer/__init__.py

@@ -0,0 +1,73 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+====================================================================
+BasicAer: Python-based Simulators (:mod:`qiskit.providers.basicaer`)
+====================================================================
+
+.. currentmodule:: qiskit.providers.basicaer
+
+A module of Python-based quantum simulators.  Simulators are accessed
+via the `BasicAer` provider, e.g.:
+
+.. code-block::
+
+   from qiskit import BasicAer
+
+   backend = BasicAer.get_backend('qasm_simulator')
+
+
+Simulators
+==========
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   QasmSimulatorPy
+   StatevectorSimulatorPy
+   UnitarySimulatorPy
+
+Provider
+========
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   BasicAerProvider
+
+Job Class
+=========
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   BasicAerJob
+
+Exceptions
+==========
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   BasicAerError
+"""
+
+from .basicaerprovider import BasicAerProvider
+from .basicaerjob import BasicAerJob
+from .qasm_simulator import QasmSimulatorPy
+from .statevector_simulator import StatevectorSimulatorPy
+from .unitary_simulator import UnitarySimulatorPy
+from .exceptions import BasicAerError
+
+# Global instance to be used as the entry point for convenience.
+BasicAer = BasicAerProvider()

qiskit/providers/basicaer/basicaerjob.py

@@ -0,0 +1,65 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""This module implements the job class used by Basic Aer Provider."""
+
+import warnings
+
+from qiskit.providers import JobStatus
+from qiskit.providers.job import JobV1
+
+
+class BasicAerJob(JobV1):
+    """BasicAerJob class."""
+
+    _async = False
+
+    def __init__(self, backend, job_id, result):
+        super().__init__(backend, job_id)
+        self._result = result
+
+    def submit(self):
+        """Submit the job to the backend for execution.
+
+        Raises:
+            JobError: if trying to re-submit the job.
+        """
+        return
+
+    def result(self, timeout=None):
+        """Get job result .
+
+        Returns:
+            qiskit.result.Result: Result object
+        """
+        if timeout is not None:
+            warnings.warn(
+                "The timeout kwarg doesn't have any meaning with "
+                "BasicAer because execution is synchronous and the "
+                "result already exists when run() returns.",
+                UserWarning,
+            )
+
+        return self._result
+
+    def status(self):
+        """Gets the status of the job by querying the Python's future
+
+        Returns:
+            qiskit.providers.JobStatus: The current JobStatus
+        """
+        return JobStatus.DONE
+
+    def backend(self):
+        """Return the instance of the backend used for this job."""
+        return self._backend

qiskit/providers/basicaer/basicaerprovider.py

@@ -0,0 +1,127 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""Provider for Basic Aer simulator backends."""
+
+from collections import OrderedDict
+import logging
+
+from qiskit.exceptions import QiskitError
+from qiskit.providers.provider import ProviderV1
+from qiskit.providers.exceptions import QiskitBackendNotFoundError
+from qiskit.providers.providerutils import resolve_backend_name, filter_backends
+
+from .qasm_simulator import QasmSimulatorPy
+from .statevector_simulator import StatevectorSimulatorPy
+from .unitary_simulator import UnitarySimulatorPy
+
+
+logger = logging.getLogger(__name__)
+
+SIMULATORS = [QasmSimulatorPy, StatevectorSimulatorPy, UnitarySimulatorPy]
+
+
+class BasicAerProvider(ProviderV1):
+    """Provider for Basic Aer backends."""
+
+    def __init__(self):
+        super().__init__()
+
+        # Populate the list of Basic Aer backends.
+        self._backends = self._verify_backends()
+
+    def get_backend(self, name=None, **kwargs):
+        backends = self._backends.values()
+
+        # Special handling of the `name` parameter, to support alias resolution
+        # and deprecated names.
+        if name:
+            try:
+                resolved_name = resolve_backend_name(
+                    name, backends, self._deprecated_backend_names(), {}
+                )
+                name = resolved_name
+            except LookupError as ex:
+                raise QiskitBackendNotFoundError(
+                    f"The '{name}' backend is not installed in your system."
+                ) from ex
+
+        return super().get_backend(name=name, **kwargs)
+
+    def backends(self, name=None, filters=None, **kwargs):
+        backends = self._backends.values()
+
+        # Special handling of the `name` parameter, to support alias resolution
+        # and deprecated names.
+        if name:
+            try:
+                resolved_name = resolve_backend_name(
+                    name, backends, self._deprecated_backend_names(), {}
+                )
+                backends = [backend for backend in backends if backend.name() == resolved_name]
+            except LookupError:
+                return []
+
+        return filter_backends(backends, filters=filters, **kwargs)
+
+    @staticmethod
+    def _deprecated_backend_names():
+        """Returns deprecated backend names."""
+        return {
+            "qasm_simulator_py": "qasm_simulator",
+            "statevector_simulator_py": "statevector_simulator",
+            "unitary_simulator_py": "unitary_simulator",
+            "local_qasm_simulator_py": "qasm_simulator",
+            "local_statevector_simulator_py": "statevector_simulator",
+            "local_unitary_simulator_py": "unitary_simulator",
+            "local_unitary_simulator": "unitary_simulator",
+        }
+
+    def _verify_backends(self):
+        """
+        Return the Basic Aer backends in `BACKENDS` that are
+        effectively available (as some of them might depend on the presence
+        of an optional dependency or on the existence of a binary).
+
+        Returns:
+            dict[str:Backend]: a dict of Basic Aer backend instances for
+                the backends that could be instantiated, keyed by backend name.
+        """
+        ret = OrderedDict()
+        for backend_cls in SIMULATORS:
+            backend_instance = self._get_backend_instance(backend_cls)
+            backend_name = backend_instance.name()
+            ret[backend_name] = backend_instance
+        return ret
+
+    def _get_backend_instance(self, backend_cls):
+        """
+        Return an instance of a backend from its class.
+
+        Args:
+            backend_cls (class): backend class.
+        Returns:
+            Backend: a backend instance.
+        Raises:
+            QiskitError: if the backend could not be instantiated.
+        """
+        # Verify that the backend can be instantiated.
+        try:
+            backend_instance = backend_cls(provider=self)
+        except Exception as err:
+            raise QiskitError(f"Backend {backend_cls} could not be instantiated: {err}") from err
+
+        return backend_instance
+
+    def __str__(self):
+        return "BasicAer"