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

qiskit/circuit/twirling.py

@@ -0,0 +1,145 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# 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.
+
+"""The twirling module."""
+
+from __future__ import annotations
+import typing
+
+from qiskit._accelerate.twirling import twirl_circuit as twirl_rs
+from qiskit.circuit.quantumcircuit import QuantumCircuit, _copy_metadata
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.library.standard_gates import CXGate, ECRGate, CZGate, iSwapGate
+from qiskit.exceptions import QiskitError
+
+if typing.TYPE_CHECKING:
+    from qiskit.transpiler.target import Target
+
+
+NAME_TO_CLASS = {
+    "cx": CXGate._standard_gate,
+    "ecr": ECRGate._standard_gate,
+    "cz": CZGate._standard_gate,
+    "iswap": iSwapGate._standard_gate,
+}
+
+
+def pauli_twirl_2q_gates(
+    circuit: QuantumCircuit,
+    twirling_gate: None | str | Gate | list[str] | list[Gate] = None,
+    seed: int | None = None,
+    num_twirls: int | None = None,
+    target: Target | None = None,
+) -> QuantumCircuit | list[QuantumCircuit]:
+    """Create copies of a given circuit with Pauli twirling applied around specified two qubit
+    gates.
+
+    If you're running this function with the intent to twirl a circuit to run on hardware this
+    may not be the most efficient way to perform twirling. Especially if the hardware vendor
+    has implemented the :mod:`.primitives` execution interface with :class:`.SamplerV2` and
+    :class:`.EstimatorV2` this most likely is not the best way to apply twirling to your
+    circuit and you'll want to refer to the implementation of :class:`.SamplerV2` and/or
+    :class:`.EstimatorV2` for the specified hardware vendor.
+
+    If the intent of this function is to be run after :func:`.transpile` or
+    :meth:`.PassManager.run` the optional ``target`` argument can be used
+    so that the inserted 1 qubit Pauli gates are synthesized to be
+    compatible with the given :class:`.Target` so the output circuit(s) are
+    still compatible.
+
+    Args:
+        circuit: The circuit to twirl
+        twirling_gate: The gate to twirl, defaults to `None` which means twirl all default gates:
+            :class:`.CXGate`, :class:`.CZGate`, :class:`.ECRGate`, and :class:`.iSwapGate`.
+            If supplied it can either be a single gate or a list of gates either as either a gate
+            object or its string name. Currently only the names `"cx"`, `"cz"`, `"ecr"`,  and
+            `"iswap"` are supported. If a gate object is provided outside the default gates it must
+            have a matrix defined from its :class:`~.Gate.to_matrix` method for the gate to potentially
+            be twirled. If a valid twirling configuration can't be computed that particular gate will
+            be silently ignored and not twirled.
+        seed: An integer seed for the random number generator used internally by this function.
+            If specified this must be between 0 and 18,446,744,073,709,551,615.
+        num_twirls: The number of twirling circuits to build. This defaults to ``None`` and will return
+            a single circuit. If it is an integer a list of circuits with `num_twirls` circuits
+            will be returned.
+        target: If specified an :class:`.Target` instance to use for running single qubit decomposition
+            as part of the Pauli twirling to optimize and map the pauli gates added to the circuit
+            to the specified target.
+
+    Returns:
+        A copy of the given circuit with Pauli twirling applied to each
+        instance of the specified twirling gate.
+    """
+    custom_gates = None
+    if isinstance(twirling_gate, str):
+        gate = NAME_TO_CLASS.get(twirling_gate, None)
+        if gate is None:
+            raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
+        twirling_std_gate = [gate]
+    elif isinstance(twirling_gate, list):
+        custom_gates = []
+        twirling_std_gate = []
+        for gate in twirling_gate:
+            if isinstance(gate, str):
+                gate = NAME_TO_CLASS.get(gate, None)
+                if gate is None:
+                    raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
+                twirling_std_gate.append(gate)
+            else:
+                twirling_gate = getattr(gate, "_standard_gate", None)
+
+                if twirling_gate is None:
+                    custom_gates.append(gate)
+                else:
+                    if twirling_gate in NAME_TO_CLASS.values():
+                        twirling_std_gate.append(twirling_gate)
+                    else:
+                        custom_gates.append(gate)
+        if not custom_gates:
+            custom_gates = None
+        if not twirling_std_gate:
+            twirling_std_gate = None
+    elif twirling_gate is not None:
+        std_gate = getattr(twirling_gate, "_standard_gate", None)
+        if std_gate is None:
+            twirling_std_gate = None
+            custom_gates = [twirling_gate]
+        else:
+            if std_gate in NAME_TO_CLASS.values():
+                twirling_std_gate = [std_gate]
+            else:
+                twirling_std_gate = None
+                custom_gates = [twirling_gate]
+    else:
+        twirling_std_gate = twirling_gate
+    out_twirls = num_twirls
+    if out_twirls is None:
+        out_twirls = 1
+    new_data = twirl_rs(
+        circuit._data,
+        twirling_std_gate,
+        custom_gates,
+        seed,
+        out_twirls,
+        target,
+    )
+    if num_twirls is not None:
+        out_list = []
+        for circ in new_data:
+            new_circ = QuantumCircuit._from_circuit_data(circ)
+            _copy_metadata(circuit, new_circ, "alike")
+            out_list.append(new_circ)
+        return out_list
+    else:
+        out_circ = QuantumCircuit._from_circuit_data(new_data[0])
+        _copy_metadata(circuit, out_circ, "alike")
+        return out_circ

