qiskit 1.4.1__cp39-abi3-win_amd64.whl → 2.0.0rc1__cp39-abi3-win_amd64.whl

qiskit/qpy/type_keys.py

@@ -30,6 +30,7 @@ from qiskit.circuit import (
     CASE_DEFAULT,
     Clbit,
     ClassicalRegister,
+    Duration,
 )
 from qiskit.circuit.annotated_operation import AnnotatedOperation, Modifier
 from qiskit.circuit.classical import expr, types
@@ -37,36 +38,6 @@ from qiskit.circuit.library import PauliEvolutionGate
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.parametervector import ParameterVectorElement
-from qiskit.pulse.channels import (
-    Channel,
-    DriveChannel,
-    MeasureChannel,
-    ControlChannel,
-    AcquireChannel,
-    MemorySlot,
-    RegisterSlot,
-)
-from qiskit.pulse.configuration import Discriminator, Kernel
-from qiskit.pulse.instructions import (
-    Acquire,
-    Play,
-    Delay,
-    SetFrequency,
-    ShiftFrequency,
-    SetPhase,
-    ShiftPhase,
-    RelativeBarrier,
-    TimeBlockade,
-    Reference,
-)
-from qiskit.pulse.library import Waveform, SymbolicPulse
-from qiskit.pulse.schedule import ScheduleBlock
-from qiskit.pulse.transforms.alignments import (
-    AlignLeft,
-    AlignRight,
-    AlignSequential,
-    AlignEquispaced,
-)
 from qiskit.qpy import exceptions
 
 
@@ -168,7 +139,7 @@ class Condition(IntEnum):
 
 
 class Container(TypeKeyBase):
-    """Typle key enum for container-like object."""
+    """Type key enum for container-like object."""
 
     RANGE = b"r"
     TUPLE = b"t"
@@ -220,125 +191,13 @@ class CircuitInstruction(TypeKeyBase):
         raise NotImplementedError
 
 
-class ScheduleAlignment(TypeKeyBase):
-    """Type key enum for schedule block alignment context object."""
-
-    LEFT = b"l"
-    RIGHT = b"r"
-    SEQUENTIAL = b"s"
-    EQUISPACED = b"e"
-
-    # AlignFunc is not serializable due to the callable in context parameter
-
-    @classmethod
-    def assign(cls, obj):
-        if isinstance(obj, AlignLeft):
-            return cls.LEFT
-        if isinstance(obj, AlignRight):
-            return cls.RIGHT
-        if isinstance(obj, AlignSequential):
-            return cls.SEQUENTIAL
-        if isinstance(obj, AlignEquispaced):
-            return cls.EQUISPACED
-
-        raise exceptions.QpyError(
-            f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
-        )
-
-    @classmethod
-    def retrieve(cls, type_key):
-        if type_key == cls.LEFT:
-            return AlignLeft
-        if type_key == cls.RIGHT:
-            return AlignRight
-        if type_key == cls.SEQUENTIAL:
-            return AlignSequential
-        if type_key == cls.EQUISPACED:
-            return AlignEquispaced
-
-        raise exceptions.QpyError(
-            f"A class corresponding to type key '{type_key}' is not found in {cls.__name__} namespace."
-        )
-
-
-class ScheduleInstruction(TypeKeyBase):
-    """Type key enum for schedule instruction object."""
-
-    ACQUIRE = b"a"
-    PLAY = b"p"
-    DELAY = b"d"
-    SET_FREQUENCY = b"f"
-    SHIFT_FREQUENCY = b"g"
-    SET_PHASE = b"q"
-    SHIFT_PHASE = b"r"
-    BARRIER = b"b"
-    TIME_BLOCKADE = b"t"
-    REFERENCE = b"y"
-
-    # 's' is reserved by ScheduleBlock, i.e. block can be nested as an element.
-    # Call instruction is not supported by QPY.
-    # This instruction has been excluded from ScheduleBlock instructions with
-    # qiskit-terra/#8005 and new instruction Reference will be added instead.
-    # Call is only applied to Schedule which is not supported by QPY.
-    # Also snapshot is not suppored because of its limited usecase.
-
-    @classmethod
-    def assign(cls, obj):
-        if isinstance(obj, Acquire):
-            return cls.ACQUIRE
-        if isinstance(obj, Play):
-            return cls.PLAY
-        if isinstance(obj, Delay):
-            return cls.DELAY
-        if isinstance(obj, SetFrequency):
-            return cls.SET_FREQUENCY
-        if isinstance(obj, ShiftFrequency):
-            return cls.SHIFT_FREQUENCY
-        if isinstance(obj, SetPhase):
-            return cls.SET_PHASE
-        if isinstance(obj, ShiftPhase):
-            return cls.SHIFT_PHASE
-        if isinstance(obj, RelativeBarrier):
-            return cls.BARRIER
-        if isinstance(obj, TimeBlockade):
-            return cls.TIME_BLOCKADE
-        if isinstance(obj, Reference):
-            return cls.REFERENCE
-
-        raise exceptions.QpyError(
-            f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
-        )
-
-    @classmethod
-    def retrieve(cls, type_key):
-        if type_key == cls.ACQUIRE:
-            return Acquire
-        if type_key == cls.PLAY:
-            return Play
-        if type_key == cls.DELAY:
-            return Delay
-        if type_key == cls.SET_FREQUENCY:
-            return SetFrequency
-        if type_key == cls.SHIFT_FREQUENCY:
-            return ShiftFrequency
-        if type_key == cls.SET_PHASE:
-            return SetPhase
-        if type_key == cls.SHIFT_PHASE:
-            return ShiftPhase
-        if type_key == cls.BARRIER:
-            return RelativeBarrier
-        if type_key == cls.TIME_BLOCKADE:
-            return TimeBlockade
-        if type_key == cls.REFERENCE:
-            return Reference
-
-        raise exceptions.QpyError(
-            f"A class corresponding to type key '{type_key}' is not found in {cls.__name__} namespace."
-        )
-
-
 class ScheduleOperand(TypeKeyBase):
