qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/primitives/__init__.py

@@ -27,9 +27,15 @@ accepting quantum circuits (or sweeps of values over parameterized circuits) and
 classical output registers. Estimators accept combinations of circuits and observables (or sweeps
 thereof) to estimate expectation values of the observables.
 
-Qiskit implements a reference implementation for each of these abstractions,
-:class:`~.StatevectorSampler` and :class:`~.StatevectorEstimator`.
+Qiskit offers a reference implementation for each of these abstractions in the
+:class:`~.StatevectorSampler` and :class:`~.StatevectorEstimator` classes.
 
+The earlier versions of the sampler and estimator abstractions are defined by :class:`~.BaseSamplerV1`
+and :class:`~.BaseEstimatorV1`. These interfaces follow a different and less flexible input-output 
+format for the ``run`` method and have been largely replaced in practice by :class:`~.BaseSamplerV2` and 
+:class:`~.BaseEstimatorV2`. However, the original abstract interface definitions have been 
+retained for backward compatibility. Check the migration section of this page to see further details 
+on the difference between V1 and V2. 
 
 Overview of EstimatorV2
 =======================
@@ -66,7 +72,9 @@ is in general array-valued as well. For more information, please check
 
 Here is an example of how an estimator is used.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.primitives import StatevectorEstimator as Estimator
     from qiskit.circuit.library import RealAmplitudes
@@ -126,7 +134,9 @@ for each pub.
 Here is an example of how a sampler is used.
 
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.primitives import StatevectorSampler as Sampler
     from qiskit import QuantumCircuit
@@ -164,12 +174,12 @@ Here is an example of how a sampler is used.
 Overview of EstimatorV1
 =======================
 
-Estimator class estimates expectation values of quantum circuits and observables.
+There are currently no implementations of the legacy ``EstimatorV1`` interface in Qiskit. 
+However, the abstract interface definition from :class:`~BaseEstimatorV1` is still part 
+of the package to provide backwards compatibility for external implementations. 
 
-An estimator is initialized with an empty parameter set. The estimator is used to
-create a :class:`~qiskit.providers.JobV1`, via the
-:meth:`qiskit.primitives.Estimator.run()` method. This method is called
-with the following parameters
+An ``EstimatorV1`` implementation is initialized with an empty parameter set. 
+:class:`~BaseEstimatorV1` can be called via the ``.run()`` method with the following parameters:
 
 * quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits
   (a list of :class:`~qiskit.circuit.QuantumCircuit` objects).
@@ -181,7 +191,7 @@ with the following parameters
   to be bound to the parameters of the quantum circuits
   (list of list of float).
 
-The method returns a :class:`~qiskit.providers.JobV1` object, calling
+The method should return a :class:`~qiskit.providers.JobV1` object. Calling
 :meth:`qiskit.providers.JobV1.result()` yields the
 a list of expectation values plus optional metadata like confidence intervals for
 the estimation.
@@ -190,11 +200,15 @@ the estimation.
 
     \langle\psi_i(\theta_k)|H_j|\psi_i(\theta_k)\rangle
 
-Here is an example of how the estimator is used.
+Here is an example of how an ``EstimatorV1`` implementation would be used.
+Note that there are currently no implementations of the legacy ``EstimatorV1`` 
+interface in Qiskit. 
 
 .. code-block:: python
 
-    from qiskit.primitives import Estimator
+    # This is a fictional import path.
+    # There are currently no EstimatorV1 implementations in Qiskit.
+    from estimator_v1_location import EstimatorV1 
     from qiskit.circuit.library import RealAmplitudes
     from qiskit.quantum_info import SparsePauliOp
 
@@ -209,7 +223,7 @@ Here is an example of how the estimator is used.
     theta2 = [0, 1, 1, 2, 3, 5, 8, 13]
     theta3 = [1, 2, 3, 4, 5, 6]
 
-    estimator = Estimator()
+    estimator = EstimatorV1()
 
     # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
     job = estimator.run([psi1], [H1], [theta1])
@@ -231,11 +245,14 @@ Here is an example of how the estimator is used.
 Overview of SamplerV1
 =====================
 
-Sampler class calculates probabilities or quasi-probabilities of bitstrings from quantum circuits.
+There are currently no implementations of the legacy ``SamplerV1`` interface in Qiskit. 
+However, the abstract interface definition from :class:`~BaseSamplerV1` is still part 
+of the package to provide backward compatibility for external implementations. 
 