qiskit/compiler/assembler.py

@@ -189,6 +189,16 @@ def assemble(
     )
 
 
+# Note for future: this method is used in `BasicSimulator` and may need to be kept past the
+# `assemble` removal deadline (2.0). If it is kept (potentially in a different location),
+# we will need an alternative for the backend.configuration() access that currently takes
+# place in L566 (`parse_circuit_args`) and L351 (`parse_common_args`)
+# because backend.configuration() is also set for removal in 2.0.
+# The ultimate goal will be to move away from relying on any kind of `assemble` implementation
+# because of how tightly coupled it is to these legacy data structures. But as a transition step,
+# given that we would only have to support the subcase of `BasicSimulator`, we could probably just
+# inline the relevant config values that are already hardcoded in the basic simulator configuration
+# generator.
 def _assemble(
     experiments: Union[
         QuantumCircuit,
@@ -229,7 +239,7 @@ def _assemble(
     experiments = experiments if isinstance(experiments, list) else [experiments]
     pulse_qobj = any(isinstance(exp, (ScheduleBlock, Schedule, Instruction)) for exp in experiments)
     with warnings.catch_warnings():
-        # The Qobj is deprecated
+        # The Qobj class is deprecated, the backend.configuration() method is too
         warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
         qobj_id, qobj_header, run_config_common_dict = _parse_common_args(
             backend,
@@ -554,9 +564,12 @@ def _parse_circuit_args(
     run_config_dict = {"parameter_binds": parameter_binds, **run_config}
     if parametric_pulses is None:
         if backend:
-            run_config_dict["parametric_pulses"] = getattr(
-                backend.configuration(), "parametric_pulses", []
-            )
+            with warnings.catch_warnings():
+                # TODO (2.0): See comment on L192 regarding backend.configuration removal
+                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                run_config_dict["parametric_pulses"] = getattr(
+                    backend.configuration(), "parametric_pulses", []
+                )
         else:
             run_config_dict["parametric_pulses"] = []
     else:

qiskit/compiler/scheduler.py

@@ -26,6 +26,7 @@ from qiskit.providers.backend import Backend
 from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.schedule_circuit import schedule_circuit
 from qiskit.utils.parallel import parallel_map
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +36,7 @@ def _log_schedule_time(start_time, end_time):
     logger.info(log_msg)
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def schedule(
     circuits: Union[QuantumCircuit, List[QuantumCircuit]],
     backend: Optional[Backend] = None,

qiskit/compiler/sequencer.py

@@ -21,8 +21,10 @@ from qiskit.providers.backend import Backend
 from qiskit.pulse import InstructionScheduleMap, Schedule
 from qiskit.scheduler import ScheduleConfig
 from qiskit.scheduler.sequence import sequence as _sequence
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
+@deprecate_pulse_dependency(moving_to_dynamics=True)
 def sequence(
     scheduled_circuits: Union[QuantumCircuit, List[QuantumCircuit]],
     backend: Optional[Backend] = None,

qiskit/compiler/transpiler.py

@@ -32,12 +32,41 @@ from qiskit.transpiler.instruction_durations import InstructionDurationsType
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from qiskit.transpiler.target import Target
+from qiskit.utils import deprecate_arg
+from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 logger = logging.getLogger(__name__)
 
 _CircuitT = TypeVar("_CircuitT", bound=Union[QuantumCircuit, List[QuantumCircuit]])
 
 
+@deprecate_arg(
+    name="instruction_durations",
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
+    "with defined instruction durations with "
+    "`Target.from_configuration(..., instruction_durations=...)`",
+)
+@deprecate_arg(
+    name="timing_constraints",
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
+    "with defined timing constraints with "
+    "`Target.from_configuration(..., timing_constraints=...)`",
+)
+@deprecate_arg(
+    name="backend_properties",
+    since="1.3",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
+    "with defined properties with Target.from_configuration(..., backend_properties=...)",
+)
+@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
 def transpile(  # pylint: disable=too-many-return-statements
     circuits: _CircuitT,
     backend: Optional[Backend] = None,
@@ -104,7 +133,7 @@ def transpile(  # pylint: disable=too-many-return-statements
             will override the backend's.
         basis_gates: List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``). If ``None``, do not unroll.
-        inst_map: Mapping of unrolled gates to pulse schedules. If this is not provided,
+        inst_map: DEPRECATED. Mapping of unrolled gates to pulse schedules. If this is not provided,
             transpiler tries to get from the backend. If any user defined calibration
             is found in the map and this is used in a circuit, transpiler attaches
             the custom gate definition to the circuit. This enables one to flexibly
@@ -365,31 +394,57 @@ def transpile(  # pylint: disable=too-many-return-statements
     # Edge cases require using the old model (loose constraints) instead of building a target,
     # but we don't populate the passmanager config with loose constraints unless it's one of
     # the known edge cases to control the execution path.
-    pm = generate_preset_pass_manager(
-        optimization_level,
-        target=target,
-        backend=backend,
-        basis_gates=basis_gates,
-        coupling_map=coupling_map,
-        instruction_durations=instruction_durations,
-        backend_properties=backend_properties,
-        timing_constraints=timing_constraints,
-        inst_map=inst_map,
-        initial_layout=initial_layout,
-        layout_method=layout_method,
-        routing_method=routing_method,
-        translation_method=translation_method,
-        scheduling_method=scheduling_method,
-        approximation_degree=approximation_degree,
-        seed_transpiler=seed_transpiler,
-        unitary_synthesis_method=unitary_synthesis_method,
-        unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
-        hls_config=hls_config,
-        init_method=init_method,
-        optimization_method=optimization_method,
-        dt=dt,
-        qubits_initially_zero=qubits_initially_zero,
-    )
+    # Filter instruction_durations, timing_constraints, backend_properties and inst_map deprecation
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
+            module="qiskit",
+        )
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*``timing_constraints`` is deprecated as of Qiskit 1.3.*",
+            module="qiskit",
+        )
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*``instruction_durations`` is deprecated as of Qiskit 1.3.*",
+            module="qiskit",
+        )
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*``backend_properties`` is deprecated as of Qiskit 1.3.*",
+            module="qiskit",
+        )
+        pm = generate_preset_pass_manager(
+            optimization_level,
+            target=target,
+            backend=backend,
+            basis_gates=basis_gates,
+            coupling_map=coupling_map,
+            instruction_durations=instruction_durations,
+            backend_properties=backend_properties,
+            timing_constraints=timing_constraints,
+            inst_map=inst_map,
+            initial_layout=initial_layout,
+            layout_method=layout_method,
+            routing_method=routing_method,
+            translation_method=translation_method,
+            scheduling_method=scheduling_method,
+            approximation_degree=approximation_degree,
+            seed_transpiler=seed_transpiler,
+            unitary_synthesis_method=unitary_synthesis_method,
+            unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
+            hls_config=hls_config,
+            init_method=init_method,
+            optimization_method=optimization_method,
+            dt=dt,
+            qubits_initially_zero=qubits_initially_zero,
+        )
 
     out_circuits = pm.run(circuits, callback=callback, num_processes=num_processes)
 

qiskit/converters/circuit_to_dag.py

@@ -73,6 +73,6 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
-    dagcircuit.duration = circuit.duration
-    dagcircuit.unit = circuit.unit
+    dagcircuit.duration = circuit._duration
+    dagcircuit.unit = circuit._unit
     return dagcircuit

qiskit/converters/circuit_to_dagdependency.py

@@ -46,6 +46,6 @@ def circuit_to_dagdependency(circuit, create_preds_and_succs=True):
         dagdependency._add_predecessors()
         dagdependency._add_successors()
 
-    dagdependency.calibrations = circuit.calibrations
+    dagdependency._calibrations = circuit._calibrations_prop
 
     return dagdependency

qiskit/converters/circuit_to_dagdependency_v2.py

@@ -27,7 +27,7 @@ def _circuit_to_dagdependency_v2(circuit):
     dagdependency = _DAGDependencyV2()
     dagdependency.name = circuit.name
     dagdependency.metadata = circuit.metadata
-    dagdependency.calibrations = circuit.calibrations
+    dagdependency._calibrations = circuit._calibrations_prop
     dagdependency.global_phase = circuit.global_phase
 
     dagdependency.add_qubits(circuit.qubits)

qiskit/converters/circuit_to_instruction.py

@@ -125,7 +125,7 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
         if (out := operation_map.get(original_id)) is not None:
             return out
 
-        condition = getattr(op, "condition", None)
+        condition = getattr(op, "_condition", None)
         if condition:
             reg, val = condition
             if isinstance(reg, Clbit):

qiskit/converters/dag_to_circuit.py

@@ -13,6 +13,7 @@
 """Helper function for converting a dag to a circuit."""
 
 from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.converters import dag_to_circuit as dag_to_circuit_rs
 
 
 def dag_to_circuit(dag, copy_operations=True):
@@ -54,6 +55,8 @@ def dag_to_circuit(dag, copy_operations=True):
     """
 
     name = dag.name or None
+
+    circuit_data = dag_to_circuit_rs(dag, copy_operations)
     circuit = QuantumCircuit(
         dag.qubits,
         dag.clbits,
@@ -67,11 +70,10 @@ def dag_to_circuit(dag, copy_operations=True):
     for var in dag.iter_declared_vars():
         circuit.add_uninitialized_var(var)
     circuit.metadata = dag.metadata
-    circuit.calibrations = dag.calibrations
+    circuit._calibrations_prop = dag._calibrations_prop
 
-    for node in dag.topological_op_nodes():
-        circuit._append(node._to_circuit_instruction(deepcopy=copy_operations))
+    circuit._data = circuit_data
 
-    circuit.duration = dag.duration
-    circuit.unit = dag.unit
+    circuit._duration = dag.duration
+    circuit._unit = dag.unit
     return circuit

qiskit/converters/dag_to_dagdependency.py

@@ -50,6 +50,6 @@ def dag_to_dagdependency(dag, create_preds_and_succs=True):
 
     # copy metadata
     dagdependency.global_phase = dag.global_phase
-    dagdependency.calibrations = dag.calibrations
+    dagdependency._calibrations_prop = dag._calibrations_prop
 
     return dagdependency

qiskit/converters/dag_to_dagdependency_v2.py

@@ -27,7 +27,7 @@ def _dag_to_dagdependency_v2(dag):
     dagdependency.name = dag.name
     dagdependency.metadata = dag.metadata
     dagdependency.global_phase = dag.global_phase
-    dagdependency.calibrations = dag.calibrations
+    dagdependency.calibrations = dag._calibrations_prop
 
     dagdependency.add_qubits(dag.qubits)
     dagdependency.add_clbits(dag.clbits)

qiskit/converters/dagdependency_to_circuit.py

@@ -34,7 +34,11 @@ def dagdependency_to_circuit(dagdependency):
     )
     circuit.metadata = dagdependency.metadata
 
-    circuit.calibrations = dagdependency.calibrations
+    if hasattr(dagdependency, "_calibrations_prop"):
+        circuit._calibrations_prop = dagdependency._calibrations_prop
+    else:
+        # This can be _DAGDependencyV2
+        circuit._calibrations_prop = dagdependency.calibrations
 
     for node in dagdependency.topological_nodes():
         circuit._append(CircuitInstruction(node.op.copy(), node.qargs, node.cargs))

qiskit/converters/dagdependency_to_dag.py

@@ -12,6 +12,7 @@
 
 """Helper function for converting a dag dependency to a dag circuit"""
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagdependency import DAGDependency
 
 
 def dagdependency_to_dag(dagdependency):
@@ -44,6 +45,10 @@ def dagdependency_to_dag(dagdependency):
 
     # copy metadata
     dagcircuit.global_phase = dagdependency.global_phase
-    dagcircuit.calibrations = dagdependency.calibrations
+    if isinstance(dagdependency, DAGDependency):
+        dagcircuit._calibrations_prop = dagdependency._calibrations_prop
+    else:
+        # This can be _DAGDependencyV2
+        dagcircuit._calibrations_prop = dagdependency.calibrations
 
     return dagcircuit

qiskit/dagcircuit/collect_blocks.py

@@ -306,7 +306,7 @@ def split_block_into_layers(block: list[DAGOpNode | DAGDepNode]):
         cur_bits = set(node.qargs)
         cur_bits.update(node.cargs)
 
-        cond = getattr(node.op, "condition", None)
+        cond = getattr(node.op, "_condition", None)
         if cond is not None:
             cur_bits.update(condition_resources(cond).clbits)
 
@@ -356,7 +356,7 @@ class BlockCollapser:
             for node in block:
                 cur_qubits.update(node.qargs)
                 cur_clbits.update(node.cargs)
-                cond = getattr(node.op, "condition", None)
+                cond = getattr(node.op, "_condition", None)
                 if cond is not None:
                     cur_clbits.update(condition_resources(cond).clbits)
                     if isinstance(cond[0], ClassicalRegister):
@@ -378,7 +378,7 @@ class BlockCollapser:
 
             for node in block:
                 instructions = qc.append(CircuitInstruction(node.op, node.qargs, node.cargs))
-                cond = getattr(node.op, "condition", None)
+                cond = getattr(node.op, "_condition", None)
                 if cond is not None:
                     instructions.c_if(*cond)
 

qiskit/dagcircuit/dagdependency.py

@@ -29,6 +29,7 @@ from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
 from qiskit.dagcircuit.exceptions import DAGDependencyError
 from qiskit.dagcircuit.dagdepnode import DAGDepNode
 from qiskit.pulse import Schedule
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 if typing.TYPE_CHECKING:
     from qiskit.circuit.parameterexpression import ParameterExpression
@@ -71,7 +72,7 @@ class DAGDependency:
 
     Bell circuit with no measurement.
 
-    .. parsed-literal::
+    .. code-block:: text
 
               ┌───┐
         qr_0: ┤ H ├──■──
@@ -146,15 +147,17 @@ class DAGDependency:
                 self._global_phase = angle % (2 * math.pi)
 
     @property
+    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self) -> dict[str, dict[tuple, Schedule]]:
         """Return calibration dictionary.
 
         The custom pulse definition of a given gate is of the form
         ``{'gate_name': {(qubits, params): schedule}}``.
         """
-        return dict(self._calibrations)
+        return self._calibrations_prop
 
     @calibrations.setter
+    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self, calibrations: dict[str, dict[tuple, Schedule]]):
         """Set the circuit calibration data from a dictionary of calibration definition.
 
@@ -162,6 +165,16 @@ class DAGDependency:
             calibrations (dict): A dictionary of input in the format
                 {'gate_name': {(qubits, gate_params): schedule}}
         """
+        self._calibrations_prop = calibrations
+
+    @property
+    def _calibrations_prop(self) -> dict[str, dict[tuple, Schedule]]:
+        """An alternative path to be used internally to avoid deprecation warnings"""
+        return dict(self._calibrations)
+
+    @_calibrations_prop.setter
+    def _calibrations_prop(self, calibrations: dict[str, dict[tuple, Schedule]]):
+        """An alternative path to be used internally to avoid deprecation warnings"""
         self._calibrations = defaultdict(dict, calibrations)
 
     def to_retworkx(self):
@@ -396,13 +409,13 @@ class DAGDependency:
             for elem in qargs:
                 qindices_list.append(self.qubits.index(elem))
 
-            if getattr(operation, "condition", None):
+            if getattr(operation, "_condition", None):
                 # The change to handling operation.condition follows code patterns in quantum_circuit.py.
                 # However:
                 #   (1) cindices_list are specific to template optimization and should not be computed
                 #       in this place.
                 #   (2) Template optimization pass needs currently does not handle general conditions.
-                cond_bits = condition_resources(operation.condition).clbits
+                cond_bits = condition_resources(operation._condition).clbits
                 cindices_list = [self.clbits.index(clbit) for clbit in cond_bits]
             else:
                 cindices_list = []
@@ -596,7 +609,7 @@ class DAGDependency:
         for nd in node_block:
             block_qargs |= set(nd.qargs)
             block_cargs |= set(nd.cargs)
-            cond = getattr(nd.op, "condition", None)
+            cond = getattr(nd.op, "_condition", None)
             if cond is not None:
                 block_cargs.update(condition_resources(cond).clbits)
 

qiskit/dagcircuit/dagdependency_v2.py

@@ -56,7 +56,7 @@ class _DAGDependencyV2:
 
     Bell circuit with no measurement.
 
-    .. parsed-literal::
+    .. code-block:: text
 
               ┌───┐
         qr_0: ┤ H ├──■──

qiskit/dagcircuit/dagnode.py

@@ -92,8 +92,8 @@ def _make_expr_key(bit_indices):
 
 
 def _condition_op_eq(node1, node2, bit_indices1, bit_indices2):
-    cond1 = node1.op.condition
-    cond2 = node2.op.condition
+    cond1 = node1.condition
+    cond2 = node2.condition
     if isinstance(cond1, expr.Expr) and isinstance(cond2, expr.Expr):
         if not expr.structurally_equivalent(
             cond1, cond2, _make_expr_key(bit_indices1), _make_expr_key(bit_indices2)

qiskit/passmanager/__init__.py

@@ -133,7 +133,7 @@ new numbers that don't contain five.
 
 Output:
 
-.. parsed-literal::
+.. code-block:: text
 
     [12346789, 464, 36784]
 
@@ -178,7 +178,7 @@ As before, we schedule these passes with the pass manager and run.
 
 Output:
 
-.. parsed-literal::
+.. code-block:: text
 
     [12346789, 45654, 36784]
 

qiskit/primitives/backend_estimator.py

@@ -44,13 +44,15 @@ from .utils import _circuit_key, _observable_key, init_observable
 def _run_circuits(
     circuits: QuantumCircuit | list[QuantumCircuit],
     backend: BackendV1 | 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
-        monitor: Enable job minotor if True
+        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
@@ -60,7 +62,8 @@ def _run_circuits(
     metadata = []
     for circ in circuits:
         metadata.append(circ.metadata)
-        circ.metadata = {}
+        if clear_metadata:
+            circ.metadata = {}
     if isinstance(backend, BackendV1):
         max_circuits = getattr(backend.configuration(), "max_experiments", None)
     elif isinstance(backend, BackendV2):