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

qiskit/primitives/base/{base_primitive.py → base_primitive_v1.py}

@@ -19,7 +19,7 @@ from abc import ABC
 from qiskit.providers import Options
 
 
-class BasePrimitive(ABC):
+class BasePrimitiveV1(ABC):
     """Primitive V1 abstract base class."""
 
     def __init__(self, options: dict | None = None):

qiskit/primitives/base/{base_result.py → base_result_v1.py}

@@ -25,7 +25,7 @@ from numpy import ndarray
 ExperimentData = Dict[str, Any]
 
 
-class _BasePrimitiveResult(ABC):
+class _BasePrimitiveResultV1(ABC):
     """
     Base class for deprecated Primitive V1 result methods.
     """

qiskit/primitives/base/base_sampler.py

@@ -21,19 +21,60 @@ from typing import Generic, TypeVar
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.providers import JobV1 as Job
-from qiskit.utils.deprecation import deprecate_func
 
 from ..containers.primitive_result import PrimitiveResult
 from ..containers.sampler_pub import SamplerPubLike
 from ..containers.sampler_pub_result import SamplerPubResult
-from . import validation
-from .base_primitive import BasePrimitive
+from .validation_v1 import _validate_sampler_args
+from .base_primitive_v1 import BasePrimitiveV1
 from .base_primitive_job import BasePrimitiveJob
 
 T = TypeVar("T", bound=Job)
 
 
-class BaseSamplerV1(BasePrimitive, Generic[T]):
+class BaseSamplerV2(ABC):
+    r"""Base class for ``SamplerV2`` implementations.
+
+    A Sampler returns samples of quantum circuit outputs. Implementations of this
+    :class:`.BaseSamplerV2` interface must define their own :meth:`.run` method,
+    which is designed to take the following inputs:
+
+     * pubs: list of pubs (Primitive Unified Blocs). A sampler pub is a list or tuple
+        of two to three elements that define the unit of work for the sampler. These are:
+
+            * A single :class:`~qiskit.circuit.QuantumCircuit`, possibly parameterized.
+
+            * A collection parameter value sets to bind the circuit against if it is parametric.
+
+            * Optionally, the number of shots to sample.
+
+     * shots: the number of shots to sample. This specification is optional and will be overriden by
+        the pub-wise shots if provided.
+
+    All sampler implementations must implement default value for the ``shots`` in the
+    :meth:`.run` method. This default value will be used any time ``shots=None`` is specified, which
+    can take place in the :meth:`.run` kwargs or at the pub level.
+    """
+
+    @abstractmethod
+    def run(
+        self, pubs: Iterable[SamplerPubLike], *, shots: int | None = None
+    ) -> BasePrimitiveJob[PrimitiveResult[SamplerPubResult]]:
+        """Run and collect samples from each pub.
+
+        Args:
+            pubs: An iterable of pub-like objects. For example, a list of circuits
+                  or tuples ``(circuit, parameter_values)``.
+            shots: The total number of shots to sample for each sampler pub that does
+                   not specify its own shots. If ``None``, the primitive's default
+                   shots value will be used, which can vary by implementation.
+
+        Returns:
+            The job object of Sampler's result.
+        """
+
+
+class BaseSamplerV1(BasePrimitiveV1, Generic[T]):
     r"""Sampler V1 base class
 
     Base class of Sampler that calculates quasi-probabilities of bitstrings from quantum circuits.
@@ -58,7 +99,9 @@ class BaseSamplerV1(BasePrimitive, Generic[T]):
 
     .. code-block:: python
 
-        from qiskit.primitives import Sampler
+        # This is a fictional import path.
+        # There are currently no Sampler implementations in Qiskit.
+        from sampler_v1_location import SamplerV1
         from qiskit import QuantumCircuit
         from qiskit.circuit.library import RealAmplitudes
 
@@ -103,6 +146,8 @@ class BaseSamplerV1(BasePrimitive, Generic[T]):
         options: dict | None = None,
     ):
         """
+        Initialize ``SamplerV1``.
+
         Args:
             options: Default options.
         """
@@ -129,7 +174,7 @@ class BaseSamplerV1(BasePrimitive, Generic[T]):
             ValueError: Invalid arguments are given.
         """
         # Validation
