qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/dagcircuit/dagdependency.py

@@ -187,7 +187,7 @@ class DAGDependency:
 
         duplicate_qubits = set(self.qubits).intersection(qubits)
         if duplicate_qubits:
-            raise DAGDependencyError("duplicate qubits %s" % duplicate_qubits)
+            raise DAGDependencyError(f"duplicate qubits {duplicate_qubits}")
 
         self.qubits.extend(qubits)
 
@@ -198,7 +198,7 @@ class DAGDependency:
 
         duplicate_clbits = set(self.clbits).intersection(clbits)
         if duplicate_clbits:
-            raise DAGDependencyError("duplicate clbits %s" % duplicate_clbits)
+            raise DAGDependencyError(f"duplicate clbits {duplicate_clbits}")
 
         self.clbits.extend(clbits)
 
@@ -207,7 +207,7 @@ class DAGDependency:
         if not isinstance(qreg, QuantumRegister):
             raise DAGDependencyError("not a QuantumRegister instance.")
         if qreg.name in self.qregs:
-            raise DAGDependencyError("duplicate register %s" % qreg.name)
+            raise DAGDependencyError(f"duplicate register {qreg.name}")
         self.qregs[qreg.name] = qreg
         existing_qubits = set(self.qubits)
         for j in range(qreg.size):
@@ -219,7 +219,7 @@ class DAGDependency:
         if not isinstance(creg, ClassicalRegister):
             raise DAGDependencyError("not a ClassicalRegister instance.")
         if creg.name in self.cregs:
-            raise DAGDependencyError("duplicate register %s" % creg.name)
+            raise DAGDependencyError(f"duplicate register {creg.name}")
         self.cregs[creg.name] = creg
         existing_clbits = set(self.clbits)
         for j in range(creg.size):

qiskit/dagcircuit/dagdependency_v2.py

@@ -247,7 +247,7 @@ class _DAGDependencyV2:
 
         duplicate_qubits = set(self.qubits).intersection(qubits)
         if duplicate_qubits:
-            raise DAGDependencyError("duplicate qubits %s" % duplicate_qubits)
+            raise DAGDependencyError(f"duplicate qubits {duplicate_qubits}")
 
         for qubit in qubits:
             self.qubits.append(qubit)
@@ -260,7 +260,7 @@ class _DAGDependencyV2:
 
         duplicate_clbits = set(self.clbits).intersection(clbits)
         if duplicate_clbits:
-            raise DAGDependencyError("duplicate clbits %s" % duplicate_clbits)
+            raise DAGDependencyError(f"duplicate clbits {duplicate_clbits}")
 
         for clbit in clbits:
             self.clbits.append(clbit)
@@ -271,7 +271,7 @@ class _DAGDependencyV2:
         if not isinstance(qreg, QuantumRegister):
             raise DAGDependencyError("not a QuantumRegister instance.")
         if qreg.name in self.qregs:
-            raise DAGDependencyError("duplicate register %s" % qreg.name)
+            raise DAGDependencyError(f"duplicate register {qreg.name}")
         self.qregs[qreg.name] = qreg
         existing_qubits = set(self.qubits)
         for j in range(qreg.size):
@@ -288,7 +288,7 @@ class _DAGDependencyV2:
         if not isinstance(creg, ClassicalRegister):
             raise DAGDependencyError("not a ClassicalRegister instance.")
         if creg.name in self.cregs:
-            raise DAGDependencyError("duplicate register %s" % creg.name)
+            raise DAGDependencyError(f"duplicate register {creg.name}")
         self.cregs[creg.name] = creg
         existing_clbits = set(self.clbits)
         for j in range(creg.size):

qiskit/dagcircuit/dagdepnode.py

@@ -83,7 +83,7 @@ class DAGDepNode:
     def op(self):
         """Returns the Instruction object corresponding to the op for the node, else None"""
         if not self.type or self.type != "op":
-            raise QiskitError("The node %s is not an op node" % (str(self)))
+            raise QiskitError(f"The node {str(self)} is not an op node")
         return self._op
 
     @op.setter

qiskit/dagcircuit/dagnode.py