-    """Type key enum for schedule instruction operand object."""
+    """Type key enum for schedule instruction operand object.
+
+    Note: This class is kept post pulse-removal to allow reading of
+    legacy payloads containing pulse gates without breaking the entire
+    load flow.
+    """
 
     WAVEFORM = b"w"
     SYMBOLIC_PULSE = b"s"
@@ -353,92 +212,27 @@ class ScheduleOperand(TypeKeyBase):
     OPERAND_STR = b"o"
 
     @classmethod
-    def assign(cls, obj):
-        if isinstance(obj, Waveform):
-            return cls.WAVEFORM
-        if isinstance(obj, SymbolicPulse):
-            return cls.SYMBOLIC_PULSE
-        if isinstance(obj, Channel):
-            return cls.CHANNEL
-        if isinstance(obj, str):
-            return cls.OPERAND_STR
-        if isinstance(obj, Kernel):
-            return cls.KERNEL
-        if isinstance(obj, Discriminator):
-            return cls.DISCRIMINATOR
-
-        raise exceptions.QpyError(
-            f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
-        )
-
-    @classmethod
-    def retrieve(cls, type_key):
+    def assign(cls, _):
         raise NotImplementedError
 
-
-class ScheduleChannel(TypeKeyBase):
-    """Type key enum for schedule channel object."""
-
-    DRIVE = b"d"
-    CONTROL = b"c"
-    MEASURE = b"m"
-    ACQURE = b"a"
-    MEM_SLOT = b"e"
-    REG_SLOT = b"r"
-
-    # SnapShot channel is not defined because of its limited usecase.
-
-    @classmethod
-    def assign(cls, obj):
-        if isinstance(obj, DriveChannel):
-            return cls.DRIVE
-        if isinstance(obj, ControlChannel):
-            return cls.CONTROL
-        if isinstance(obj, MeasureChannel):
-            return cls.MEASURE
-        if isinstance(obj, AcquireChannel):
-            return cls.ACQURE
-        if isinstance(obj, MemorySlot):
-            return cls.MEM_SLOT
-        if isinstance(obj, RegisterSlot):
-            return cls.REG_SLOT
-
-        raise exceptions.QpyError(
-            f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
-        )
-
     @classmethod