-        circuits, parameter_values = validation._validate_sampler_args(circuits, parameter_values)
+        circuits, parameter_values = _validate_sampler_args(circuits, parameter_values)
 
         # Options
         run_opts = copy(self.options)
@@ -148,57 +193,4 @@ class BaseSamplerV1(BasePrimitive, Generic[T]):
         parameter_values: tuple[tuple[float, ...], ...],
         **run_options,
     ) -> T:
-        raise NotImplementedError("The subclass of BaseSampler must implement `_run` method.")
-
-
-class BaseSampler(BaseSamplerV1[T]):
-    """DEPRECATED. Type alias for Sampler V1 base class
-
-    See :class:`.BaseSamplerV1` for details.
-    """
-
-    @deprecate_func(
-        since="1.2",
-        additional_msg="The `BaseSampler` class is a type alias for the `BaseSamplerV1` "
-        "interface that has been deprecated in favor of explicitly versioned interface classes. "
-        "It is recommended to migrate all implementations to use `BaseSamplerV2`. "
-        "However, for implementations incompatible with `BaseSamplerV2`, `BaseSampler` can "
-        "be replaced with the explicitly versioned `BaseSamplerV1` class.",
-    )
-    def __init__(
-        self,
-        *,
-        options: dict | None = None,
-    ):
-        """
-        Args:
-            options: Default options.
-        """
-        super().__init__(options=options)
-
-
-class BaseSamplerV2(ABC):
-    r"""Sampler V2 base class.
-
-    A Sampler returns samples of quantum circuit outputs.
-
-    All sampler implementations must implement default value for the ``shots`` in the
-    :meth:`.run` method if ``None`` is given both as a ``kwarg`` and in all of the pubs.
-    """
-
-    @abstractmethod
-    def run(
-        self, pubs: Iterable[SamplerPubLike], *, shots: int | None = None
-    ) -> BasePrimitiveJob[PrimitiveResult[SamplerPubResult]]:
-        """Run and collect samples from each pub.
-
-        Args:
-            pubs: An iterable of pub-like objects. For example, a list of circuits
-                  or tuples ``(circuit, parameter_values)``.
-            shots: The total number of shots to sample for each sampler pub that does
-                   not specify its own shots. If ``None``, the primitive's default
-                   shots value will be used, which can vary by implementation.
-
-        Returns:
-            The job object of Sampler's result.
-        """
+        raise NotImplementedError("The subclass of BaseSamplerV1 must implement `_run` method.")

qiskit/primitives/base/{estimator_result.py → estimator_result_v1.py}

@@ -18,14 +18,14 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from .base_result import _BasePrimitiveResult
+from .base_result_v1 import _BasePrimitiveResultV1
 
 if TYPE_CHECKING:
     import numpy as np
 
 
 @dataclass(frozen=True)
-class EstimatorResult(_BasePrimitiveResult):
+class EstimatorResult(_BasePrimitiveResultV1):
     """Result of Estimator V1.
 
     .. code-block:: python

qiskit/primitives/base/{sampler_result.py → sampler_result_v1.py}

@@ -20,11 +20,11 @@ from typing import Any
 
 from qiskit.result import QuasiDistribution
 
-from .base_result import _BasePrimitiveResult
+from .base_result_v1 import _BasePrimitiveResultV1
 
 
 @dataclass(frozen=True)
-class SamplerResult(_BasePrimitiveResult):
+class SamplerResult(_BasePrimitiveResultV1):
     """Result of Sampler V1.
 
     .. code-block:: python

qiskit/primitives/base/{validation.py → validation_v1.py}

@@ -10,34 +10,30 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Primitive validation methods.
+"""Primitive V1 validation methods.
 
 Note that these are not intended to be part of the public API of base primitives
-but are here for backwards compatibility with deprecated functions.
+but are here for backward compatibility with BaseSamplerV1 and BaseEstimatorV1 classes.
 """
 
 from __future__ import annotations
 
 from collections.abc import Sequence
-import typing
 import numpy as np
 
 from qiskit.circuit import QuantumCircuit, ControlFlowOp, Measure
