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

qiskit/providers/__init__.py

@@ -17,13 +17,13 @@ Providers Interface (:mod:`qiskit.providers`)
 
 .. currentmodule:: qiskit.providers
 
-This module contains the classes used to build external providers for Terra. A
-provider is anything that provides an external service to Terra. The typical
+This module contains the classes used to build external providers for Qiskit. A
+provider is anything that provides an external service to Qiskit. The typical
 example of this is a Backend provider which provides
 :class:`~qiskit.providers.Backend` objects which can be used for executing
 :class:`~qiskit.circuit.QuantumCircuit` and/or :class:`~qiskit.pulse.Schedule`
 objects. This module contains the abstract classes which are used to define the
-interface between a provider and terra.
+interface between a provider and Qiskit.
 
 Version Support
 ===============
@@ -36,17 +36,17 @@ backwards compatible between versions.
 Version Changes
 ----------------
 
-Each minor version release of qiskit-terra **may** increment the version of any
-providers interface a single version number. It will be an aggregate of all
+Each minor version release of ``qiskit`` **may** increment the version of any
+backend interface a single version number. It will be an aggregate of all
 the interface changes for that release on that interface.
 
 Version Support Policy
 ----------------------
 
 To enable providers to have time to adjust to changes in this interface
-Terra will support multiple versions of each class at once. Given the
+Qiskit will support multiple versions of each class at once. Given the
 nature of one version per release the version deprecation policy is a bit
-more conservative than the standard deprecation policy. Terra will support a
+more conservative than the standard deprecation policy. Qiskit will support a
 provider interface version for a minimum of 3 minor releases or the first
 release after 6 months from the release that introduced a version, whichever is
 longer, prior to a potential deprecation. After that the standard deprecation
@@ -57,17 +57,17 @@ the release of 0.19.0 we release 0.20.0, 0.21.0, and 0.22.0, then 7 months after
 0.19.0 we release 0.23.0. In 0.23.0 we can deprecate BackendV2, and it needs to
 still be supported and can't be removed until the deprecation policy completes.
 
-It's worth pointing out that Terra's version support policy doesn't mean
+It's worth pointing out that Qiskit's version support policy doesn't mean
 providers themselves will have the same support story, they can (and arguably
 should) update to newer versions as soon as they can, the support window is
-just for Terra's supported versions. Part of this lengthy window prior to
+just for Qiskit's supported versions. Part of this lengthy window prior to
 deprecation is to give providers enough time to do their own deprecation of a
 potential end user impacting change in a user facing part of the interface
 prior to bumping their version. For example, let's say we changed the signature
 to ``Backend.run()`` in ``BackendV34`` in a backwards incompatible way. Before
 Aer could update its :class:`~qiskit_aer.AerSimulator` class
 to be based on version 34 they'd need to deprecate the old signature prior to switching
-over. The changeover for Aer is not guaranteed to be lockstep with Terra so we
+over. The changeover for Aer is not guaranteed to be lockstep with Qiskit, so we
 need to ensure there is a sufficient amount of time for Aer to complete its
 deprecation cycle prior to removing version 33 (ie making version 34
 mandatory/the minimum version).
@@ -131,12 +131,12 @@ Exceptions
 .. autoexception:: JobTimeoutError
 .. autoexception:: BackendConfigurationError
 
-======================
-Writing a New Provider
-======================
+Writing a New Backend
+=====================
 
 If you have a quantum device or simulator that you would like to integrate with
-Qiskit you will need to write a provider. A provider will provide Terra with a
+Qiskit you will need to write a backend. A provider is a collection of backends
+and will provide Qiskit with a
 method to get available :class:`~qiskit.providers.BackendV2` objects. The
 :class:`~qiskit.providers.BackendV2` object provides both information describing
 a backend and its operation for the :mod:`~qiskit.transpiler` so that circuits
@@ -149,8 +149,7 @@ executing circuits on devices in a standard
 fashion regardless of how the backend is implemented. At a high level the basic
 steps for writing a provider are:
 
