qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/quantum_info/operators/operator.py

@@ -16,6 +16,7 @@ Matrix Operator class.
 
 from __future__ import annotations
 
+import cmath
 import copy as _copy
 import re
 from numbers import Number
@@ -540,11 +541,41 @@ class Operator(LinearOp):
         ret._op_shape = new_shape
         return ret
 
-    def power(self, n: float) -> Operator:
+    def power(
+        self, n: float, branch_cut_rotation=cmath.pi * 1e-12, assume_unitary=False
+    ) -> Operator:
         """Return the matrix power of the operator.
 
+        Non-integer powers of operators with an eigenvalue whose complex phase is :math:`\\pi` have
+        a branch cut in the complex plane, which makes the calculation of the principal root around
+        this cut subject to precision / differences in BLAS implementation.  For example, the square
+        root of Pauli Y can return the :math:`\\pi/2` or :math:`-\\pi/2` Y rotation depending on
+        whether the -1 eigenvalue is found as ``complex(-1, tiny)`` or ``complex(-1, -tiny)``. Such
+        eigenvalues are really common in quantum information, so this function first phase-rotates
+        the input matrix to shift the branch cut to a far less common point.  The underlying
+        numerical precision issues around the branch-cut point remain, if an operator has an
+        eigenvalue close to this phase.  The magnitude of this rotation can be controlled with the
+        ``branch_cut_rotation`` parameter.
+
+        The choice of ``branch_cut_rotation`` affects the principal root that is found.  For
+        example, the square root of :class:`.ZGate` will be calculated as either :class:`.SGate` or
+        :class:`.SdgGate` depending on which way the rotation is done::
+
+            from qiskit.circuit import library
+            from qiskit.quantum_info import Operator
+
+            z_op = Operator(library.ZGate())
+            assert z_op.power(0.5, branch_cut_rotation=1e-3) == Operator(library.SGate())
+            assert z_op.power(0.5, branch_cut_rotation=-1e-3) == Operator(library.SdgGate())
+
         Args:
             n (float): the power to raise the matrix to.
+            branch_cut_rotation (float): The rotation angle to apply to the branch cut in the
+                complex plane.  This shifts the branch cut away from the common point of :math:`-1`,
+                but can cause a different root to be selected as the principal root.  The rotation
+                is anticlockwise, following the standard convention for complex phase.
+            assume_unitary (bool): if ``True``, the operator is assumed to be unitary. In this case,
+                for fractional powers we employ a faster implementation based on Schur's decomposition.
 
         Returns:
             Operator: the resulting operator ``O ** n``.
@@ -552,6 +583,11 @@ class Operator(LinearOp):
         Raises:
             QiskitError: if the input and output dimensions of the operator
                          are not equal.
+
+        .. note::
+            It is only safe to set the argument ``assume_unitary`` to ``True`` when the operator
+            is unitary (or, more generally, normal). Otherwise, the function will return an
+            incorrect output.
         """
         if self.input_dims() != self.output_dims():
             raise QiskitError("Can only power with input_dims = output_dims.")
@@ -561,13 +597,23 @@ class Operator(LinearOp):
         else:
             import scipy.linalg
 
-            # Experimentally, for fractional powers this seems to be 3x faster than
-            # calling scipy.linalg.fractional_matrix_power(self.data, n)
-            decomposition, unitary = scipy.linalg.schur(self.data, output="complex")
-            decomposition_diagonal = decomposition.diagonal()
-            decomposition_power = [pow(element, n) for element in decomposition_diagonal]
-            unitary_power = unitary @ np.diag(decomposition_power) @ unitary.conj().T
-            ret._data = unitary_power
+            if assume_unitary:
+                # Experimentally, for fractional powers this seems to be 3x faster than
+                # calling scipy.linalg.fractional_matrix_power(self.data, exponent)
+                decomposition, unitary = scipy.linalg.schur(
+                    cmath.rect(1, -branch_cut_rotation) * self.data, output="complex"
+                )
+                decomposition_diagonal = decomposition.diagonal()
+                decomposition_power = [pow(element, n) for element in decomposition_diagonal]
+                unitary_power = unitary @ np.diag(decomposition_power) @ unitary.conj().T
+                ret._data = cmath.rect(1, branch_cut_rotation * n) * unitary_power
+            else:
+                ret._data = cmath.rect(
+                    1, branch_cut_rotation * n
+                ) * scipy.linalg.fractional_matrix_power(
+                    cmath.rect(1, -branch_cut_rotation) * self.data, n
+                )
+
         return ret
 
     def tensor(self, other: Operator) -> Operator:

