qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/providers/fake_provider/fake_provider.py

@@ -0,0 +1,214 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+# pylint: disable=wildcard-import,unused-argument
+
+"""
+Fake provider class that provides access to fake backends.
+"""
+
+from qiskit.providers.provider import ProviderV1
+from qiskit.providers.exceptions import QiskitBackendNotFoundError
+
+from .backends import *
+from .fake_qasm_simulator import FakeQasmSimulator
+from .fake_openpulse_2q import FakeOpenPulse2Q
+from .fake_openpulse_3q import FakeOpenPulse3Q
+
+
+class FakeProviderFactory:
+    """Fake provider factory class."""
+
+    def __init__(self):
+        self.fake_provider = FakeProvider()
+
+    def load_account(self):
+        """Fake load_account method to mirror the IBMQ provider."""
+        pass
+
+    def enable_account(self, *args, **kwargs):
+        """Fake enable_account method to mirror the IBMQ provider factory."""
+        pass
+
+    def disable_account(self):
+        """Fake disable_account method to mirror the IBMQ provider factory."""
+        pass
+
+    def save_account(self, *args, **kwargs):
+        """Fake save_account method to mirror the IBMQ provider factory."""
+        pass
+
+    @staticmethod
+    def delete_account():
+        """Fake delete_account method to mirror the IBMQ provider factory."""
+        pass
+
+    def update_account(self, force=False):
+        """Fake update_account method to mirror the IBMQ provider factory."""
+        pass
+
+    def providers(self):
+        """Fake providers method to mirror the IBMQ provider."""
+        return [self.fake_provider]
+
+    def get_provider(self, hub=None, group=None, project=None):
+        """Fake get_provider method to mirror the IBMQ provider."""
+        return self.fake_provider
+
+
+class FakeProviderForBackendV2(ProviderV1):
+    """Fake provider containing fake V2 backends.
+
+    Only filtering backends by name is implemented. This class contains all fake V2 backends
+    available in the :mod:`qiskit.providers.fake_provider`.
+    """
+
+    def get_backend(self, name=None, **kwargs):
+        backend = self._backends[0]
+        if name:
+            filtered_backends = [backend for backend in self._backends if backend.name() == name]
+            if not filtered_backends:
+                raise QiskitBackendNotFoundError()
+
+            backend = filtered_backends[0]
+
+        return backend
+
+    def backends(self, name=None, **kwargs):
+        return self._backends
+
+    def __init__(self):
+        self._backends = [
+            FakeAlmadenV2(),
+            FakeArmonkV2(),
+            FakeAthensV2(),
+            FakeAuckland(),
+            FakeBelemV2(),
+            FakeBoeblingenV2(),
+            FakeBogotaV2(),
+            FakeBrooklynV2(),
+            FakeBurlingtonV2(),
+            FakeCairoV2(),
+            FakeCambridgeV2(),
+            FakeCasablancaV2(),
+            FakeEssexV2(),
+            FakeGeneva(),
+            FakeGuadalupeV2(),
+            FakeHanoiV2(),
+            FakeJakartaV2(),
+            FakeJohannesburgV2(),
+            FakeKolkataV2(),
+            FakeLagosV2(),
+            FakeLimaV2(),
+            FakeLondonV2(),
+            FakeManhattanV2(),
+            FakeManilaV2(),
+            FakeMelbourneV2(),
+            FakeMontrealV2(),
+            FakeMumbaiV2(),
+            FakeNairobiV2(),
+            FakeOslo(),
+            FakeOurenseV2(),
+            FakeParisV2(),
+            FakePerth(),
+            FakePrague(),
+            FakePoughkeepsieV2(),
+            FakeQuitoV2(),
+            FakeRochesterV2(),
+            FakeRomeV2(),
+            FakeSantiagoV2(),
+            FakeSherbrooke(),
+            FakeSingaporeV2(),
+            FakeSydneyV2(),
+            FakeTorontoV2(),
+            FakeValenciaV2(),
+            FakeVigoV2(),
+            FakeWashingtonV2(),
+            FakeYorktownV2(),
+        ]
+
+        super().__init__()
+
+
+class FakeProvider(ProviderV1):
+    """Fake provider containing fake V1 backends.
+
+    Only filtering backends by name is implemented. This class contains all fake V1 backends
+    available in the :mod:`qiskit.providers.fake_provider`.
+    """
+
+    def get_backend(self, name=None, **kwargs):
+        backend = self._backends[0]
+        if name:
+            filtered_backends = [backend for backend in self._backends if backend.name() == name]
+            if not filtered_backends:
+                raise QiskitBackendNotFoundError()
+
+            backend = filtered_backends[0]
+
+        return backend
+
+    def backends(self, name=None, **kwargs):
+        return self._backends
+
+    def __init__(self):
+        self._backends = [
+            FakeAlmaden(),
+            FakeArmonk(),
+            FakeAthens(),
+            FakeBelem(),
+            FakeBoeblingen(),
+            FakeBogota(),
+            FakeBrooklyn(),
+            FakeBurlington(),
+            FakeCairo(),
+            FakeCambridge(),
+            FakeCambridgeAlternativeBasis(),
+            FakeCasablanca(),
+            FakeEssex(),
+            FakeGuadalupe(),
+            FakeHanoi(),
+            FakeJakarta(),
+            FakeJohannesburg(),
+            FakeKolkata(),
+            FakeLagos(),
+            FakeLima(),
+            FakeLondon(),
+            FakeManila(),
+            FakeManhattan(),
+            FakeMelbourne(),
+            FakeMontreal(),
+            FakeMumbai(),
+            FakeNairobi(),
+            FakeOpenPulse2Q(),
+            FakeOpenPulse3Q(),
+            FakeOurense(),
+            FakeParis(),
+            FakePoughkeepsie(),
+            FakeQasmSimulator(),
+            FakeQuito(),
+            FakeRochester(),
+            FakeRome(),
+            FakeRueschlikon(),
+            FakeSantiago(),
+            FakeSingapore(),
+            FakeSydney(),
+            FakeTenerife(),
+            FakeTokyo(),
+            FakeToronto(),
+            FakeValencia(),
+            FakeVigo(),
+            FakeWashington(),
+            FakeYorktown(),
+        ]
+
+        super().__init__()