- * Implement a :class:`~qiskit.providers.ProviderV1` subclass that handles
-   access to the backend(s).
+ * Implement a ``Provider`` class that handles access to the backend(s).
  * Implement a :class:`~qiskit.providers.BackendV2` subclass and its
    :meth:`~qiskit.providers.BackendV2.run` method.
 
@@ -164,7 +163,7 @@ For a simple example of a provider, see the
 `qiskit-aqt-provider <https://github.com/Qiskit-Partners/qiskit-aqt-provider>`__
 
 Provider
-========
+--------
 
 A provider class serves a single purpose: to get backend objects that enable
 executing circuits on a device or simulator. The expectation is that any
@@ -173,12 +172,11 @@ of a provider object. The provider object will then provide a list of backends,
 and methods to filter and acquire backends (using the provided credentials if
 required). An example provider class looks like::
 
-    from qiskit.providers import ProviderV1 as Provider
     from qiskit.providers.providerutils import filter_backends
 
     from .backend import MyBackend
 
-    class MyProvider(Provider):
+    class MyProvider:
 
         def __init__(self, token=None):
             super().__init__()
@@ -196,7 +194,7 @@ authentication (if required) are present in the class and that the backends
 method matches the required interface. The rest is up to the specific provider on how to implement.
 
 Backend
-=======
+-------
 
 The backend classes are the core to the provider. These classes are what
 provide the interface between Qiskit and the hardware or simulator that will
@@ -277,8 +275,8 @@ example would be something like::
             return MyJob(self. job_handle, job_json, circuit)
 
 
-Transpiler Interface
---------------------
+Backend's Transpiler Interface
+------------------------------
 
 The key piece of the :class:`~qiskit.providers.Backend` object is how it describes itself to the
 compiler. This is handled with the :class:`~qiskit.transpiler.Target` class which defines
@@ -454,8 +452,45 @@ This way if these two compilation steps are **required** for running or providin
 efficient output on ``Mybackend`` the transpiler will be able to perform these
 custom steps without any manual user input.
 
-Run Method
-----------
+.. _providers-guide-real-time-variables:
+
+Real-time variables
+^^^^^^^^^^^^^^^^^^^
+
+The transpiler will automatically handle real-time typed classical variables (see
+:mod:`qiskit.circuit.classical`) and treat the :class:`.Store` instruction as a built-in
+"directive", similar to :class:`.Barrier`.  No special handling from backends is necessary to permit
+this.
+
+If your backend is *unable* to handle classical variables and storage, we recommend that you comment
+on this in your documentation, and insert a check into your :meth:`~.BackendV2.run` method (see
+:ref:`providers-guide-backend-run`) to eagerly reject circuits containing them.  You can examine
+:attr:`.QuantumCircuit.num_vars` for the presence of variables at the top level.  If you accept
+:ref:`control-flow operations <circuit-control-flow-repr>`, you might need to recursively search the
+internal :attr:`~.ControlFlowOp.blocks` of each for scope-local variables with
+:attr:`.QuantumCircuit.num_declared_vars`.
+
+For example, a function to check for the presence of any manual storage locations, or manual stores
+to memory::
+
+    from qiskit.circuit import Store, ControlFlowOp, QuantumCircuit
+
+    def has_realtime_logic(circuit: QuantumCircuit) -> bool:
+        if circuit.num_vars:
+            return True
+        for instruction in circuit.data:
+            if isinstance(instruction.operation, Store):
+                return True
+            elif isinstance(instruction.operation, ControlFlowOp):
+                for block in instruction.operation.blocks:
+                    if has_realtime_logic(block):
+                        return True
+        return False
+
+.. _providers-guide-backend-run:
+
+Backend.run Method
+------------------
 
 Of key importance is the :meth:`~qiskit.providers.BackendV2.run` method, which
 is used to actually submit circuits to a device or simulator. The run method
@@ -485,8 +520,8 @@ An example run method would be something like::
         job_handle = submit_to_backend(job_jsonb)
         return MyJob(self. job_handle, job_json, circuit)
 
-Options
--------
+Backend Options
+---------------
 
 There are often several options for a backend that control how a circuit is run.
 The typical example of this is something like the number of ``shots`` which is
@@ -516,7 +551,7 @@ for a full list of validation options.
 
 
 Job