-from qiskit.quantum_info.operators import SparsePauliOp
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import PauliList, SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
-
-from ..utils import init_observable
-
-if typing.TYPE_CHECKING:
-    from qiskit.opflow import PauliSumOp
+from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli
 
 
 def _validate_estimator_args(
     circuits: Sequence[QuantumCircuit] | QuantumCircuit,
-    observables: Sequence[BaseOperator | PauliSumOp | str] | BaseOperator | PauliSumOp | str,
+    observables: Sequence[BaseOperator | str] | BaseOperator | str,
     parameter_values: Sequence[Sequence[float]] | Sequence[float] | float | None = None,
 ) -> tuple[tuple[QuantumCircuit], tuple[BaseOperator], tuple[tuple[float]]]:
-    """Validate run arguments for a reference Estimator.
+    """Validate run arguments for BaseEstimatorV1.
 
     Args:
         circuits: one or more circuit objects.
@@ -70,7 +66,7 @@ def _validate_sampler_args(
     circuits: Sequence[QuantumCircuit] | QuantumCircuit,
     parameter_values: Sequence[Sequence[float]] | Sequence[float] | float | None = None,
 ) -> tuple[tuple[QuantumCircuit], tuple[BaseOperator], tuple[tuple[float]]]:
-    """Validate run arguments for a reference Sampler.
+    """Validate run arguments for BaseSamplerV1.
 
     Args:
         circuits: one or more circuit objects.