qiskit/providers/fake_provider/fake_pulse_backend.py

@@ -0,0 +1,43 @@
+# 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.
+
+"""
+Fake backend abstract class for mock backends supporting OpenPulse.
+"""
+
+from qiskit.exceptions import QiskitError
+from qiskit.providers.models import PulseBackendConfiguration, PulseDefaults
+
+from .fake_qasm_backend import FakeQasmBackend
+from .utils.json_decoder import decode_pulse_defaults
+
+
+class FakePulseBackend(FakeQasmBackend):
+    """A fake pulse backend."""
+
+    defs_filename = None
+
+    def defaults(self):
+        """Returns a snapshot of device defaults"""
+        if not self._defaults:
+            self._set_defaults_from_json()
+        return self._defaults
+
+    def _set_defaults_from_json(self):
+        if not self.props_filename:
+            raise QiskitError("No properties file has been defined")
+        defs = self._load_json(self.defs_filename)
+        decode_pulse_defaults(defs)
+        self._defaults = PulseDefaults.from_dict(defs)
+
+    def _get_config_from_dict(self, conf):
+        return PulseBackendConfiguration.from_dict(conf)

qiskit/providers/fake_provider/fake_qasm_backend.py

@@ -0,0 +1,72 @@
+# 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.
+
+"""
+Fake backend abstract class for mock backends.
+"""
+
+import json
+import os
+
+from qiskit.exceptions import QiskitError
+from qiskit.providers.models import BackendProperties, QasmBackendConfiguration
+
+from .utils.json_decoder import (
+    decode_backend_configuration,
+    decode_backend_properties,
+)
+from .fake_backend import FakeBackend
+
+
+class FakeQasmBackend(FakeBackend):
+    """A fake OpenQASM backend."""
+
+    dirname = None
+    conf_filename = None
+    props_filename = None
+    backend_name = None
+
+    def __init__(self):
+        configuration = self._get_conf_from_json()
+        self._defaults = None
+        self._properties = None
+        super().__init__(configuration)
+
+    def properties(self):
+        """Returns a snapshot of device properties"""
+        if not self._properties:
+            self._set_props_from_json()
+        return self._properties
+
+    def _get_conf_from_json(self):
+        if not self.conf_filename:
+            raise QiskitError("No configuration file has been defined")
+        conf = self._load_json(self.conf_filename)
+        decode_backend_configuration(conf)
+        configuration = self._get_config_from_dict(conf)
+        configuration.backend_name = self.backend_name
+        return configuration
+
+    def _set_props_from_json(self):
+        if not self.props_filename:
+            raise QiskitError("No properties file has been defined")
+        props = self._load_json(self.props_filename)
+        decode_backend_properties(props)
+        self._properties = BackendProperties.from_dict(props)
+
+    def _load_json(self, filename):
+        with open(os.path.join(self.dirname, filename)) as f_json:
+            the_json = json.load(f_json)
+        return the_json
+
+    def _get_config_from_dict(self, conf):
+        return QasmBackendConfiguration.from_dict(conf)