-A sampler is initialized with an empty parameter set. The sampler is used to
-create a :class:`~qiskit.providers.JobV1`, via the :meth:`qiskit.primitives.Sampler.run()`
-method. This method is called with the following parameters
+Sampler classes calculate probabilities or quasi-probabilities of bitstrings from quantum circuits.
+
+A ``SamplerV1`` is initialized with an empty parameter set. :class:`~BaseSamplerV1` implementations can 
+be called via the ``.run()`` method with the following parameters:
 
 * quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits.
   (a list of :class:`~qiskit.circuit.QuantumCircuit` objects)
@@ -244,16 +261,20 @@ method. This method is called with the following parameters
   to be bound to the parameters of the quantum circuits.
   (list of list of float)
 
-The method returns a :class:`~qiskit.providers.JobV1` object, calling
+``.run()`` will return a :class:`~qiskit.providers.JobV1` object. Calling
 :meth:`qiskit.providers.JobV1.result()` yields a :class:`~qiskit.primitives.SamplerResult`
 object, which contains probabilities or quasi-probabilities of bitstrings,
 plus optional metadata like error bars in the samples.
 
-Here is an example of how sampler is used.
+Here is an example of how a ``SamplerV1`` implementation would be used.
+Note that there are currently no implementations of the legacy ``SamplerV1`` 
+interface in Qiskit. 
 
 .. code-block:: python
 
-    from qiskit.primitives import Sampler
+    # This is a fictional import path.
+    # There are currently no SamplerV1 implementations in Qiskit.
+    from sampler_v1_location import Sampler 
     from qiskit import QuantumCircuit
     from qiskit.circuit.library import RealAmplitudes
 
@@ -273,7 +294,7 @@ Here is an example of how sampler is used.
     theta2 = [0, 1, 2, 3, 4, 5, 6, 7]
 
     # initialization of the sampler