@@ -96,6 +92,29 @@ def _validate_sampler_args(
     return circuits, parameter_values
 
 
+def _init_observable(observable: BaseOperator | str) -> SparsePauliOp:
+    """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`.
+
+    Args:
+        observable: The observable.
+
+    Returns:
+        The observable as :class:`~qiskit.quantum_info.SparsePauliOp`.
+
+    Raises:
+        QiskitError: when observable type cannot be converted to SparsePauliOp.
+    """
+
+    if isinstance(observable, SparsePauliOp):
+        return observable
+    elif isinstance(observable, BaseOperator) and not isinstance(observable, BasePauli):
+        raise QiskitError(f"observable type not supported: {type(observable)}")
+    else:
+        if isinstance(observable, PauliList):
+            raise QiskitError(f"observable type not supported: {type(observable)}")
+        return SparsePauliOp(observable)
+
+
 def _validate_circuits(
     circuits: Sequence[QuantumCircuit] | QuantumCircuit,
     requires_measure: bool = False,
@@ -166,13 +185,13 @@ def _validate_parameter_values(
 
 
 def _validate_observables(
-    observables: Sequence[BaseOperator | PauliSumOp | str] | BaseOperator | PauliSumOp | str,
+    observables: Sequence[BaseOperator | str] | BaseOperator | str,
 ) -> tuple[SparsePauliOp, ...]:
     if isinstance(observables, str) or not isinstance(observables, Sequence):
         observables = (observables,)
     if len(observables) == 0:
         raise ValueError("No observables were provided.")
-    return tuple(init_observable(obs) for obs in observables)
+    return tuple(_init_observable(obs) for obs in observables)
 
 
 def _cross_validate_circuits_parameter_values(
@@ -192,7 +211,7 @@ def _cross_validate_circuits_parameter_values(
 
 
 def _cross_validate_circuits_observables(
-    circuits: tuple[QuantumCircuit, ...], observables: tuple[BaseOperator | PauliSumOp, ...]
+    circuits: tuple[QuantumCircuit, ...], observables: tuple[BaseOperator, ...]
 ) -> None:
     if len(circuits) != len(observables):
         raise ValueError(

qiskit/primitives/containers/bindings_array.py

@@ -67,7 +67,9 @@ class BindingsArray(ShapedMixin):
     allows flexibility about whether values for different parameters are stored in one big array, or
     across several smaller arrays.
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         # 0-d array (i.e. only one binding)
         BindingsArray({"a": 4, ("b", "c"): [5, 6]})

qiskit/primitives/containers/bit_array.py

@@ -314,6 +314,29 @@ class BitArray(ShapedMixin):
         array = np.frombuffer(data, dtype=np.uint8, count=len(data))
         return BitArray(array.reshape(-1, num_bytes), num_bits)
 
+    def to_bool_array(self, order: Literal["big", "little"] = "big") -> NDArray[np.bool_]:
+        """Convert this :class:`~BitArray` to a boolean array.
+
+        Args:
+            order: One of ``"big"`` or ``"little"``, respectively indicating whether the most significant
+                bit or the least significant bit of each bitstring should be placed at ``[..., 0]``.
+
+        Returns:
+            A NumPy array of bools.
+
+        Raises:
+            ValueError: If the order is not one of ``"big"`` or ``"little"``.
+        """
+        if order not in ("big", "little"):
+            raise ValueError(
+                f"Invalid value for order: '{order}'. Valid values are 'big' and 'little'."
+            )
+
+        arr = np.unpackbits(self.array, axis=-1)[..., -self.num_bits :]
+        if order == "little":
+            arr = arr[..., ::-1]
+        return arr.astype(np.bool_)
+
     def get_counts(self, loc: int | tuple[int, ...] | None = None) -> dict[str, int]:
         """Return a counts dictionary with bitstring keys.
 

qiskit/primitives/containers/data_bin.py

@@ -32,7 +32,9 @@ def _value_repr(value: Any) -> str:
 class DataBin(ShapedMixin):
     """Namespace for storing data.
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         import numpy as np
         from qiskit.primitives import DataBin, BitArray

qiskit/primitives/containers/observables_array.py

@@ -97,8 +97,25 @@ class ObservablesArray(ShapedMixin):
         array = np.array2string(self._array, prefix=prefix, suffix=suffix, threshold=50)
         return prefix + array + suffix
 
-    def tolist(self) -> list:
-        """Convert to a nested list"""
+    def tolist(self) -> list | ObservableLike:
+        """Convert to a nested list.
+
+        Similar to Numpy's ``tolist`` method, the level of nesting
+        depends on the dimension of the observables array. In the
+        case of dimension 0 the method returns a single observable
+        (``dict`` in the case of a weighted sum of Paulis) instead of a list.
+
+        Examples::
+            Return values for a one-element list vs one element:
+
+                >>> from qiskit.primitives.containers.observables_array import ObservablesArray
+                >>> oa = ObservablesArray.coerce(["Z"])
+                >>> print(type(oa.tolist()))
+                <class 'list'>
+                >>> oa = ObservablesArray.coerce("Z")
+                >>> print(type(oa.tolist()))
+                <class 'dict'>
+        """
         return self._array.tolist()
 
     def __array__(self, dtype=None, copy=None):

qiskit/primitives/statevector_sampler.py

@@ -23,11 +23,10 @@ import numpy as np
 from numpy.typing import NDArray
 
 from qiskit import ClassicalRegister, QiskitError, QuantumCircuit
-from qiskit.circuit import ControlFlowOp
 from qiskit.quantum_info import Statevector
 
 from .base import BaseSamplerV2
-from .base.validation import _has_measure
+from .base.validation_v1 import _has_measure
 from .containers import (
     BitArray,
     DataBin,
@@ -64,7 +63,9 @@ class StatevectorSampler(BaseSamplerV2):
     primitive unified bloc (PUB), produces its own array-valued result. The :meth:`~run` method can
     be given many pubs at once.
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit.circuit import (
             Parameter, QuantumCircuit, ClassicalRegister, QuantumRegister
@@ -210,7 +211,7 @@ def _preprocess_circuit(circuit: QuantumCircuit):
     qargs_index = {v: k for k, v in enumerate(qargs)}
     circuit = circuit.remove_final_measurements(inplace=False)
     if _has_control_flow(circuit):
-        raise QiskitError("StatevectorSampler cannot handle ControlFlowOp and c_if")
+        raise QiskitError("StatevectorSampler cannot handle ControlFlowOp")
     if _has_measure(circuit):
         raise QiskitError("StatevectorSampler cannot handle mid-circuit measurements")
     # num_qubits is used as sentinel to fill 0 in _samples_to_packed_array
@@ -286,7 +287,4 @@ def _final_measurement_mapping(circuit: QuantumCircuit) -> dict[tuple[ClassicalR
 
 
 def _has_control_flow(circuit: QuantumCircuit) -> bool:
-    return any(
-        isinstance((op := instruction.operation), ControlFlowOp) or op._condition
-        for instruction in circuit
-    )
+    return any(instruction.is_control_flow() for instruction in circuit)

qiskit/primitives/utils.py

@@ -14,185 +14,30 @@ Utility functions for primitives
 """
 from __future__ import annotations
 
-from collections.abc import Iterable
-
 import numpy as np
 
 from qiskit.circuit import Instruction, QuantumCircuit
-from qiskit.circuit.bit import Bit
-from qiskit.circuit.library.data_preparation import Initialize
-from qiskit.exceptions import QiskitError
-from qiskit.quantum_info import PauliList, SparsePauliOp, Statevector
-from qiskit.quantum_info.operators.base_operator import BaseOperator
-from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli
-from qiskit.utils.deprecation import deprecate_func
-
-
-@deprecate_func(
-    since="1.2",
-    additional_msg="To initialize a circuit from a ``Statevector`` instance, "
-    + "use ``QuantumCircuit.initialize`` instead.",
-)
-def init_circuit(state: QuantumCircuit | Statevector) -> QuantumCircuit:
-    """Initialize state by converting the input to a quantum circuit.
-
-    Args:
-        state: The state as quantum circuit or statevector.
-
-    Returns:
-        The state as quantum circuit.
-    """
-    if isinstance(state, QuantumCircuit):
-        return state
-    if not isinstance(state, Statevector):
-        state = Statevector(state)
-    qc = QuantumCircuit(state.num_qubits)
-    qc.append(Initialize(state), qargs=range(state.num_qubits))
-    return qc
-
-
-@deprecate_func(
-    since="1.2",
-    additional_msg="Use the constructor of ``SparsePauliOp`` instead.",
-)
-def init_observable(observable: BaseOperator | str) -> SparsePauliOp:
-    """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`.
-
-    Args:
-        observable: The observable.
-
-    Returns:
-        The observable as :class:`~qiskit.quantum_info.SparsePauliOp`.
-
-    Raises:
-        QiskitError: when observable type cannot be converted to SparsePauliOp.
-    """
-
-    if isinstance(observable, SparsePauliOp):
-        return observable
-    elif isinstance(observable, BaseOperator) and not isinstance(observable, BasePauli):
-        raise QiskitError(f"observable type not supported: {type(observable)}")
-    else:
-        if isinstance(observable, PauliList):
-            raise QiskitError(f"observable type not supported: {type(observable)}")
-        return SparsePauliOp(observable)
-
-
-@deprecate_func(
-    since="1.2",
-    additional_msg="Use ``QuantumCircuit.layout`` and ``SparsePauliOp.apply_layout`` "
-    + "to adjust an operator for a layout. Otherwise, use ``mthree.utils.final_measurement_mapping``. "
-    + "See <https://qiskit.github.io/qiskit-addon-mthree/apidocs/utils> for details.",
-)
-def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]:
-    """Return the final measurement mapping for the circuit.
+from qiskit.quantum_info import Statevector
 
-    Dict keys label measured qubits, whereas the values indicate the
-    classical bit onto which that qubits measurement result is stored.
 
-    Parameters:
-        circuit: Input quantum circuit.
-
-    Returns:
-        Mapping of qubits to classical bits for final measurements.
-    """
-    active_qubits = list(range(circuit.num_qubits))
-    active_cbits = list(range(circuit.num_clbits))
-
-    # Find final measurements starting in back
-    mapping = {}
-    for item in circuit._data[::-1]:
-        if item.operation.name == "measure":
-            cbit = circuit.find_bit(item.clbits[0]).index
-            qbit = circuit.find_bit(item.qubits[0]).index
-            if cbit in active_cbits and qbit in active_qubits:
-                mapping[qbit] = cbit
-                active_cbits.remove(cbit)
-                active_qubits.remove(qbit)
-        elif item.operation.name not in ["barrier", "delay"]:
-            for qq in item.qubits:
-                _temp_qubit = circuit.find_bit(qq).index
-                if _temp_qubit in active_qubits:
-                    active_qubits.remove(_temp_qubit)
-
-        if not active_cbits or not active_qubits:
-            break
-
-    # Sort so that classical bits are in numeric order low->high.
-    mapping = dict(sorted(mapping.items(), key=lambda item: item[1]))
-    return mapping
-
-
-def _bits_key(bits: tuple[Bit, ...], circuit: QuantumCircuit) -> tuple:
-    return tuple(
-        (
-            circuit.find_bit(bit).index,
-            tuple((reg[0].size, reg[0].name, reg[1]) for reg in circuit.find_bit(bit).registers),
-        )
-        for bit in bits
-    )
-
-
-def _format_params(param):
-    if isinstance(param, np.ndarray):
-        return param.data.tobytes()
-    elif isinstance(param, QuantumCircuit):
-        return _circuit_key(param)
-    elif isinstance(param, Iterable):
-        return tuple(param)
-    return param
-
-
-def _circuit_key(circuit: QuantumCircuit, functional: bool = True) -> tuple:
-    """Private key function for QuantumCircuit.
-
-    This is the workaround until :meth:`QuantumCircuit.__hash__` will be introduced.
-    If key collision is found, please add elements to avoid it.
-
-    Args:
-        circuit: Input quantum circuit.
-        functional: If True, the returned key only includes functional data (i.e. execution related).
+def _statevector_from_circuit(
+    circuit: QuantumCircuit, rng: np.random.Generator | None
+) -> Statevector:
+    """Generate a statevector from a circuit. Used in StatevectorEstimator class.
 
-    Returns:
-        Composite key for circuit.
-    """
-    functional_key: tuple = (
-        circuit.num_qubits,
-        circuit.num_clbits,
-        circuit.num_parameters,
-        tuple(  # circuit.data
-            (
-                _bits_key(data.qubits, circuit),  # qubits
-                _bits_key(data.clbits, circuit),  # clbits
-                data.operation.name,  # operation.name
-                tuple(_format_params(param) for param in data.operation.params),  # operation.params
-            )
-            for data in circuit.data
-        ),
-        None if circuit._op_start_times is None else tuple(circuit._op_start_times),
-    )
-    if functional:
-        return functional_key
-    return (
-        circuit.name,
-        *functional_key,
-    )
+    If the input circuit includes any resets for a some subsystem,
+    :meth:`.Statevector.reset` behaves in a stochastic way in :meth:`.Statevector.evolve`.
+    This function sets a random number generator to be reproducible.
 
+    See :meth:`.Statevector.reset` for details.
 
-def _observable_key(observable: SparsePauliOp) -> tuple:
-    """Private key function for SparsePauliOp.
     Args:
-        observable: Input operator.
-
-    Returns:
-        Key for observables.
+        circuit: The quantum circuit.
+        seed: The random number generator or None.
     """
-    return (
-        observable.paulis.z.tobytes(),
-        observable.paulis.x.tobytes(),
-        observable.paulis.phase.tobytes(),
-        observable.coeffs.tobytes(),
-    )
+    sv = Statevector.from_int(0, 2**circuit.num_qubits)
+    sv.seed(rng)
+    return sv.evolve(bound_circuit_to_instruction(circuit))
 
 
 def bound_circuit_to_instruction(circuit: QuantumCircuit) -> Instruction:
@@ -225,23 +70,3 @@ def bound_circuit_to_instruction(circuit: QuantumCircuit) -> Instruction:
     )
     inst.definition = circuit
     return inst
-
-
-def _statevector_from_circuit(
-    circuit: QuantumCircuit, rng: np.random.Generator | None
-) -> Statevector:
-    """Generate a statevector from a circuit
-
-    If the input circuit includes any resets for a some subsystem,
-    :meth:`.Statevector.reset` behaves in a stochastic way in :meth:`.Statevector.evolve`.
-    This function sets a random number generator to be reproducible.
-
-    See :meth:`.Statevector.reset` for details.
-
-    Args:
-        circuit: The quantum circuit.
-        seed: The random number generator or None.
-    """
-    sv = Statevector.from_int(0, 2**circuit.num_qubits)
-    sv.seed(rng)
-    return sv.evolve(bound_circuit_to_instruction(circuit))