-===
+---
 
 The output from the :obj:`~qiskit.providers.BackendV2.run` method is a :class:`~qiskit.providers.JobV1`
 object. Each provider is expected to implement a custom job subclass that
@@ -613,7 +648,7 @@ and for a sync job::
             return JobStatus.DONE
 
 Primitives
-==========
+----------
 
 While not directly part of the provider interface, the :mod:`qiskit.primitives`
 module is tightly coupled with providers. Specifically the primitive
@@ -641,12 +676,8 @@ implementations. Also the built-in implementations: :class:`~.Sampler`,
 :class:`~.Estimator`, :class:`~.BackendSampler`, and :class:`~.BackendEstimator`
 can serve as references/models on how to implement these as well.
 
-======================================
-Migrating between Backend API Versions
-======================================
-
-BackendV1 -> BackendV2
-======================
+Migrating from BackendV1 to BackendV2
+=====================================
 
 The :obj:`~BackendV2` class re-defined user access for most properties of a
 backend to make them work with native Qiskit data structures and have flatter

qiskit/providers/backend.py

@@ -40,8 +40,8 @@ class Backend:
 class BackendV1(Backend, ABC):
     """Abstract class for Backends
 
-    This abstract class is to be used for all Backend objects created by a
-    provider. There are several classes of information contained in a Backend.
+    This abstract class is to be used for Backend objects.
+    There are several classes of information contained in a Backend.
     The first are the attributes of the class itself. These should be used to
     defined the immutable characteristics of the backend. The ``options``
     attribute of the backend is used to contain the dynamic user configurable

qiskit/providers/backend_compat.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020.
+# (C) Copyright IBM 2020, 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
@@ -57,7 +57,7 @@ def convert_to_target(
         A ``Target`` instance.
     """
 