qiskit/quantum_info/operators/symplectic/base_pauli.py

@@ -33,6 +33,8 @@ if TYPE_CHECKING:
 
 # utility for _to_matrix
 _PARITY = np.array([-1 if bin(i).count("1") % 2 else 1 for i in range(256)], dtype=complex)
+# Utility for `_to_label`
+_TO_LABEL_CHARS = np.array([ord("I"), ord("X"), ord("Z"), ord("Y")], dtype=np.uint8)
 
 
 class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
@@ -184,7 +186,7 @@ class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
         return BasePauli(self._z, self._x, np.mod(self._phase + phase, 4))
 
     def conjugate(self):
-        """Return the conjugate of each Pauli in the list."""
+        """Return the complex conjugate of the Pauli with respect to the Z basis."""
         complex_phase = np.mod(self._phase, 2)
         if np.all(complex_phase == 0):
             return self
@@ -496,25 +498,15 @@ class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
                             the phase ``q`` for the coefficient :math:`(-i)^(q + x.z)`
                             for the label from the full Pauli group.
         """
-        num_qubits = z.size
-        phase = int(phase)
-        coeff_labels = {0: "", 1: "-i", 2: "-", 3: "i"}
-        label = ""
-        for i in range(num_qubits):
-            if not z[num_qubits - 1 - i]:
-                if not x[num_qubits - 1 - i]:
-                    label += "I"
-                else:
-                    label += "X"
-            elif not x[num_qubits - 1 - i]:
-                label += "Z"
-            else:
-                label += "Y"
-                if not group_phase:
-                    phase -= 1
-        phase %= 4
+        # Map each qubit to the {I: 0, X: 1, Z: 2, Y: 3} integer form, then use Numpy advanced
+        # indexing to get a new data buffer which is compatible with an ASCII string label.
+        index = z << 1
+        index += x
+        ascii_label = _TO_LABEL_CHARS[index[::-1]].data.tobytes()
+        phase = (int(phase) if group_phase else int(phase) - ascii_label.count(b"Y")) % 4
+        label = ascii_label.decode("ascii")
         if phase and full_group:
-            label = coeff_labels[phase] + label
+            label = ("", "-i", "-", "i")[phase] + label
         if return_phase:
             return label, phase
         return label

qiskit/quantum_info/operators/symplectic/clifford.py

@@ -92,7 +92,7 @@ class Clifford(BaseOperator, AdjointMixin, Operation):
         # Print the Clifford stabilizer rows
         print(cliff.to_labels(mode="S"))
 
-    .. parsed-literal::
+    .. code-block:: text
 
         Clifford: Stabilizer = ['+XX', '+ZZ'], Destabilizer = ['+IZ', '+XI']
         ['+IZ', '+XI']

qiskit/quantum_info/operators/symplectic/clifford_circuits.py

@@ -81,7 +81,7 @@ def _append_operation(clifford, operation, qargs=None):
     else:
         # assert isinstance(gate, Instruction)
         name = gate.name
-        if getattr(gate, "condition", None) is not None:
+        if getattr(gate, "_condition", None) is not None:
             raise QiskitError("Conditional gate is not a valid Clifford operation.")
 
     # Apply gate if it is a Clifford basis gate

qiskit/quantum_info/operators/symplectic/pauli.py

@@ -144,6 +144,8 @@ class Pauli(BasePauli):
 
     .. code-block:: python
 
+        from qiskit.quantum_info import Pauli
+
         P = Pauli('-iXYZ')
 
         print('P[0] =', repr(P[0]))

qiskit/quantum_info/operators/symplectic/pauli_list.py

@@ -80,7 +80,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         pauli_list = PauliList.from_symplectic(z, x, phase)
         print("4. ", pauli_list)
 
-    .. parsed-literal::
+    .. code-block:: text
 
         1.  ['II', 'ZI', '-iYY']
         2.  ['iXI']
@@ -100,7 +100,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         print("List: ", repr(pauli_list[[0, 2]]))
         print("Slice: ", repr(pauli_list[0:2]))
 
-    .. parsed-literal::
+    .. code-block:: text
 
         Integer:  Pauli('ZZ')
         List:  PauliList(['XX', 'IZ'])
@@ -568,7 +568,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
             print('Weight sorted')
             print(srt)
 
-        .. parsed-literal::
+        .. code-block:: text
 
             Initial Ordering
             ['YX', 'ZZ', 'XZ', 'YI', 'YZ', 'II', 'XX', 'XI', 'XY', 'YY', 'IX', 'IZ',
@@ -603,7 +603,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
             unique = pt.unique()
             print(unique)
 
-        .. parsed-literal::
+        .. code-block:: text
 
             ['X', 'Y', '-X', 'I', 'Z', 'iZ']
 

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -560,7 +560,7 @@ class SparsePauliOp(LinearOp):
             print('Weight sorted')
             print(srt)
 
-        .. parsed-literal::
+        .. code-block:: text
 
             Initial Ordering
             SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
@@ -629,7 +629,7 @@ class SparsePauliOp(LinearOp):
             print('Weight sorted')
             print(srt)
 
-        .. parsed-literal::
+        .. code-block:: text
 
             Initial Ordering
             SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
@@ -794,6 +794,8 @@ class SparsePauliOp(LinearOp):
 
         .. code-block:: python
 
+            from qiskit.quantum_info import SparsePauliOp
+
             # via tuples and the full Pauli string
             op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])
 
@@ -858,6 +860,8 @@ class SparsePauliOp(LinearOp):
 
         .. code-block:: python
 
+            from qiskit.quantum_info import SparsePauliOp
+
             # via triples and local Paulis with indices
             op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)
 
@@ -931,6 +935,14 @@ class SparsePauliOp(LinearOp):
             return labels
         return labels.tolist()
 
+    def to_sparse_list(self):
+        """Convert to a sparse Pauli list format with elements (pauli, qubits, coefficient)."""
+        pauli_labels = self.paulis.to_labels()
+        sparse_list = [
+            (*sparsify_label(label), coeff) for label, coeff in zip(pauli_labels, self.coeffs)
+        ]
+        return sparse_list
+
     def to_matrix(self, sparse: bool = False, force_serial: bool = False) -> np.ndarray:
         """Convert to a dense or sparse matrix.
 