-    sampler = Sampler()
+    sampler = SamplerV1()
 
     # Sampler runs a job on the Bell circuit
     job = sampler.run(
@@ -427,10 +448,7 @@ Estimator V1
 .. autosummary::
    :toctree: ../stubs/
 
-   BaseEstimator
    BaseEstimatorV1
-   Estimator
-   BackendEstimator
    EstimatorResult
 
 
@@ -440,26 +458,19 @@ Sampler V1
 .. autosummary::
    :toctree: ../stubs/
 
-   BaseSampler
    BaseSamplerV1
-   Sampler
-   BackendSampler
    SamplerResult
 
 """
 
-from .backend_estimator import BackendEstimator
-from .backend_sampler import BackendSampler
 from .base import (
-    BaseEstimator,
     BaseEstimatorV1,
     BaseEstimatorV2,
-    BaseSampler,
     BaseSamplerV1,
     BaseSamplerV2,
 )
-from .base.estimator_result import EstimatorResult
-from .base.sampler_result import SamplerResult
+from .base.estimator_result_v1 import EstimatorResult
+from .base.sampler_result_v1 import SamplerResult
 from .containers import (
     BitArray,
     DataBin,
@@ -472,9 +483,7 @@ from .containers import (
     ObservableLike,
     ObservablesArrayLike,
 )
-from .estimator import Estimator
 from .primitive_job import BasePrimitiveJob, PrimitiveJob
-from .sampler import Sampler
 from .statevector_estimator import StatevectorEstimator
 from .statevector_sampler import StatevectorSampler
 from .backend_estimator_v2 import BackendEstimatorV2

qiskit/primitives/backend_estimator_v2.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import math
-import warnings
 from collections import defaultdict
 from collections.abc import Iterable
 from dataclasses import dataclass
@@ -24,13 +23,12 @@ import numpy as np
 
 from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister
 from qiskit.exceptions import QiskitError
-from qiskit.providers import BackendV1, BackendV2
+from qiskit.providers import BackendV2
 from qiskit.quantum_info import Pauli, PauliList
-from qiskit.result import Counts
+from qiskit.result import Counts, Result
 from qiskit.transpiler import PassManager, PassManagerConfig
 from qiskit.transpiler.passes import Optimize1qGatesDecomposition
 
-from .backend_estimator import _pauli_expval_with_variance, _prepare_counts, _run_circuits
 from .base import BaseEstimatorV2
 from .containers import DataBin, EstimatorPubLike, PrimitiveResult, PubResult
 from .containers.bindings_array import BindingsArray
@@ -38,6 +36,103 @@ from .containers.estimator_pub import EstimatorPub
 from .primitive_job import PrimitiveJob
 
 
+def _run_circuits(
+    circuits: QuantumCircuit | list[QuantumCircuit],
+    backend: BackendV2,
+    clear_metadata: bool = True,
+    **run_options,
+) -> tuple[list[Result], list[dict]]:
+    """Remove metadata of circuits and run the circuits on a backend.
+    Args:
+        circuits: The circuits
+        backend: The backend
+        clear_metadata: Clear circuit metadata before passing to backend.run if
+            True.
+        **run_options: run_options
+    Returns:
+        The result and the metadata of the circuits
+    """
+    if isinstance(circuits, QuantumCircuit):
+        circuits = [circuits]
+    metadata = []
+    for circ in circuits:
+        metadata.append(circ.metadata)
+        if clear_metadata:
+            circ.metadata = {}
+    if isinstance(backend, BackendV2):
+        max_circuits = backend.max_circuits
+    else:
+        raise RuntimeError("Backend version not supported")
+    if max_circuits:
+        jobs = [
+            backend.run(circuits[pos : pos + max_circuits], **run_options)
+            for pos in range(0, len(circuits), max_circuits)
+        ]
+        result = [x.result() for x in jobs]
+    else:
+        result = [backend.run(circuits, **run_options).result()]
+    return result, metadata
+
+
+def _prepare_counts(results: list[Result]):
+    counts = []
+    for res in results:
+        count = res.get_counts()
+        if not isinstance(count, list):
+            count = [count]
+        counts.extend(count)
+    return counts
+
+
+def _pauli_expval_with_variance(counts: Counts, paulis: PauliList) -> tuple[np.ndarray, np.ndarray]:
+    """Return array of expval and variance pairs for input Paulis.
+    Note: All non-identity Pauli's are treated as Z-paulis, assuming
+    that basis rotations have been applied to convert them to the
+    diagonal basis.
+    """
+    # Diag indices
+    size = len(paulis)
+    diag_inds = _paulis2inds(paulis)
+
+    expvals = np.zeros(size, dtype=float)
+    denom = 0  # Total shots for counts dict
+    for bin_outcome, freq in counts.items():
+        split_outcome = bin_outcome.split(" ", 1)[0] if " " in bin_outcome else bin_outcome
+        outcome = int(split_outcome, 2)
+        denom += freq
+        for k in range(size):
+            coeff = (-1) ** _parity(diag_inds[k] & outcome)
+            expvals[k] += freq * coeff
+
+    # Divide by total shots
+    expvals /= denom
+
+    # Compute variance
+    variances = 1 - expvals**2
+    return expvals, variances
+
+
+def _paulis2inds(paulis: PauliList) -> list[int]:
+    """Convert PauliList to diagonal integers.
+    These are integer representations of the binary string with a
+    1 where there are Paulis, and 0 where there are identities.
+    """
+    # Treat Z, X, Y the same
+    nonid = paulis.z | paulis.x
+
+    # bits are packed into uint8 in little endian
+    # e.g., i-th bit corresponds to coefficient 2^i
+    packed_vals = np.packbits(nonid, axis=1, bitorder="little")
+    power_uint8 = 1 << (8 * np.arange(packed_vals.shape[1], dtype=object))
+    inds = packed_vals @ power_uint8
+    return inds.tolist()
+
+
+def _parity(integer: int) -> int:
+    """Return the parity of an integer"""
+    return bin(integer).count("1") % 2
+
+
 @dataclass
 class Options:
     """Options for :class:`~.BackendEstimatorV2`."""
@@ -77,7 +172,7 @@ class BackendEstimatorV2(BaseEstimatorV2):
 
     The :class:`~.BackendEstimatorV2` class is a generic implementation of the
     :class:`~.BaseEstimatorV2` interface that is used to wrap a :class:`~.BackendV2`
-    (or :class:`~.BackendV1`) object in the :class:`~.BaseEstimatorV2` API. It
+    object in the :class:`~.BaseEstimatorV2` API. It
     facilitates using backends that do not provide a native
     :class:`~.BaseEstimatorV2` implementation in places that work with
     :class:`~.BaseEstimatorV2`. However,
@@ -128,32 +223,16 @@ class BackendEstimatorV2(BaseEstimatorV2):
     def __init__(
         self,
         *,
-        backend: BackendV1 | BackendV2,
+        backend: BackendV2,
         options: dict | None = None,
     ):
         """
-        .. deprecated:: 1.4
-            The method ``BackendEstimatorV2.__init__`` will stop supporting inputs of type
-            :class:`.BackendV1` in the `backend` parameter in a future release no
-            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
-            move to :class:`.BackendV2`.
-
         Args:
             backend: The backend to run the primitive on.
             options: The options to control the default precision (``default_precision``),
                 the operator grouping (``abelian_grouping``), and
                 the random seed for the simulator (``seed_simulator``).
         """
-
-        if not isinstance(backend, BackendV2):
-            warnings.warn(
-                "The method `BackendEstimatorV2.__init__` will stop supporting inputs of "
-                f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
-                "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
-                "should move to `BackendV2`.",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
         self._backend = backend
         self._options = Options(**options) if options else Options()
 
@@ -170,7 +249,7 @@ class BackendEstimatorV2(BaseEstimatorV2):
         return self._options
 
     @property
-    def backend(self) -> BackendV1 | BackendV2:
+    def backend(self) -> BackendV2:
         """Returns the backend which this sampler object based on."""
         return self._backend
 

qiskit/primitives/backend_sampler_v2.py

@@ -24,7 +24,7 @@ from numpy.typing import NDArray
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.exceptions import QiskitError
-from qiskit.primitives.backend_estimator import _run_circuits
+from qiskit.primitives.backend_estimator_v2 import _run_circuits
 from qiskit.primitives.base import BaseSamplerV2
 from qiskit.primitives.containers import (
     BitArray,
@@ -36,7 +36,7 @@ from qiskit.primitives.containers import (
 from qiskit.primitives.containers.bit_array import _min_num_bytes
 from qiskit.primitives.containers.sampler_pub import SamplerPub
 from qiskit.primitives.primitive_job import PrimitiveJob
-from qiskit.providers.backend import BackendV1, BackendV2
+from qiskit.providers.backend import BackendV2
 from qiskit.result import Result
 
 
@@ -83,7 +83,7 @@ class BackendSamplerV2(BaseSamplerV2):
 
     The :class:`~.BackendSamplerV2` class is a generic implementation of the
     :class:`~.BaseSamplerV2` interface that is used to wrap a :class:`~.BackendV2`
-    (or :class:`~.BackendV1`) object in the class :class:`~.BaseSamplerV2` API. It
+    object in the class :class:`~.BaseSamplerV2` API. It
     facilitates using backends that do not provide a native
     :class:`~.BaseSamplerV2` implementation in places that work with
     :class:`~.BaseSamplerV2`. However,
@@ -119,35 +119,20 @@ class BackendSamplerV2(BaseSamplerV2):
     def __init__(
         self,
         *,
-        backend: BackendV1 | BackendV2,
+        backend: BackendV2,
         options: dict | None = None,
     ):
         """
-        .. deprecated:: 1.4
-            The method ``BackendSamplerV2.__init__`` will stop supporting inputs of type
-            :class:`.BackendV1` in the `backend` parameter in a future release no
-            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
-            move to :class:`.BackendV2`.
-
         Args:
             backend: The backend to run the primitive on.
             options: The options to control the default shots (``default_shots``) and
                 the random seed for the simulator (``seed_simulator``).
         """
-        if not isinstance(backend, BackendV2):
-            warnings.warn(
-                "The method `BackendSamplerV2.__init__` will stop supporting inputs of "
-                f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
-                "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
-                "should move to `BackendV2`.",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
         self._backend = backend
         self._options = Options(**options) if options else Options()
 
     @property
-    def backend(self) -> BackendV1 | BackendV2:
+    def backend(self) -> BackendV2:
         """Returns the backend which this sampler object based on."""
         return self._backend
 

qiskit/primitives/base/__init__.py

@@ -14,7 +14,7 @@
 Abstract base classes for primitives module.
 """
 
-from .base_sampler import BaseSampler, BaseSamplerV1, BaseSamplerV2
-from .base_estimator import BaseEstimator, BaseEstimatorV1, BaseEstimatorV2
-from .estimator_result import EstimatorResult
-from .sampler_result import SamplerResult
+from .base_sampler import BaseSamplerV1, BaseSamplerV2
+from .base_estimator import BaseEstimatorV1, BaseEstimatorV2
+from .estimator_result_v1 import EstimatorResult
+from .sampler_result_v1 import SamplerResult

qiskit/primitives/base/base_estimator.py

@@ -23,7 +23,6 @@ from qiskit.circuit import QuantumCircuit
 from qiskit.providers import JobV1 as Job
 from qiskit.quantum_info.operators import SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
-from qiskit.utils.deprecation import deprecate_func
 
 from ..containers import (
     DataBin,
@@ -32,22 +31,81 @@ from ..containers import (
     PubResult,
 )
 from ..containers.estimator_pub import EstimatorPub
-from . import validation
-from .base_primitive import BasePrimitive
+from .validation_v1 import _validate_estimator_args
+from .base_primitive_v1 import BasePrimitiveV1
 from .base_primitive_job import BasePrimitiveJob
 
 T = TypeVar("T", bound=Job)
 
 
-class BaseEstimatorV1(BasePrimitive, Generic[T]):
-    r"""Estimator V1 base class.
+class BaseEstimatorV2(ABC):
+    r"""Base class for ``EstimatorV2`` implementations.
+
+    An estimator calculates expectation values for provided quantum circuit and
+    observable combinations. Implementations of this :class:`.BaseEstimatorV2`
+    interface must define their own :meth:`.run` method, which is designed to
+    take the following inputs:
+
+     * pubs: list of pubs (Primitive Unified Blocs). An estimator pub is a list
+        or tuple of two to four elements that define the unit of work for the
+        estimator. These are:
+
+        * A single :class:`~qiskit.circuit.QuantumCircuit`, possibly parametrized,
+            whose final state we define as :math:`\psi(\theta)`.
+
+        * One or more observables (specified as any :class:`~.ObservablesArrayLike`, including
+            :class:`~.Pauli`, :class:`~.SparsePauliOp`, ``str``) that specify which expectation
+            values to estimate, denoted :math:`H_j`.
+
+        * A collection parameter value sets to bind the circuit against, :math:`\theta_k`
 
-    Base class for Estimator that estimates expectation values of quantum circuits and observables.
+        * Optionally, the estimation precision.
 
-    An estimator is initialized with an empty parameter set. The estimator is used to
-    create a :class:`~qiskit.providers.JobV1`, via the
-    :meth:`qiskit.primitives.Estimator.run()` method. This method is called
-    with the following parameters
+     * precision: the estimation precision. This specification is optional and will be overriden by
+        the pub-wise shots if provided.
+
+    All estimator implementations must implement default value for the ``precision`` in the
+    :meth:`.run` method. This default value will be used any time ``precision=None`` is specified, which
+    can take place in the :meth:`.run` kwargs or at the pub level.
+    """
+
+    @staticmethod
+    def _make_data_bin(_: EstimatorPub) -> type[DataBin]:
+        # this method is present for backwards compat. new primitive implementations
+        # should avoid it.
+        return DataBin
+
+    @abstractmethod
+    def run(
+        self, pubs: Iterable[EstimatorPubLike], *, precision: float | None = None
+    ) -> BasePrimitiveJob[PrimitiveResult[PubResult]]:
+        """Estimate expectation values for each provided pub (Primitive Unified Bloc).
+
+        Args:
+            pubs: An iterable of pub-like objects, such as tuples ``(circuit, observables)``
+                  or ``(circuit, observables, parameter_values)``.
+            precision: The target precision for expectation value estimates of each
+                       run Estimator Pub that does not specify its own precision. If None
+                       the estimator's default precision value will be used.
+
+        Returns:
+            A job object that contains results.
+        """
+
+
+class BaseEstimatorV1(BasePrimitiveV1, Generic[T]):
+    r"""Base class for ``EstimatorV1`` implementations.
+
+    Note that the reference estimator in Qiskit follows the ``EstimatorV2``
+    interface specifications instead.
+
+    An estimator calculates expectation values for provided quantum circuit and
+    observable combinations.
+
+    Implementations of :class:`.BaseEstimatorV1` should define their own
+    :meth:`.BaseEstimatorV1._run` method
+    that will be called by the public-facing :meth:`qiskit.primitives.BaseEstimatorV1.run`,
+    which takes the following inputs:
 
     * quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits
       (a list of :class:`~qiskit.circuit.QuantumCircuit` objects).
@@ -59,7 +117,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
       to be bound to the parameters of the quantum circuits
       (list of list of float).
 
-    The method returns a :class:`~qiskit.providers.JobV1` object, calling
+    The method returns a :class:`~qiskit.providers.JobV1` object. Calling
     :meth:`qiskit.providers.JobV1.result()` yields the
     a list of expectation values plus optional metadata like confidence intervals for
     the estimation.
@@ -68,11 +126,13 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
 
         \langle\psi_i(\theta_k)|H_j|\psi_i(\theta_k)\rangle
 
-    Here is an example of how the estimator is used.
+    Here is an example of how a :class:`.BaseEstimatorV1` would be used:
 
     .. code-block:: python
 
-        from qiskit.primitives import Estimator
+        # This is a fictional import path.
+        # There are currently no EstimatorV1 implementations in Qiskit.
+        from estimator_v1_location import EstimatorV1
         from qiskit.circuit.library import RealAmplitudes
         from qiskit.quantum_info import SparsePauliOp
 
@@ -87,7 +147,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         theta2 = [0, 1, 1, 2, 3, 5, 8, 13]
         theta3 = [1, 2, 3, 4, 5, 6]
 
-        estimator = Estimator()
+        estimator = EstimatorV1()
 
         # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
         job = estimator.run([psi1], [H1], [theta1])
@@ -110,8 +170,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         options: dict | None = None,
     ):
         """
-        Creating an instance of an Estimator V1, or using one in a ``with`` context opens a session that
-        holds resources until the instance is ``close()`` ed or the context is exited.
+        Initialize ``EstimatorV1``.
 
         Args:
             options: Default options.
@@ -162,7 +221,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
             ValueError: Invalid argument values given.
         """
         # Validation
-        circuits, observables, parameter_values = validation._validate_estimator_args(
+        circuits, observables, parameter_values = _validate_estimator_args(
             circuits, observables, parameter_values
         )
 
@@ -185,68 +244,4 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         parameter_values: tuple[tuple[float, ...], ...],
         **run_options,
     ) -> T:
-        raise NotImplementedError("The subclass of BaseEstimator must implement `_run` method.")
-
-
-class BaseEstimator(BaseEstimatorV1[T]):
-    """DEPRECATED. Type alias for Estimator V1 base class.
-
-    See :class:`.BaseEstimatorV1` for details.
-    """
-
-    @deprecate_func(
-        since="1.2",
-        additional_msg="The `BaseEstimator` class is a type alias for the `BaseEstimatorV1` "
-        "interface that has been deprecated in favor of explicitly versioned interface classes. "
-        "It is recommended to migrate all implementations to use `BaseEstimatorV2`. "
-        "However, for implementations incompatible with `BaseEstimatorV2`, `BaseEstimator` can "
-        "be replaced with the explicitly versioned `BaseEstimatorV1` class.",
-    )
-    def __init__(
-        self,
-        *,
-        options: dict | None = None,
-    ):
-        """
-        Creating an instance of an Estimator, or using one in a ``with`` context opens a session that
-        holds resources until the instance is ``close()`` ed or the context is exited.
-
-        Args:
-            options: Default options.
-        """
-        super().__init__(options=options)
-
-
-class BaseEstimatorV2(ABC):
-    r"""Estimator V2 base class.
-
-    An estimator estimates expectation values for provided quantum circuit and
-    observable combinations.
-
-    An Estimator implementation must treat the :meth:`.run` method ``precision=None``
-    kwarg as using a default ``precision`` value.  The default value and methods to
-    set it can be determined by the Estimator implementor.
-    """
-
-    @staticmethod
-    def _make_data_bin(_: EstimatorPub) -> type[DataBin]:
-        # this method is present for backwards compat. new primitive implementations
-        # should avoid it.
-        return DataBin
-
-    @abstractmethod
-    def run(
-        self, pubs: Iterable[EstimatorPubLike], *, precision: float | None = None
-    ) -> BasePrimitiveJob[PrimitiveResult[PubResult]]:
-        """Estimate expectation values for each provided pub (Primitive Unified Bloc).
-
-        Args:
-            pubs: An iterable of pub-like objects, such as tuples ``(circuit, observables)``
-                  or ``(circuit, observables, parameter_values)``.
-            precision: The target precision for expectation value estimates of each
-                       run Estimator Pub that does not specify its own precision. If None
-                       the estimator's default precision value will be used.
-
-        Returns:
-            A job object that contains results.
-        """
+        raise NotImplementedError("The subclass of BaseEstimatorV1 must implement `_run` method.")

qiskit/primitives/base/base_primitive_job.py

@@ -17,9 +17,9 @@ from abc import ABC, abstractmethod
 from typing import Generic, TypeVar, Union
 
 from ..containers import PrimitiveResult
-from .base_result import _BasePrimitiveResult
+from .base_result_v1 import _BasePrimitiveResultV1
 
-ResultT = TypeVar("ResultT", bound=Union[_BasePrimitiveResult, PrimitiveResult])
+ResultT = TypeVar("ResultT", bound=Union[_BasePrimitiveResultV1, PrimitiveResult])
 StatusT = TypeVar("StatusT")