-    def retrieve(cls, type_key):
-        if type_key == cls.DRIVE:
-            return DriveChannel
-        if type_key == cls.CONTROL:
-            return ControlChannel
-        if type_key == cls.MEASURE:
-            return MeasureChannel
-        if type_key == cls.ACQURE:
-            return AcquireChannel
-        if type_key == cls.MEM_SLOT:
-            return MemorySlot
-        if type_key == cls.REG_SLOT:
-            return RegisterSlot
-
-        raise exceptions.QpyError(
-            f"A class corresponding to type key '{type_key}' is not found in {cls.__name__} namespace."
-        )
+    def retrieve(cls, _):
+        raise NotImplementedError
 
 
 class Program(TypeKeyBase):
-    """Typle key enum for program that QPY supports."""
+    """Type key enum for program that QPY supports."""
 
     CIRCUIT = b"q"
+    # This is left for backward compatibility, for identifying payloads of type `ScheduleBlock`
+    # and raising accordingly. `ScheduleBlock` support has been removed in Qiskit 2.0 as part
+    # of the pulse package removal in that version.
     SCHEDULE_BLOCK = b"s"
 
     @classmethod
     def assign(cls, obj):
         if isinstance(obj, QuantumCircuit):
             return cls.CIRCUIT
-        if isinstance(obj, ScheduleBlock):
-            return cls.SCHEDULE_BLOCK
 
         raise exceptions.QpyError(
             f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
@@ -453,6 +247,7 @@ class Expression(TypeKeyBase):
     """Type keys for the ``EXPRESSION`` QPY item."""
 
     VAR = b"x"
+    STRETCH = b"s"
     VALUE = b"v"
     CAST = b"c"
     UNARY = b"u"
@@ -479,6 +274,8 @@ class ExprVarDeclaration(TypeKeyBase):
     INPUT = b"I"
     CAPTURE = b"C"
     LOCAL = b"L"
+    STRETCH_CAPTURE = b"A"
+    STRETCH_LOCAL = b"O"
 
     @classmethod
     def assign(cls, obj):
@@ -494,6 +291,8 @@ class ExprType(TypeKeyBase):
 
     BOOL = b"b"
     UINT = b"u"
+    FLOAT = b"f"
+    DURATION = b"d"
 
     @classmethod
     def assign(cls, obj):
@@ -538,6 +337,8 @@ class ExprValue(TypeKeyBase):
 
     BOOL = b"b"
     INT = b"i"
+    FLOAT = b"f"
+    DURATION = b"t"
 
     @classmethod
     def assign(cls, obj):
@@ -545,6 +346,42 @@ class ExprValue(TypeKeyBase):
             return cls.BOOL
         if isinstance(obj, int):
             return cls.INT
+        if isinstance(obj, float):
+            return cls.FLOAT
+        if isinstance(obj, Duration):
+            return cls.DURATION
+        raise exceptions.QpyError(
+            f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
+        )
+
+    @classmethod
+    def retrieve(cls, type_key):
+        raise NotImplementedError
+
+
+class CircuitDuration(TypeKeyBase):
+    """Type keys for the ``DURATION`` QPY item."""
+
+    DT = b"t"
+    NS = b"n"
+    US = b"u"
+    MS = b"m"
+    S = b"s"
+
+    @classmethod
+    def assign(cls, obj):
+        if isinstance(obj, Duration):
+            unit = obj.unit()
+            if unit == "dt":
+                return cls.DT
+            if unit == "ns":
+                return cls.NS
+            if unit == "us":
+                return cls.US
+            if unit == "ms":
+                return cls.MS
+            if unit == "s":
+                return cls.S
         raise exceptions.QpyError(
             f"Object type '{type(obj)}' is not supported in {cls.__name__} namespace."
         )

qiskit/quantum_info/analysis/distance.py

@@ -74,7 +74,9 @@ def hellinger_fidelity(dist_p: dict, dist_q: dict) -> float:
 
     Example:
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit import QuantumCircuit
             from qiskit.quantum_info.analysis import hellinger_fidelity

qiskit/quantum_info/operators/dihedral/dihedral.py

@@ -46,7 +46,9 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
      The phase polynomial is a polynomial of degree at most 3,
      in :math:`N` variables, whose coefficients are in the ring Z_8 with 8 elements.
 
-     .. code-block::
+     .. plot::
+        :include-source:
+        :nofigs:
 
          from qiskit import QuantumCircuit
          from qiskit.quantum_info import CNOTDihedral

qiskit/quantum_info/operators/operator.py

@@ -61,7 +61,9 @@ class Operator(LinearOp):
     :math:`|\psi\rangle=|0\rangle (\rho = |0\rangle\langle 0|)` changes it to the
     one state :math:`|\psi\rangle=|1\rangle (\rho = |1\rangle\langle 1|)`:
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         >>> import numpy as np
         >>> from qiskit.quantum_info import Operator
@@ -204,6 +206,8 @@ class Operator(LinearOp):
 
         Raises:
             ValueError: when an invalid output method is selected.
+            MissingOptionalLibrary: If SymPy isn't installed and ``'latex'`` or
+                ``'latex_source'`` is selected for ``output``.
 
         """
         # pylint: disable=cyclic-import
@@ -236,7 +240,7 @@ class Operator(LinearOp):
     def _ipython_display_(self):
         out = self.draw()
         if isinstance(out, str):
-            print(out)
+            print(out)  # pylint: disable=bad-builtin
         else:
             from IPython.display import display
 

qiskit/quantum_info/operators/symplectic/clifford.py

@@ -72,7 +72,9 @@ class Clifford(BaseOperator, AdjointMixin, Operation):
     be obtained by calling the :meth:`to_dict` method. This representation is
     also used if a Clifford object is printed as in the following example
 
-    .. code-block::
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit import QuantumCircuit
         from qiskit.quantum_info import Clifford

qiskit/quantum_info/operators/symplectic/pauli.py

@@ -142,7 +142,9 @@ class Pauli(BasePauli):
 
     For example
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit.quantum_info import Pauli
 
@@ -583,7 +585,7 @@ class Pauli(BasePauli):
             other (Pauli or Clifford or QuantumCircuit): The Clifford operator to evolve by.
             qargs (list): a list of qubits to apply the Clifford to.
             frame (string): ``'h'`` for Heisenberg (default) or ``'s'`` for
-            Schrödinger framework.
+                Schrödinger framework.
 
         Returns:
             Pauli: the Pauli :math:`C^\dagger.P.C` (Heisenberg picture)

qiskit/quantum_info/operators/symplectic/pauli_list.py

@@ -54,7 +54,10 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
 
     For example,
 
-    .. code-block::
+    .. plot::
+       :include-source:
+       :nofigs:
+       :context: reset
 
         import numpy as np
 
@@ -93,7 +96,10 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
     operator which accepts integer, lists, or slices for selecting subsets
     of PauliList. If integer is given, it returns Pauli not PauliList.
 
-    .. code-block::
+    .. plot::
+       :include-source:
+       :nofigs:
+       :context:
 
         pauli_list = PauliList(["XX", "ZZ", "IZ"])
         print("Integer: ", repr(pauli_list[1]))
@@ -542,7 +548,9 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
 
         Consider sorting all a random ordering of all 2-qubit Paulis
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from numpy.random import shuffle
             from qiskit.quantum_info.operators import PauliList
@@ -593,7 +601,9 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
 
         **Example**
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit.quantum_info.operators import PauliList
 
@@ -1214,7 +1224,9 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
             qubit_wise (bool): whether the commutation rule is applied to the whole operator,
                 or on a per-qubit basis.  For example:
 
-                .. code-block:: python
+                .. plot::
+                   :include-source:
+                   :nofigs:
 
                     >>> from qiskit.quantum_info import PauliList
                     >>> op = PauliList(["XX", "YY", "IZ", "ZZ"])

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -30,6 +30,7 @@ from qiskit._accelerate.sparse_pauli_op import (
     to_matrix_sparse,
     unordered_unique,
 )
+from qiskit._accelerate.sparse_observable import SparseObservable
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.parametertable import ParameterView
@@ -69,7 +70,9 @@ class SparsePauliOp(LinearOp):
     configure this by passing ``np.ndarray`` with a different dtype.  For example, a parameterized
     :class:`SparsePauliOp` can be made as follows:
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         >>> import numpy as np
         >>> from qiskit.circuit import ParameterVector
@@ -539,7 +542,9 @@ class SparsePauliOp(LinearOp):
 
         Here is an example of how to use SparsePauliOp argsort.
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             import numpy as np
             from qiskit.quantum_info import SparsePauliOp
@@ -608,7 +613,9 @@ class SparsePauliOp(LinearOp):
 
         Here is an example of how to use SparsePauliOp sort.
 
-        .. code-block::
+        .. plot::
+           :include-source:
+           :nofigs:
 
             import numpy as np
             from qiskit.quantum_info import SparsePauliOp
@@ -801,7 +808,9 @@ class SparsePauliOp(LinearOp):
 
         can be constructed as
 
-        .. code-block:: python
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit.quantum_info import SparsePauliOp
 
@@ -867,7 +876,9 @@ class SparsePauliOp(LinearOp):
 
         can be constructed as
 
-        .. code-block:: python
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit.quantum_info import SparsePauliOp
 
@@ -919,6 +930,27 @@ class SparsePauliOp(LinearOp):
         paulis = PauliList(labels)
         return SparsePauliOp(paulis, coeffs, copy=False)
 
+    @staticmethod
+    def from_sparse_observable(obs: SparseObservable) -> SparsePauliOp:
+        r"""Initialize from a :class:`.SparseObservable`.
+
+        .. warning::
+
+            A :class:`.SparseObservable` can efficiently represent eigenstate projectors
+            (such as :math:`|0\langle\rangle 0|`), but a :class:`.SparsePauliOp` **cannot**.
+            If the input ``obs`` has :math:`n` single-qubit projectors, the resulting
+            :class:`.SparsePauliOp` will use :math:`2^n` terms, which is an exponentially
+            expensive representation that can quickly run out of memory.
+
+        Args:
+            obs: The :class:`.SparseObservable` to convert.
+
+        Returns:
+            A :class:`.SparsePauliOp` version of the observable.
+        """
+        as_sparse_list = obs.as_paulis().to_sparse_list()
+        return SparsePauliOp.from_sparse_list(as_sparse_list, obs.num_qubits)
+
     def to_list(self, array: bool = False):
         """Convert to a list Pauli string labels and coefficients.
 
@@ -1072,7 +1104,9 @@ class SparsePauliOp(LinearOp):
             qubit_wise (bool): whether the commutation rule is applied to the whole operator,
                 or on a per-qubit basis.  For example:
 
-                .. code-block:: python
+                .. plot::
+                   :include-source:
+                   :nofigs:
 
                     >>> from qiskit.quantum_info import SparsePauliOp
                     >>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])

qiskit/quantum_info/states/densitymatrix.py

@@ -180,7 +180,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
     def _ipython_display_(self):
         out = self.draw()
         if isinstance(out, str):
-            print(out)
+            print(out)  # pylint: disable=bad-builtin
         else:
             from IPython.display import display
 
@@ -443,7 +443,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             with :math:`\\rho_1=|+\\rangle\\!\\langle+|`,
             :math:`\\rho_0=|0\\rangle\\!\\langle0|`.
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import DensityMatrix
 
@@ -470,7 +472,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             We can also permute the order of qubits in the ``qargs`` list
             to change the qubit position in the probabilities output
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import DensityMatrix
 
@@ -649,7 +653,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             The ket-form of a 2-qubit density matrix
             :math:`rho = |-\rangle\!\langle -|\otimes |0\rangle\!\langle 0|`
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import DensityMatrix
 
@@ -668,7 +674,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             For non-qubit subsystems the integer range can go from 0 to 9. For
             example in a qutrit system
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 import numpy as np
                 from qiskit.quantum_info import DensityMatrix
@@ -689,7 +697,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             following example is for a 20-dimensional system consisting of
             a qubit and 10-dimensional qudit.
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 import numpy as np
                 from qiskit.quantum_info import DensityMatrix