@@ -1053,6 +1065,7 @@ class SparsePauliOp(LinearOp):
 
                 .. code-block:: python
 
+                    >>> from qiskit.quantum_info import SparsePauliOp
                     >>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
                     >>> op.group_commuting()
                     [SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),
@@ -1171,5 +1184,13 @@ class SparsePauliOp(LinearOp):
         return new_op.compose(self, qargs=layout)
 
 
+def sparsify_label(pauli_string):
+    """Return a sparse format of a Pauli string, e.g. "XIIIZ" -> ("XZ", [0, 4])."""
+    qubits = [i for i, label in enumerate(reversed(pauli_string)) if label != "I"]
+    sparse_label = "".join(pauli_string[~i] for i in qubits)
+
+    return sparse_label, qubits
+
+
 # Update docstrings for API docs
 generate_apidocs(SparsePauliOp)

qiskit/quantum_info/states/densitymatrix.py

@@ -461,7 +461,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
                 probs_qubit_1 = rho.probabilities([1])
                 print('Qubit-1 probs: {}'.format(probs_qubit_1))
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 probs: [0.5 0.  0.5 0. ]
                 Qubit-0 probs: [1. 0.]
@@ -485,7 +485,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
                 probs_swapped = rho.probabilities([1, 0])
                 print('Swapped probs: {}'.format(probs_swapped))
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 probs: [0.5 0.  0.5 0. ]
                 Swapped probs: [0.5 0.5 0.  0. ]