qiskit/providers/fake_provider/fake_qasm_simulator.py

@@ -0,0 +1,48 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+"""
+Fake OpenQASM simulator.
+"""
+
+from qiskit.providers.models import GateConfig, QasmBackendConfiguration
+
+from .fake_backend import FakeBackend
+
+
+class FakeQasmSimulator(FakeBackend):
+    """A fake simulator backend."""
+
+    def __init__(self):
+        configuration = QasmBackendConfiguration(
+            backend_name="fake_qasm_simulator",
+            backend_version="0.0.0",
+            n_qubits=5,
+            basis_gates=["u1", "u2", "u3", "cx", "id", "unitary"],
+            coupling_map=None,
+            simulator=True,
+            local=True,
+            conditional=True,
+            open_pulse=False,
+            memory=True,
+            max_shots=65536,
+            gates=[GateConfig(name="TODO", parameters=[], qasm_def="TODO")],
+            dt=1.3333,
+            dtm=10.5,
+            qubit_lo_range=[[4.95, 5.05], [4.95, 5.05], [4.95, 5.05], [4.95, 5.05], [4.95, 5.05]],
+            meas_lo_range=[[6.65, 6.75], [6.65, 6.75], [6.65, 6.75], [6.65, 6.75], [6.65, 6.75]],
+        )
+
+        super().__init__(configuration)
+
+    def properties(self):
+        return None

qiskit/providers/fake_provider/fake_qobj.py

@@ -0,0 +1,44 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+"""
+Base Fake Qobj.
+"""
+
+from qiskit.qobj import (
+    QasmQobj,
+    QobjExperimentHeader,
+    QobjHeader,
+    QasmQobjInstruction,
+    QasmQobjExperimentConfig,
+    QasmQobjExperiment,
+    QasmQobjConfig,
+)
+
+from .fake_qasm_simulator import FakeQasmSimulator
+
+
+class FakeQobj(QasmQobj):
+    """A fake `Qobj` instance."""
+
+    def __init__(self):
+        qobj_id = "test_id"
+        config = QasmQobjConfig(shots=1024, memory_slots=1)
+        header = QobjHeader(backend_name=FakeQasmSimulator().name())
+        experiments = [
+            QasmQobjExperiment(
+                instructions=[QasmQobjInstruction(name="barrier", qubits=[1])],
+                header=QobjExperimentHeader(),
+                config=QasmQobjExperimentConfig(seed=123456),
+            )
+        ]
+        super().__init__(qobj_id=qobj_id, config=config, experiments=experiments, header=header)

qiskit/providers/fake_provider/utils/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+"""
+Utils for test backends.
+"""

qiskit/providers/fake_provider/utils/backend_converter.py