@@ -14,14 +14,11 @@
 """Objects to represent the information at a node in the DAGCircuit."""
 from __future__ import annotations
 
-import itertools
 import typing
 import uuid
-from collections.abc import Iterable
-
 
+import qiskit._accelerate.circuit
 from qiskit.circuit import (
-    Qubit,
     Clbit,
     ClassicalRegister,
     ControlFlowOp,
@@ -30,7 +27,6 @@ from qiskit.circuit import (
     SwitchCaseOp,
     ForLoopOp,
     Parameter,
-    Operation,
     QuantumCircuit,
 )
 from qiskit.circuit.classical import expr
@@ -39,6 +35,12 @@ if typing.TYPE_CHECKING:
     from qiskit.dagcircuit import DAGCircuit
 
 
+DAGNode = qiskit._accelerate.circuit.DAGNode
+DAGOpNode = qiskit._accelerate.circuit.DAGOpNode
+DAGInNode = qiskit._accelerate.circuit.DAGInNode
+DAGOutNode = qiskit._accelerate.circuit.DAGOutNode
+
+
 def _legacy_condition_eq(cond1, cond2, bit_indices1, bit_indices2) -> bool:
     if cond1 is cond2 is None:
         return True
@@ -175,158 +177,65 @@ _SEMANTIC_EQ_CONTROL_FLOW = {
 _SEMANTIC_EQ_SYMMETRIC = frozenset({"barrier", "swap", "break_loop", "continue_loop"})
 
 
-class DAGNode:
-    """Parent class for DAGOpNode, DAGInNode, and DAGOutNode."""
-
-    __slots__ = ["_node_id"]
-
-    def __init__(self, nid=-1):
-        """Create a node"""
-        self._node_id = nid
-
-    def __lt__(self, other):
-        return self._node_id < other._node_id
-
-    def __gt__(self, other):
-        return self._node_id > other._node_id
-
-    def __str__(self):
-        # TODO is this used anywhere other than in DAG drawing?
-        # needs to be unique as it is what pydot uses to distinguish nodes
-        return str(id(self))
-
-    @staticmethod
-    def semantic_eq(node1, node2, bit_indices1, bit_indices2):
-        """
-        Check if DAG nodes are considered equivalent, e.g., as a node_match for
-        :func:`rustworkx.is_isomorphic_node_match`.
-
-        Args:
-            node1 (DAGOpNode, DAGInNode, DAGOutNode): A node to compare.
-            node2 (DAGOpNode, DAGInNode, DAGOutNode): The other node to compare.
-            bit_indices1 (dict): Dictionary mapping Bit instances to their index
-                within the circuit containing node1
-            bit_indices2 (dict): Dictionary mapping Bit instances to their index
-                within the circuit containing node2
-
-        Return:
-            Bool: If node1 == node2
-        """
-        if not isinstance(node1, DAGOpNode) or not isinstance(node1, DAGOpNode):
-            return type(node1) is type(node2) and bit_indices1.get(node1.wire) == bit_indices2.get(
-                node2.wire
-            )
-        if isinstance(node1.op, ControlFlowOp) and isinstance(node2.op, ControlFlowOp):
-            # While control-flow operations aren't represented natively in the DAG, we have to do
-            # some unpleasant dispatching and very manual handling.  Once they have more first-class
-            # support we'll still be dispatching, but it'll look more appropriate (like the dispatch
-            # based on `DAGOpNode`/`DAGInNode`/`DAGOutNode` that already exists) and less like we're
-            # duplicating code from the `ControlFlowOp` classes.
-            if type(node1.op) is not type(node2.op):
-                return False
-            comparer = _SEMANTIC_EQ_CONTROL_FLOW.get(type(node1.op))
-            if comparer is None:  # pragma: no cover
-                raise RuntimeError(f"unhandled control-flow operation: {type(node1.op)}")
-            return comparer(node1, node2, bit_indices1, bit_indices2)
-
-        node1_qargs = [bit_indices1[qarg] for qarg in node1.qargs]
-        node1_cargs = [bit_indices1[carg] for carg in node1.cargs]
-
-        node2_qargs = [bit_indices2[qarg] for qarg in node2.qargs]
-        node2_cargs = [bit_indices2[carg] for carg in node2.cargs]
-
-        # For barriers, qarg order is not significant so compare as sets
-        if node1.op.name == node2.op.name and node1.name in _SEMANTIC_EQ_SYMMETRIC:
-            node1_qargs = set(node1_qargs)
-            node1_cargs = set(node1_cargs)
-            node2_qargs = set(node2_qargs)
-            node2_cargs = set(node2_cargs)
-
-        return (
-            node1_qargs == node2_qargs
-            and node1_cargs == node2_cargs
-            and _legacy_condition_eq(
-                getattr(node1.op, "condition", None),
-                getattr(node2.op, "condition", None),
-                bit_indices1,
-                bit_indices2,
-            )
-            and node1.op == node2.op
+# Note: called from dag_node.rs.
+def _semantic_eq(node1, node2, bit_indices1, bit_indices2):
+    """
+    Check if DAG nodes are considered equivalent, e.g., as a node_match for
+    :func:`rustworkx.is_isomorphic_node_match`.
+
+    Args:
+        node1 (DAGOpNode, DAGInNode, DAGOutNode): A node to compare.
+        node2 (DAGOpNode, DAGInNode, DAGOutNode): The other node to compare.
+        bit_indices1 (dict): Dictionary mapping Bit instances to their index
+            within the circuit containing node1
+        bit_indices2 (dict): Dictionary mapping Bit instances to their index
+            within the circuit containing node2
+
+    Return:
+        Bool: If node1 == node2
+    """
+    if not isinstance(node1, DAGOpNode) or not isinstance(node1, DAGOpNode):
+        return type(node1) is type(node2) and bit_indices1.get(node1.wire) == bit_indices2.get(
+            node2.wire
         )
+    if isinstance(node1.op, ControlFlowOp) and isinstance(node2.op, ControlFlowOp):
+        # While control-flow operations aren't represented natively in the DAG, we have to do
+        # some unpleasant dispatching and very manual handling.  Once they have more first-class
+        # support we'll still be dispatching, but it'll look more appropriate (like the dispatch
+        # based on `DAGOpNode`/`DAGInNode`/`DAGOutNode` that already exists) and less like we're
+        # duplicating code from the `ControlFlowOp` classes.
+        if type(node1.op) is not type(node2.op):
+            return False
+        comparer = _SEMANTIC_EQ_CONTROL_FLOW.get(type(node1.op))
+        if comparer is None:  # pragma: no cover
+            raise RuntimeError(f"unhandled control-flow operation: {type(node1.op)}")
+        return comparer(node1, node2, bit_indices1, bit_indices2)
+
+    node1_qargs = [bit_indices1[qarg] for qarg in node1.qargs]
+    node1_cargs = [bit_indices1[carg] for carg in node1.cargs]
+
+    node2_qargs = [bit_indices2[qarg] for qarg in node2.qargs]
+    node2_cargs = [bit_indices2[carg] for carg in node2.cargs]
+
+    # For barriers, qarg order is not significant so compare as sets
+    if node1.op.name == node2.op.name and node1.name in _SEMANTIC_EQ_SYMMETRIC:
+        node1_qargs = set(node1_qargs)
+        node1_cargs = set(node1_cargs)
+        node2_qargs = set(node2_qargs)
+        node2_cargs = set(node2_cargs)
+
+    return (
+        node1_qargs == node2_qargs
+        and node1_cargs == node2_cargs
+        and _legacy_condition_eq(
+            getattr(node1.op, "condition", None),
+            getattr(node2.op, "condition", None),
+            bit_indices1,
+            bit_indices2,
+        )
+        and node1.op == node2.op
+    )
 
 
-class DAGOpNode(DAGNode):
-    """Object to represent an Instruction at a node in the DAGCircuit."""
-
-    __slots__ = ["op", "qargs", "cargs", "sort_key"]
-
-    def __init__(
-        self, op: Operation, qargs: Iterable[Qubit] = (), cargs: Iterable[Clbit] = (), dag=None
-    ):
-        """Create an Instruction node"""
-        super().__init__()
-        self.op = op
-        self.qargs = tuple(qargs)
-        self.cargs = tuple(cargs)
-        if dag is not None:
-            cache_key = (self.qargs, self.cargs)
-            key = dag._key_cache.get(cache_key, None)
-            if key is not None:
-                self.sort_key = key
-            else:
-                self.sort_key = ",".join(
-                    f"{dag.find_bit(q).index:04d}" for q in itertools.chain(*cache_key)
-                )
-                dag._key_cache[cache_key] = self.sort_key
-        else:
-            self.sort_key = str(self.qargs)
-
-    @property
-    def name(self):
-        """Returns the Instruction name corresponding to the op for this node"""
-        return self.op.name
-
-    @name.setter
-    def name(self, new_name):
-        """Sets the Instruction name corresponding to the op for this node"""
-        self.op.name = new_name
-
-    def __repr__(self):
-        """Returns a representation of the DAGOpNode"""
-        return f"DAGOpNode(op={self.op}, qargs={self.qargs}, cargs={self.cargs})"
-
-
-class DAGInNode(DAGNode):
-    """Object to represent an incoming wire node in the DAGCircuit."""
-
-    __slots__ = ["wire", "sort_key"]
-
-    def __init__(self, wire):
-        """Create an incoming node"""
-        super().__init__()
-        self.wire = wire
-        # TODO sort_key which is used in dagcircuit.topological_nodes
-        # only works as str([]) for DAGInNodes. Need to figure out why.
-        self.sort_key = str([])
-
-    def __repr__(self):
-        """Returns a representation of the DAGInNode"""
-        return f"DAGInNode(wire={self.wire})"
-
-
-class DAGOutNode(DAGNode):
-    """Object to represent an outgoing wire node in the DAGCircuit."""
-
-    __slots__ = ["wire", "sort_key"]
-
-    def __init__(self, wire):
-        """Create an outgoing node"""
-        super().__init__()
-        self.wire = wire
-        # TODO sort_key which is used in dagcircuit.topological_nodes
-        # only works as str([]) for DAGOutNodes. Need to figure out why.
-        self.sort_key = str([])
-
-    def __repr__(self):
-        """Returns a representation of the DAGOutNode"""
-        return f"DAGOutNode(wire={self.wire})"
+# Bind semantic_eq from Python to Rust implementation
+DAGNode.semantic_eq = staticmethod(_semantic_eq)

qiskit/passmanager/flow_controllers.py

@@ -84,7 +84,7 @@ class DoWhileController(BaseController):
                 return
             # Remove stored tasks from the completed task collection for next loop
             state.workflow_status.completed_passes.difference_update(self.tasks)
-        raise PassManagerError("Maximum iteration reached. max_iteration=%i" % max_iteration)
+        raise PassManagerError(f"Maximum iteration reached. max_iteration={max_iteration}")
 
 
 class ConditionalController(BaseController):

qiskit/passmanager/passmanager.py

@@ -130,7 +130,7 @@ class BasePassManager(ABC):
                 return new_passmanager
             except PassManagerError as ex:
                 raise TypeError(
-                    "unsupported operand type + for %s and %s" % (self.__class__, other.__class__)
+                    f"unsupported operand type + for {self.__class__} and {other.__class__}"
                 ) from ex
 
     @abstractmethod
@@ -225,7 +225,7 @@ class BasePassManager(ABC):
             in_programs = [in_programs]
             is_list = False
 
-        # If we're not going to run in parallel, we want to avoid spending time `dill` serialising
+        # If we're not going to run in parallel, we want to avoid spending time `dill` serializing
         # ourselves, since that can be quite expensive.
         if len(in_programs) == 1 or not should_run_in_parallel(num_processes):
             out = [
@@ -242,7 +242,7 @@ class BasePassManager(ABC):
         # Pass manager may contain callable and we need to serialize through dill rather than pickle.
         # See https://github.com/Qiskit/qiskit-terra/pull/3290
         # Note that serialized object is deserialized as a different object.
-        # Thus, we can resue the same manager without state collision, without building it per thread.
+        # Thus, we can reuse the same manager without state collision, without building it per thread.
         return parallel_map(
             _run_workflow_in_new_process,
             values=in_programs,

qiskit/primitives/__init__.py

@@ -420,7 +420,6 @@ Results V2
    SamplerPubResult
    BasePrimitiveJob
    PrimitiveJob
-   Shaped
 
 Estimator V1
 ------------
@@ -466,16 +465,13 @@ from .containers import (
     DataBin,
     PrimitiveResult,
     PubResult,
-    SamplerPubResult,
     EstimatorPubLike,
     SamplerPubLike,
+    SamplerPubResult,
     BindingsArrayLike,
     ObservableLike,
     ObservablesArrayLike,
-    Shaped,
 )
-
-
 from .estimator import Estimator
 from .primitive_job import BasePrimitiveJob, PrimitiveJob
 from .sampler import Sampler

qiskit/primitives/backend_estimator.py

@@ -9,9 +9,8 @@
 # Any modifications or derivative works of this code must retain this
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
-"""
-Expectation value class
-"""
+
+"""Estimator V1 implementation for an arbitrary Backend object."""
 
 from __future__ import annotations
 
@@ -35,6 +34,7 @@ from qiskit.transpiler.passes import (
     Optimize1qGatesDecomposition,
     SetLayout,
 )
+from qiskit.utils.deprecation import deprecate_func
 
 from .base import BaseEstimator, EstimatorResult
 from .primitive_job import PrimitiveJob
@@ -65,6 +65,8 @@ def _run_circuits(
         max_circuits = getattr(backend.configuration(), "max_experiments", None)
     elif 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)
@@ -90,18 +92,26 @@ class BackendEstimator(BaseEstimator[PrimitiveJob[EstimatorResult]]):
     """Evaluates expectation value using Pauli rotation gates.
 
     The :class:`~.BackendEstimator` class is a generic implementation of the
-    :class:`~.BaseEstimator` interface that is used to wrap a :class:`~.BackendV2`
-    (or :class:`~.BackendV1`) object in the :class:`~.BaseEstimator` API. It
+    :class:`~.BaseEstimator` (V1) interface that is used to wrap a :class:`~.BackendV2`
+    (or :class:`~.BackendV1`) object in the :class:`~.BaseEstimator` V1 API. It
     facilitates using backends that do not provide a native
-    :class:`~.BaseEstimator` implementation in places that work with
-    :class:`~.BaseEstimator`. However,
-    if you're using a provider that has a native implementation of
-    :class:`~.BaseEstimator`, it is a better choice to leverage that native
-    implementation as it will likely include additional optimizations and be
-    a more efficient implementation. The generic nature of this class
-    precludes doing any provider- or backend-specific optimizations.
+    :class:`~.BaseEstimator` V1 implementation in places that work with
+    :class:`~.BaseEstimator` V1.
+    However, if you're using a provider that has a native implementation of
+    :class:`~.BaseEstimatorV1` ( :class:`~.BaseEstimator`) or
+    :class:`~.BaseEstimatorV2`, it is a better
+    choice to leverage that native implementation as it will likely include
+    additional optimizations and be a more efficient implementation.
+    The generic nature of this class precludes doing any provider- or
+    backend-specific optimizations.
     """
 
+    @deprecate_func(
+        since="1.2",
+        additional_msg="All implementations of the `BaseEstimatorV1` interface "
+        "have been deprecated in favor of their V2 counterparts. "
+        "The V2 alternative for the `BackendEstimator` class is `BackendEstimatorV2`.",
+    )
     def __init__(
         self,
         backend: BackendV1 | BackendV2,
@@ -110,10 +120,10 @@ class BackendEstimator(BaseEstimator[PrimitiveJob[EstimatorResult]]):
         bound_pass_manager: PassManager | None = None,
         skip_transpilation: bool = False,
     ):
-        """Initialize a new BackendEstimator instance
+        """Initialize a new BackendEstimator (V1) instance
 
         Args:
-            backend: Required: the backend to run the primitive on
+            backend: (required) the backend to run the primitive on
             options: Default options.
             abelian_grouping: Whether the observable should be grouped into
                 commuting
@@ -198,7 +208,7 @@ class BackendEstimator(BaseEstimator[PrimitiveJob[EstimatorResult]]):
                 transpiled_circuit = common_circuit.copy()
                 final_index_layout = list(range(common_circuit.num_qubits))
             else:
-                transpiled_circuit = transpile(
+                transpiled_circuit = transpile(  # pylint:disable=unexpected-keyword-arg
                     common_circuit, self.backend, **self.transpile_options.__dict__
                 )
                 if transpiled_circuit.layout is not None:

qiskit/primitives/backend_estimator_v2.py

@@ -72,7 +72,7 @@ class _PreprocessedData:
 
 
 class BackendEstimatorV2(BaseEstimatorV2):
-    """Evaluates expectation values for provided quantum circuit and observable combinations
+    r"""Evaluates expectation values for provided quantum circuit and observable combinations.
 
     The :class:`~.BackendEstimatorV2` class is a generic implementation of the
     :class:`~.BaseEstimatorV2` interface that is used to wrap a :class:`~.BackendV2`
@@ -87,7 +87,19 @@ class BackendEstimatorV2(BaseEstimatorV2):
     precludes doing any provider- or backend-specific optimizations.
 
     This class does not perform any measurement or gate mitigation, and, presently, is only
-    compatible with Pauli-based observables.
+    compatible with Pauli-based observables. More formally, given an observable of the type
+    :math:`O=\sum_{i=1}^Na_iP_i`, where :math:`a_i` is a complex number and :math:`P_i` is a
+    Pauli operator, the estimator calculates the expectation :math:`\mathbb{E}(P_i)` of each
+    :math:`P_i` and finally calculates the expectation value of :math:`O` as
+    :math:`\mathbb{E}(O)=\sum_{i=1}^Na_i\mathbb{E}(P_i)`. The reported ``std`` is calculated
+    as
+
+    .. math::
+
+        \frac{\sum_{i=1}^{n}|a_i|\sqrt{\textrm{Var}\big(P_i\big)}}{\sqrt{N}}\:,
+
+    where :math:`\textrm{Var}(P_i)` is the variance of :math:`P_i`, :math:`N=O(\epsilon^{-2})` is
+    the number of shots, and :math:`\epsilon` is the target precision [1].
 
     Each tuple of ``(circuit, observables, <optional> parameter values, <optional> precision)``,
     called an estimator primitive unified bloc (PUB), produces its own array-based result. The
@@ -104,6 +116,12 @@ class BackendEstimatorV2(BaseEstimatorV2):
 
     * ``seed_simulator``: The seed to use in the simulator. If None, a random seed will be used.
       Default: None.
+
+    **Reference:**
+
+    [1] O. Crawford, B. van Straaten, D. Wang, T. Parks, E. Campbell, St. Brierley,
+    Efficient quantum measurement of Pauli operators in the presence of finite sampling error.
+    `Quantum 5, 385 <https://doi.org/10.22331/q-2021-01-20-385>`_
     """
 
     def __init__(
@@ -172,7 +190,7 @@ class BackendEstimatorV2(BaseEstimatorV2):
             # reconstruct the result of pubs
             for i, pub_result in zip(lst, pub_results):
                 results[i] = pub_result
-        return PrimitiveResult(results)
+        return PrimitiveResult(results, metadata={"version": 2})
 
     def _run_pubs(self, pubs: list[EstimatorPub], shots: int) -> list[PubResult]:
         """Compute results for pubs that all require the same value of ``shots``."""
@@ -220,7 +238,6 @@ class BackendEstimatorV2(BaseEstimatorV2):
         param_indices = np.fromiter(np.ndindex(param_shape), dtype=object).reshape(param_shape)
         bc_param_ind, bc_obs = np.broadcast_arrays(param_indices, observables)
 
-        # calculate expectation values for each pair of parameter value set and pauli
         param_obs_map = defaultdict(set)
         for index in np.ndindex(*bc_param_ind.shape):
             param_index = bc_param_ind[index]
@@ -254,10 +271,17 @@ class BackendEstimatorV2(BaseEstimatorV2):
             for pauli, coeff in bc_obs[index].items():
                 expval, variance = expval_map[param_index, pauli]
                 evs[index] += expval * coeff
-                variances[index] += variance * coeff**2
-        stds = np.sqrt(variances / shots)
+                variances[index] += np.abs(coeff) * variance**0.5
+        stds = variances / np.sqrt(shots)
         data_bin = DataBin(evs=evs, stds=stds, shape=evs.shape)
-        return PubResult(data_bin, metadata={"target_precision": pub.precision})
+        return PubResult(
+            data_bin,
+            metadata={
+                "target_precision": pub.precision,
+                "shots": shots,
+                "circuit_metadata": pub.circuit.metadata,
+            },
+        )
 
     def _bind_and_add_measurements(
         self,

qiskit/primitives/backend_sampler.py

@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Sampler implementation for an arbitrary Backend object."""
+"""Sampler V1 implementation for an arbitrary Backend object."""
 
 from __future__ import annotations
 
@@ -23,6 +23,7 @@ from qiskit.providers.backend import BackendV1, BackendV2
 from qiskit.providers.options import Options
 from qiskit.result import QuasiDistribution, Result
 from qiskit.transpiler.passmanager import PassManager
+from qiskit.utils.deprecation import deprecate_func
 
 from .backend_estimator import _prepare_counts, _run_circuits
 from .base import BaseSampler, SamplerResult
@@ -31,21 +32,29 @@ from .utils import _circuit_key
 
 
 class BackendSampler(BaseSampler[PrimitiveJob[SamplerResult]]):
-    """A :class:`~.BaseSampler` implementation that provides an interface for
-    leveraging the sampler interface from any backend.
+    """A :class:`~.BaseSampler` (V1) implementation that provides a wrapper for
+    leveraging the Sampler V1 interface from any backend.
 
     This class provides a sampler interface from any backend and doesn't do
     any measurement mitigation, it just computes the probability distribution
     from the counts. It facilitates using backends that do not provide a
-    native :class:`~.BaseSampler` implementation in places that work with
-    :class:`~.BaseSampler`.
+    native :class:`~.BaseSampler` V1 implementation in places that work with
+    :class:`~.BaseSampler` V1.
     However, if you're using a provider that has a native implementation of
-    :class:`~.BaseSampler`, it is a better choice to leverage that native
-    implementation as it will likely include additional optimizations and be
-    a more efficient implementation. The generic nature of this class
-    precludes doing any provider- or backend-specific optimizations.
+    :class:`~.BaseSamplerV1` ( :class:`~.BaseSampler`) or
+    :class:`~.BaseESamplerV2`, it is a better
+    choice to leverage that native implementation as it will likely include
+    additional optimizations and be a more efficient implementation.
+    The generic nature of this class precludes doing any provider- or
+    backend-specific optimizations.
     """
 
+    @deprecate_func(
+        since="1.2",
+        additional_msg="All implementations of the `BaseSamplerV1` interface "
+        "have been deprecated in favor of their V2 counterparts. "
+        "The V2 alternative for the `BackendSampler` class is `BackendSamplerV2`.",
+    )
     def __init__(
         self,
         backend: BackendV1 | BackendV2,
@@ -53,10 +62,10 @@ class BackendSampler(BaseSampler[PrimitiveJob[SamplerResult]]):
         bound_pass_manager: PassManager | None = None,
         skip_transpilation: bool = False,
     ):
-        """Initialize a new BackendSampler
+        """Initialize a new BackendSampler (V1) instance
 
         Args:
-            backend: Required: the backend to run the sampler primitive on
+            backend: (required) the backend to run the sampler primitive on
             options: Default options.
             bound_pass_manager: An optional pass manager to run after
                 parameter binding.
@@ -176,7 +185,7 @@ class BackendSampler(BaseSampler[PrimitiveJob[SamplerResult]]):
 
         start = len(self._transpiled_circuits)
         self._transpiled_circuits.extend(
-            transpile(
+            transpile(  # pylint:disable=unexpected-keyword-arg
                 self.preprocessed_circuits[start:],
                 self.backend,
                 **self.transpile_options.__dict__,