@@ -654,7 +654,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
                 rho = DensityMatrix.from_label('-0')
                 print(rho.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                {
                    '00|00': (0.4999999999999999+0j),
@@ -679,7 +679,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
                 rho = DensityMatrix(mat, dims=(3, 3))
                 print(rho.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 {'00|00': (0.25+0j), '10|10': (0.25+0j), '20|20': (0.25+0j), '22|22': (0.25+0j)}
 
@@ -698,7 +698,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
                 rho = DensityMatrix(mat, dims=(2, 10))
                 print(rho.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 {'00|00': (0.5+0j), '91|91': (0.5+0j)}
         """

qiskit/quantum_info/states/stabilizerstate.py

@@ -54,7 +54,7 @@ class StabilizerState(QuantumState):
         # Calculate expectation value of the StabilizerState
         print (stab.expectation_value(Pauli('ZZ')))
 
-    .. parsed-literal::
+    .. code-block:: text
 
         StabilizerState(StabilizerTable: ['+XX', '+ZZ'])
         {'00': 0.5, '11': 0.5}

qiskit/quantum_info/states/statevector.py

@@ -476,7 +476,7 @@ class Statevector(QuantumState, TolerancesMixin):
         pauli_phase = (-1j) ** pauli.phase if pauli.phase else 1
 
         if x_mask + z_mask == 0:
-            return pauli_phase * np.linalg.norm(self.data)
+            return pauli_phase * np.linalg.norm(self.data) ** 2
 
         if x_mask == 0:
             return pauli_phase * expval_pauli_no_x(self.data, self.num_qubits, z_mask)
@@ -554,7 +554,7 @@ class Statevector(QuantumState, TolerancesMixin):
                 probs_qubit_1 = psi.probabilities([1])
                 print('Qubit-1 probs: {}'.format(probs_qubit_1))
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 probs: [0.5 0.  0.5 0. ]
                 Qubit-0 probs: [1. 0.]
@@ -578,7 +578,7 @@ class Statevector(QuantumState, TolerancesMixin):
                 probs_swapped = psi.probabilities([1, 0])
                 print('Swapped probs: {}'.format(probs_swapped))
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 probs: [0.5 0.  0.5 0. ]
                 Swapped probs: [0.5 0.5 0.  0. ]
@@ -794,7 +794,7 @@ class Statevector(QuantumState, TolerancesMixin):
                 psi = Statevector.from_label('-0')
                 print(psi.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 {'00': (0.7071067811865475+0j), '10': (-0.7071067811865475+0j)}
 
@@ -812,7 +812,7 @@ class Statevector(QuantumState, TolerancesMixin):
                 psi = Statevector(vec, dims=(3, 3))
                 print(psi.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 {'00': (0.7071067811865475+0j), '22': (0.7071067811865475+0j)}
 
@@ -831,7 +831,7 @@ class Statevector(QuantumState, TolerancesMixin):
                 psi = Statevector(vec, dims=(2, 10))
                 print(psi.to_dict())
 
-            .. parsed-literal::
+            .. code-block:: text
 
                 {'00': (0.7071067811865475+0j), '91': (0.7071067811865475+0j)}
 

qiskit/result/mitigation/base_readout_mitigator.py

@@ -21,7 +21,7 @@ from ..counts import Counts
 
 
 class BaseReadoutMitigator(ABC):
-    """Base readout error mitigator class."""
+    """This class is DEPRECATED. Base readout error mitigator class."""
 
     @abstractmethod
     def quasi_probabilities(

qiskit/result/mitigation/correlated_readout_mitigator.py

@@ -18,6 +18,7 @@ from typing import Optional, List, Tuple, Iterable, Callable, Union, Dict
 import numpy as np
 
 from qiskit.exceptions import QiskitError
+from qiskit.utils.deprecation import deprecate_func
 from ..distributions.quasi import QuasiDistribution
 from ..counts import Counts
 from .base_readout_mitigator import BaseReadoutMitigator
@@ -25,7 +26,7 @@ from .utils import counts_probability_vector, z_diagonal, str2diag
 
 
 class CorrelatedReadoutMitigator(BaseReadoutMitigator):
-    """N-qubit readout error mitigator.
+    """This class is DEPRECATED. N-qubit readout error mitigator.
 
     Mitigates :meth:`expectation_value` and :meth:`quasi_probabilities`.
     The mitigation_matrix should be calibrated using qiskit experiments.
@@ -34,6 +35,13 @@ class CorrelatedReadoutMitigator(BaseReadoutMitigator):
     :math:`2^N x 2^N` so the mitigation complexity is :math:`O(4^N)`.
     """
 
+    @deprecate_func(
+        since="1.3",
+        package_name="Qiskit",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+        "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+    )
     def __init__(self, assignment_matrix: np.ndarray, qubits: Optional[Iterable[int]] = None):
         """Initialize a CorrelatedReadoutMitigator
 

qiskit/result/mitigation/local_readout_mitigator.py

@@ -19,6 +19,7 @@ from typing import Optional, List, Tuple, Iterable, Callable, Union, Dict
 import numpy as np
 
 from qiskit.exceptions import QiskitError
+from qiskit.utils.deprecation import deprecate_func
 from ..distributions.quasi import QuasiDistribution
 from ..counts import Counts
 from .base_readout_mitigator import BaseReadoutMitigator
@@ -26,7 +27,7 @@ from .utils import counts_probability_vector, z_diagonal, str2diag
 
 
 class LocalReadoutMitigator(BaseReadoutMitigator):
-    """1-qubit tensor product readout error mitigator.
+    """This class is DEPRECATED. 1-qubit tensor product readout error mitigator.
 
     Mitigates :meth:`expectation_value` and :meth:`quasi_probabilities`.
     The mitigator should either be calibrated using qiskit experiments,
@@ -37,6 +38,13 @@ class LocalReadoutMitigator(BaseReadoutMitigator):
     so it is more efficient than the :class:`CorrelatedReadoutMitigator` class.
     """
 
+    @deprecate_func(
+        since="1.3",
+        package_name="Qiskit",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+        "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+    )
     def __init__(
         self,
         assignment_matrices: Optional[List[np.ndarray]] = None,

qiskit/result/mitigation/utils.py

@@ -19,12 +19,20 @@ from typing import Optional, List, Tuple, Dict
 import numpy as np
 
 from qiskit.exceptions import QiskitError
+from qiskit.utils.deprecation import deprecate_func
 from ..utils import marginal_counts
 from ..counts import Counts
 
 logger = logging.getLogger(__name__)
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def z_diagonal(dim, dtype=float):
     r"""Return the diagonal for the operator :math:`Z^\otimes n`"""
     parity = np.zeros(dim, dtype=dtype)
@@ -33,6 +41,13 @@ def z_diagonal(dim, dtype=float):
     return (-1) ** np.mod(parity, 2)
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def expval_with_stddev(coeffs: np.ndarray, probs: np.ndarray, shots: int) -> Tuple[float, float]:
     """Compute expectation value and standard deviation.
     Args:
@@ -60,6 +75,13 @@ def expval_with_stddev(coeffs: np.ndarray, probs: np.ndarray, shots: int) -> Tup
     return [expval, calc_stddev]
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def stddev(probs, shots):
     """Calculate stddev dict"""
     ret = {}
@@ -69,6 +91,13 @@ def stddev(probs, shots):
     return ret
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def str2diag(string):
     """Transform diagonal from a string to a numpy array"""
     chars = {
@@ -85,6 +114,13 @@ def str2diag(string):
     return ret
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def counts_to_vector(counts: Counts, num_qubits: int) -> Tuple[np.ndarray, int]:
     """Transforms Counts to a probability vector"""
     vec = np.zeros(2**num_qubits, dtype=float)
@@ -96,6 +132,13 @@ def counts_to_vector(counts: Counts, num_qubits: int) -> Tuple[np.ndarray, int]:
     return vec, shots
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def remap_qubits(
     vec: np.ndarray, num_qubits: int, qubits: Optional[List[int]] = None
 ) -> np.ndarray:
@@ -108,6 +151,13 @@ def remap_qubits(
     return vec
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def marganalize_counts(
     counts: Counts,
     qubit_index: Dict[int, int],
@@ -129,6 +179,13 @@ def marganalize_counts(
     return counts
 
 
+@deprecate_func(
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `qiskit.result.mitigation` module is deprecated in favor of "
+    "the https://github.com/Qiskit/qiskit-addon-mthree package.",
+)
 def counts_probability_vector(
     counts: Counts,
     qubit_index: Dict[int, int],

qiskit/scheduler/config.py

@@ -16,11 +16,13 @@ from typing import List
 
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.pulse.utils import format_meas_map
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class ScheduleConfig:
     """Configuration for pulse scheduling."""
 
+    @deprecate_pulse_dependency(moving_to_dynamics=True)
     def __init__(self, inst_map: InstructionScheduleMap, meas_map: List[List[int]], dt: float):
         """
         Container for information needed to schedule a QuantumCircuit into a pulse Schedule.

qiskit/scheduler/methods/basic.py

@@ -23,8 +23,10 @@ from qiskit.pulse.schedule import Schedule
 from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.lowering import lower_gates
 from qiskit.providers import BackendV1, BackendV2
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def as_soon_as_possible(
     circuit: QuantumCircuit,
     schedule_config: ScheduleConfig,
@@ -78,6 +80,7 @@ def as_soon_as_possible(
     return schedule
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def as_late_as_possible(
     circuit: QuantumCircuit,
     schedule_config: ScheduleConfig,

qiskit/scheduler/schedule_circuit.py

@@ -20,8 +20,10 @@ from qiskit.pulse.schedule import Schedule
 from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.methods import as_soon_as_possible, as_late_as_possible
 from qiskit.providers import BackendV1, BackendV2
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def schedule_circuit(
     circuit: QuantumCircuit,
     schedule_config: ScheduleConfig,

qiskit/scheduler/sequence.py

@@ -25,8 +25,10 @@ from qiskit.pulse.transforms import pad
 from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.lowering import lower_gates
 from qiskit.providers import BackendV1, BackendV2
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def sequence(
     scheduled_circuit: QuantumCircuit,
     schedule_config: ScheduleConfig,