@@ -0,0 +1,150 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+
+"""
+Utilities for constructing Target object from configuration, properties and
+pulse defaults json files
+"""
+
+from qiskit.transpiler.target import Target, InstructionProperties
+from qiskit.providers.backend import QubitProperties
+from qiskit.utils.units import apply_prefix
+from qiskit.circuit.library.standard_gates import IGate, SXGate, XGate, CXGate, RZGate
+from qiskit.circuit.parameter import Parameter
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.delay import Delay
+from qiskit.circuit.measure import Measure
+from qiskit.circuit.reset import Reset
+from qiskit.providers.models.pulsedefaults import PulseDefaults
+
+
+def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict = None) -> Target:
+    """Uses configuration, properties and pulse defaults dicts
+    to construct and return Target class.
+    """
+    name_mapping = {
+        "id": IGate(),
+        "sx": SXGate(),
+        "x": XGate(),
+        "cx": CXGate(),
+        "rz": RZGate(Parameter("λ")),
+        "reset": Reset(),
+    }
+    custom_gates = {}
+    qubit_props = None
+    if props_dict:
+        qubit_props = qubit_props_from_props(props_dict)
+    target = Target(qubit_properties=qubit_props, concurrent_measurements=conf_dict.get("meas_map"))
+    # Parse from properties if it exsits
+    if props_dict is not None:
+        # Parse instructions
+        gates = {}
+        for gate in props_dict["gates"]:
+            name = gate["gate"]
+            if name in name_mapping:
+                if name not in gates:
+                    gates[name] = {}
+            elif name not in custom_gates:
+                custom_gate = Gate(name, len(gate["qubits"]), [])
+                custom_gates[name] = custom_gate
+                gates[name] = {}
+
+            qubits = tuple(gate["qubits"])
+            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():
+            if gate in name_mapping:
+                inst = name_mapping.get(gate)
+            else:
+                inst = custom_gates[gate]
+            target.add_instruction(inst, props)
+        # Create measurement instructions:
+        measure_props = {}
+        count = 0
+        for qubit in props_dict["qubits"]:
+            qubit_prop = {}
+            for prop in qubit:
+                if prop["name"] == "readout_length":
+                    qubit_prop["duration"] = apply_prefix(prop["value"], prop["unit"])
+                if prop["name"] == "readout_error":
+                    qubit_prop["error"] = prop["value"]
+            measure_props[(count,)] = InstructionProperties(**qubit_prop)
+            count += 1
+        target.add_instruction(Measure(), measure_props)
+    # Parse from configuration because properties doesn't exist
+    else:
+        for gate in conf_dict["gates"]:
+            name = gate["name"]
+            gate_props = {tuple(x): None for x in gate["coupling_map"]}
+            if name in name_mapping:
+                target.add_instruction(name_mapping[name], gate_props)
+            else:
+                custom_gate = Gate(name, len(gate["coupling_map"][0]), [])
+                target.add_instruction(custom_gate, gate_props)
+        measure_props = {(n,): None for n in range(conf_dict["n_qubits"])}
+        target.add_instruction(Measure(), measure_props)
+    # parse global configuration properties
+    dt = conf_dict.get("dt")
+    if dt:
+        target.dt = dt * 1e-9
+    if "timing_constraints" in conf_dict:
+        target.granularity = conf_dict["timing_constraints"].get("granularity")
+        target.min_length = conf_dict["timing_constraints"].get("min_length")
+        target.pulse_alignment = conf_dict["timing_constraints"].get("pulse_alignment")
+        target.acquire_alignment = conf_dict["timing_constraints"].get("acquire_alignment")
+    # If pulse defaults exists use that as the source of truth
+    if defs_dict is not None:
+        # TODO remove the usage of PulseDefaults as it will be deprecated in the future
+        pulse_defs = PulseDefaults.from_dict(defs_dict)
+        inst_map = pulse_defs.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:
+                            target[inst][(qubit,)].calibration = calibration_entry
+                    elif qargs in target[inst]:
+                        target[inst][qargs].calibration = calibration_entry
+    target.add_instruction(
+        Delay(Parameter("t")), {(bit,): None for bit in range(target.num_qubits)}
+    )
+    return target
+
+
+def qubit_props_from_props(properties: dict) -> list:
+    """Returns a dictionary of `qiskit.providers.backend.QubitProperties` using
+    a backend properties dictionary created by loading props.json payload.
+    """
+    qubit_props = []
+    for qubit in properties["qubits"]:
+        qubit_properties = {}
+        for prop_dict in qubit:
+            if prop_dict["name"] == "T1":
+                qubit_properties["t1"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+            elif prop_dict["name"] == "T2":
+                qubit_properties["t2"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+            elif prop_dict["name"] == "frequency":
+                qubit_properties["frequency"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+        qubit_props.append(QubitProperties(**qubit_properties))
+    return qubit_props