-    # importing pacakges where they are needed, to avoid cyclic-import.
+    # importing packages where they are needed, to avoid cyclic-import.
     # pylint: disable=cyclic-import
     from qiskit.transpiler.target import (
         Target,
@@ -82,7 +82,7 @@ def convert_to_target(
         "switch_case": SwitchCaseOp,
     }
 
-    in_data = {"num_qubits": configuration.n_qubits}
+    in_data = {"num_qubits": configuration.num_qubits}
 
     # Parse global configuration properties
     if hasattr(configuration, "dt"):
@@ -97,7 +97,6 @@ def convert_to_target(
     all_instructions = set.union(
         basis_gates, set(required), supported_instructions.intersection(CONTROL_FLOW_OP_NAMES)
     )
-
     inst_name_map = {}  # type: Dict[str, Instruction]
 
     faulty_ops = set()
@@ -244,10 +243,8 @@ def convert_to_target(
 
         for name in inst_sched_map.instructions:
             for qubits in inst_sched_map.qubits_with_instruction(name):
-
                 if not isinstance(qubits, tuple):
                     qubits = (qubits,)
-
                 if (
                     name not in all_instructions
                     or name not in prop_name_map
@@ -267,17 +264,18 @@ def convert_to_target(
                     continue
 
                 entry = inst_sched_map._get_calibration_entry(name, qubits)
-
                 try:
                     prop_name_map[name][qubits].calibration = entry
                 except AttributeError:
+                    # if instruction properties are "None", add entry
+                    prop_name_map[name].update({qubits: InstructionProperties(None, None, entry)})
                     logger.info(
                         "The PulseDefaults payload received contains an instruction %s on "
-                        "qubits %s which is not present in the configuration or properties payload.",
+                        "qubits %s which is not present in the configuration or properties payload."
+                        "A new properties entry will be added to include the new calibration data.",
                         name,
                         qubits,
                     )
-
     # Add parsed properties to target
     target = Target(**in_data)
     for inst_name in all_instructions:
@@ -384,7 +382,7 @@ class BackendV2Converter(BackendV2):
         super().__init__(
             provider=backend.provider,
             name=backend.name(),
-            description=self._config.description,
+            description=getattr(self._config, "description", None),
             online_date=getattr(self._config, "online_date", None),
             backend_version=self._config.backend_version,
         )

qiskit/providers/basic_provider/__init__.py

@@ -27,36 +27,15 @@ via the `BasicProvider` provider, e.g.:
    backend = BasicProvider().get_backend('basic_simulator')
 
 
-Simulators
-==========
+Classes
+=======
 
 .. autosummary::
    :toctree: ../stubs/
 
    BasicSimulator
-
-Provider
-========
-
-.. autosummary::
-   :toctree: ../stubs/
-
    BasicProvider
-
-Job Class
-=========
-
-.. autosummary::
-   :toctree: ../stubs/
-
    BasicProviderJob
-
-Exceptions
-==========
-
-.. autosummary::
-   :toctree: ../stubs/
-
    BasicProviderError
 """
 

qiskit/providers/basic_provider/basic_provider_tools.py

@@ -23,7 +23,30 @@ import qiskit.circuit.library.standard_gates as gates
 from qiskit.exceptions import QiskitError
 
 # Single qubit gates supported by ``single_gate_params``.
-SINGLE_QUBIT_GATES = ("U", "u", "h", "p", "u1", "u2", "u3", "rz", "sx", "x")
+SINGLE_QUBIT_GATES = {
+    "U": gates.UGate,
+    "u": gates.UGate,
+    "u1": gates.U1Gate,
+    "u2": gates.U2Gate,
+    "u3": gates.U3Gate,
+    "h": gates.HGate,
+    "p": gates.PhaseGate,
+    "s": gates.SGate,
+    "sdg": gates.SdgGate,
+    "sx": gates.SXGate,
+    "sxdg": gates.SXdgGate,
+    "t": gates.TGate,
+    "tdg": gates.TdgGate,
+    "x": gates.XGate,
+    "y": gates.YGate,
+    "z": gates.ZGate,
+    "id": gates.IGate,
+    "i": gates.IGate,
+    "r": gates.RGate,
+    "rx": gates.RXGate,
+    "ry": gates.RYGate,
+    "rz": gates.RZGate,
+}
 
 
 def single_gate_matrix(gate: str, params: list[float] | None = None) -> np.ndarray:
@@ -40,42 +63,55 @@ def single_gate_matrix(gate: str, params: list[float] | None = None) -> np.ndarr
     """
     if params is None:
         params = []
-
-    if gate == "U":
-        gc = gates.UGate
-    elif gate == "u3":
-        gc = gates.U3Gate
-    elif gate == "h":
-        gc = gates.HGate
-    elif gate == "u":
-        gc = gates.UGate
-    elif gate == "p":
-        gc = gates.PhaseGate
-    elif gate == "u2":
-        gc = gates.U2Gate
-    elif gate == "u1":
-        gc = gates.U1Gate
-    elif gate == "rz":
-        gc = gates.RZGate
-    elif gate == "id":
-        gc = gates.IGate
-    elif gate == "sx":
-        gc = gates.SXGate
-    elif gate == "x":
-        gc = gates.XGate
+    if gate in SINGLE_QUBIT_GATES:
+        gc = SINGLE_QUBIT_GATES[gate]
     else:
         raise QiskitError("Gate is not a valid basis gate for this simulator: %s" % gate)
 
     return gc(*params).to_matrix()
 
 
-# Cache CX matrix as no parameters.
-_CX_MATRIX = gates.CXGate().to_matrix()
-
-
-def cx_gate_matrix() -> np.ndarray:
-    """Get the matrix for a controlled-NOT gate."""
-    return _CX_MATRIX
+# Two qubit gates WITHOUT parameters: name -> matrix
+TWO_QUBIT_GATES = {
+    "CX": gates.CXGate().to_matrix(),
+    "cx": gates.CXGate().to_matrix(),
+    "ecr": gates.ECRGate().to_matrix(),
+    "cy": gates.CYGate().to_matrix(),
+    "cz": gates.CZGate().to_matrix(),
+    "swap": gates.SwapGate().to_matrix(),
+    "iswap": gates.iSwapGate().to_matrix(),
+    "ch": gates.CHGate().to_matrix(),
+    "cs": gates.CSGate().to_matrix(),
+    "csdg": gates.CSdgGate().to_matrix(),
+    "csx": gates.CSXGate().to_matrix(),
+    "dcx": gates.DCXGate().to_matrix(),
+}
+
+# Two qubit gates WITH parameters: name -> class
+TWO_QUBIT_GATES_WITH_PARAMETERS = {
+    "cp": gates.CPhaseGate,
+    "crx": gates.CRXGate,
+    "cry": gates.CRYGate,
+    "crz": gates.CRZGate,
+    "cu": gates.CUGate,
+    "cu1": gates.CU1Gate,
+    "cu3": gates.CU3Gate,
+    "rxx": gates.RXXGate,
+    "ryy": gates.RYYGate,
+    "rzz": gates.RZZGate,
+    "rzx": gates.RZXGate,
+    "xx_minus_yy": gates.XXMinusYYGate,
+    "xx_plus_yy": gates.XXPlusYYGate,
+}
+
+
+# Three qubit gates: name -> matrix
+THREE_QUBIT_GATES = {
+    "ccx": gates.CCXGate().to_matrix(),
+    "ccz": gates.CCZGate().to_matrix(),
+    "rccx": gates.RCCXGate().to_matrix(),
+    "cswap": gates.CSwapGate().to_matrix(),
+}
 
 
 def einsum_matmul_index(gate_indices: list[int], number_of_qubits: int) -> str:

qiskit/providers/basic_provider/basic_simulator.py

@@ -29,6 +29,7 @@ field, which is a result of measurements for each shot.
 
 from __future__ import annotations
 
+import math
 import uuid
 import time
 import logging
@@ -39,7 +40,7 @@ import numpy as np
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.library import UnitaryGate
-from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
+from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping, GlobalPhaseGate
 from qiskit.providers import Provider
 from qiskit.providers.backend import BackendV2
 from qiskit.providers.models import BackendConfiguration
@@ -50,8 +51,12 @@ from qiskit.transpiler import Target
 
 from .basic_provider_job import BasicProviderJob
 from .basic_provider_tools import single_gate_matrix
-from .basic_provider_tools import SINGLE_QUBIT_GATES
-from .basic_provider_tools import cx_gate_matrix
+from .basic_provider_tools import (
+    SINGLE_QUBIT_GATES,
+    TWO_QUBIT_GATES,
+    TWO_QUBIT_GATES_WITH_PARAMETERS,
+    THREE_QUBIT_GATES,
+)
 from .basic_provider_tools import einsum_vecmul_index
 from .exceptions import BasicProviderError
 
@@ -137,21 +142,59 @@ class BasicSimulator(BackendV2):
             num_qubits=None,
         )
         basis_gates = [
+            "ccx",
+            "ccz",
+            "ch",
+            "cp",
+            "crx",
+            "cry",
+            "crz",
+            "cs",
+            "csdg",
+            "cswap",
+            "csx",
+            "cu",
+            "cu1",
+            "cu3",
+            "cx",
+            "cy",
+            "cz",
+            "dcx",
+            "delay",
+            "ecr",
+            "global_phase",
             "h",
-            "u",
+            "id",
+            "iswap",
+            "measure",
             "p",
+            "r",
+            "rccx",
+            "reset",
+            "rx",
+            "rxx",
+            "ry",
+            "ryy",
+            "rz",
+            "rzx",
+            "rzz",
+            "s",
+            "sdg",
+            "swap",
+            "sx",
+            "sxdg",
+            "t",
+            "tdg",
+            "u",
             "u1",
             "u2",
             "u3",
-            "rz",
-            "sx",
-            "x",
-            "cx",
-            "id",
             "unitary",
-            "measure",
-            "delay",
-            "reset",
+            "x",
+            "xx_minus_yy",
+            "xx_plus_yy",
+            "y",
+            "z",
         ]
         inst_mapping = get_standard_gate_name_mapping()
         for name in basis_gates:
@@ -331,9 +374,9 @@ class BasicSimulator(BackendV2):
 
         # update quantum state
         if outcome == "0":
-            update_diag = [[1 / np.sqrt(probability), 0], [0, 0]]
+            update_diag = [[1 / math.sqrt(probability), 0], [0, 0]]
         else:
-            update_diag = [[0, 0], [0, 1 / np.sqrt(probability)]]
+            update_diag = [[0, 0], [0, 1 / math.sqrt(probability)]]
         # update classical state
         self._add_unitary(update_diag, [qubit])
 
@@ -351,10 +394,10 @@ class BasicSimulator(BackendV2):
         outcome, probability = self._get_measure_outcome(qubit)
         # update quantum state
         if outcome == "0":
-            update = [[1 / np.sqrt(probability), 0], [0, 0]]
+            update = [[1 / math.sqrt(probability), 0], [0, 0]]
             self._add_unitary(update, [qubit])
         else:
-            update = [[0, 1 / np.sqrt(probability)], [0, 0]]
+            update = [[0, 1 / math.sqrt(probability)], [0, 0]]
             self._add_unitary(update, [qubit])
 
     def _validate_initial_statevector(self) -> None:
@@ -478,7 +521,7 @@ class BasicSimulator(BackendV2):
             Example::
 
                 backend_options = {
-                    "initial_statevector": np.array([1, 0, 0, 1j]) / np.sqrt(2),
+                    "initial_statevector": np.array([1, 0, 0, 1j]) / math.sqrt(2),
                 }
         """
         # TODO: replace assemble with new run flow
@@ -616,24 +659,41 @@ class BasicSimulator(BackendV2):
                             value >>= 1
                         if value != int(operation.conditional.val, 16):
                             continue
-                # Check if single  gate
                 if operation.name == "unitary":
                     qubits = operation.qubits
                     gate = operation.params[0]
                     self._add_unitary(gate, qubits)
+                elif operation.name in ("id", "u0", "delay"):
+                    pass
+                elif operation.name == "global_phase":
+                    params = getattr(operation, "params", None)
+                    gate = GlobalPhaseGate(*params).to_matrix()
+                    self._add_unitary(gate, [])
+                # Check if single qubit gate
                 elif operation.name in SINGLE_QUBIT_GATES:
                     params = getattr(operation, "params", None)
                     qubit = operation.qubits[0]
                     gate = single_gate_matrix(operation.name, params)
                     self._add_unitary(gate, [qubit])
-                # Check if CX gate
+                elif operation.name in TWO_QUBIT_GATES_WITH_PARAMETERS:
+                    params = getattr(operation, "params", None)
+                    qubit0 = operation.qubits[0]
+                    qubit1 = operation.qubits[1]
+                    gate = TWO_QUBIT_GATES_WITH_PARAMETERS[operation.name](*params).to_matrix()
+                    self._add_unitary(gate, [qubit0, qubit1])
                 elif operation.name in ("id", "u0"):
                     pass
-                elif operation.name in ("CX", "cx"):
+                elif operation.name in TWO_QUBIT_GATES:
                     qubit0 = operation.qubits[0]
                     qubit1 = operation.qubits[1]
-                    gate = cx_gate_matrix()
+                    gate = TWO_QUBIT_GATES[operation.name]
                     self._add_unitary(gate, [qubit0, qubit1])
+                elif operation.name in THREE_QUBIT_GATES:
+                    qubit0 = operation.qubits[0]
+                    qubit1 = operation.qubits[1]
+                    qubit2 = operation.qubits[2]
+                    gate = THREE_QUBIT_GATES[operation.name]
+                    self._add_unitary(gate, [qubit0, qubit1, qubit2])
                 # Check if reset
                 elif operation.name == "reset":
                     qubit = operation.qubits[0]

qiskit/providers/fake_provider/__init__.py

@@ -24,7 +24,7 @@ The fake provider module in Qiskit contains fake (simulated) backend classes
 useful for testing the transpiler and other backend-facing functionality.
 
 Example Usage
-=============
+-------------
 
 Here is an example of using a simulated backend for transpilation and running.
 

qiskit/providers/fake_provider/fake_1q.py

@@ -32,7 +32,7 @@ class Fake1Q(FakeBackend):
         configuration = BackendProperties(
             backend_name="fake_1q",
             backend_version="0.0.0",
-            n_qubits=1,
+            num_qubits=1,
             basis_gates=["u1", "u2", "u3", "cx"],
             simulator=False,
             local=True,