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

qiskit/circuit/random/utils.py

@@ -54,9 +54,9 @@ def random_circuit(
         reset (bool): if True, insert middle resets
         seed (int): sets random seed (optional)
         num_operand_distribution (dict): a distribution of gates that specifies the ratio
-        of 1-qubit, 2-qubit, 3-qubit, ..., n-qubit gates in the random circuit. Expect a
-        deviation from the specified ratios that depends on the size of the requested
-        random circuit. (optional)
+            of 1-qubit, 2-qubit, 3-qubit, ..., n-qubit gates in the random circuit. Expect a
+            deviation from the specified ratios that depends on the size of the requested
+            random circuit. (optional)
 
     Returns:
         QuantumCircuit: constructed circuit
@@ -274,9 +274,15 @@ def random_circuit(
                 if is_cond:
                     qc.measure(qc.qubits, cr)
                     # The condition values are required to be bigints, not Numpy's fixed-width type.
-                    operation = operation.c_if(cr, int(condition_values[c_ptr]))
-                    c_ptr += 1
-                qc._append(CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end]))
+                    with qc.if_test((cr, int(condition_values[c_ptr]))):
+                        c_ptr += 1
+                        qc._append(
+                            CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end])
+                        )
+                else:
+                    qc._append(
+                        CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end])
+                    )
         else:
             for gate, q_start, q_end, p_start, p_end in zip(
                 gate_specs["class"], q_indices[:-1], q_indices[1:], p_indices[:-1], p_indices[1:]

qiskit/circuit/reset.py

@@ -15,17 +15,20 @@ Qubit reset to computational zero.
 """
 
 from qiskit.circuit.singleton import SingletonInstruction, stdlib_singleton_key
+from qiskit._accelerate.circuit import StandardInstructionType
 
 
 class Reset(SingletonInstruction):
     r"""Incoherently reset a qubit to the :math:`\lvert0\rangle` state."""
 
-    def __init__(self, label=None, *, duration=None, unit="dt"):
+    _standard_instruction_type = StandardInstructionType.Reset
+
+    def __init__(self, label=None):
         """
         Args:
             label: optional string label of this instruction.
         """
-        super().__init__("reset", 1, 0, [], label=label, duration=duration, unit=unit)
+        super().__init__("reset", 1, 0, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 

qiskit/circuit/singleton.py

@@ -251,7 +251,6 @@ from __future__ import annotations
 
 import functools
 
-from qiskit.utils import deprecate_func
 from .instruction import Instruction
 from .gate import Gate
 from .controlledgate import ControlledGate, _ctrl_state_to_int
@@ -490,10 +489,6 @@ class _SingletonInstructionOverrides(Instruction):
         instruction._params = _frozenlist(instruction._params)
         return instruction
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        return self.to_mutable().c_if(classical, val)
-
     def copy(self, name=None):
         if name is None:
             return self
@@ -513,8 +508,7 @@ class SingletonInstruction(Instruction, _SingletonBase, overrides=_SingletonInst
     memory footprint of multiple instructions.
 
     The exception to be aware of with this class though are the :class:`~.circuit.Instruction`
-    attributes :attr:`~.Instruction.label`, :attr:`~.Instruction.condition`,
-    :attr:`~.Instruction.duration`, and :attr:`~.Instruction.unit` which can be set differently for
+    attribute :attr:`~.Instruction.label` which can be set differently for
     specific instances of gates.  For :class:`SingletonInstruction` usage to be sound setting these
     attributes is not available and they can only be set at creation time, or on an object that has
     been specifically made mutable using :meth:`~.Instruction.to_mutable`. If any of these
@@ -589,8 +583,8 @@ def stdlib_singleton_key(*, num_ctrl_qubits: int = 0):
 
     if num_ctrl_qubits:
 
-        def key(label=None, ctrl_state=None, *, duration=None, unit="dt", _base_label=None):
-            if label is None and duration is None and unit == "dt" and _base_label is None:
+        def key(label=None, ctrl_state=None, *, _base_label=None):
+            if label is None and _base_label is None:
                 # Normalisation; we want all types for the control state to key the same.
                 ctrl_state = _ctrl_state_to_int(ctrl_state, num_ctrl_qubits)
                 return (ctrl_state,)
@@ -598,8 +592,8 @@ def stdlib_singleton_key(*, num_ctrl_qubits: int = 0):
 
     else:
 
-        def key(label=None, *, duration=None, unit="dt"):
-            if label is None and duration is None and unit == "dt":
+        def key(label=None):
+            if label is None:
                 return ()
             return None
 

qiskit/circuit/store.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import typing
 
-from qiskit.utils import deprecate_func
 from .exceptions import CircuitError
 from .classical import expr, types
 from .instruction import Instruction
@@ -88,10 +87,3 @@ class Store(Instruction):
     def rvalue(self):
         """Get the r-value :class:`~.expr.Expr` node that is being written into the l-value."""
         return self.params[1]
-
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        """:meta hidden:"""
-        raise NotImplementedError(
-            "stores cannot be conditioned with `c_if`; use a full `if_test` context instead"
-        )

qiskit/compiler/__init__.py

@@ -17,17 +17,11 @@ Compilation Routines (:mod:`qiskit.compiler`)
 
 .. currentmodule:: qiskit.compiler
 
-Circuit and Pulse Compilation Functions
+Circuit Compilation Functions
 =======================================
 
-.. autofunction:: assemble
-.. autofunction:: schedule
 .. autofunction:: transpile
-.. autofunction:: sequence
 
 """
 
-from .assembler import assemble
 from .transpiler import transpile
-from .scheduler import schedule
-from .sequencer import sequence

qiskit/compiler/transpiler.py

@@ -16,73 +16,35 @@
 import logging
 from time import time
 from typing import List, Union, Dict, Callable, Any, Optional, TypeVar
-import warnings
 
 from qiskit import user_config
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.providers.backend import Backend
-from qiskit.providers.backend_compat import BackendV2Converter
-from qiskit.providers.models.backendproperties import BackendProperties
-from qiskit.pulse import Schedule, InstructionScheduleMap
 from qiskit.transpiler import Layout, CouplingMap, PropertySet
 from qiskit.transpiler.basepasses import BasePass
 from qiskit.transpiler.exceptions import TranspilerError, CircuitTooWideForTarget
-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,
     basis_gates: Optional[List[str]] = None,
-    inst_map: Optional[List[InstructionScheduleMap]] = None,
     coupling_map: Optional[Union[CouplingMap, List[List[int]]]] = None,
-    backend_properties: Optional[BackendProperties] = None,
     initial_layout: Optional[Union[Layout, Dict, List]] = None,
     layout_method: Optional[str] = None,
     routing_method: Optional[str] = None,
     translation_method: Optional[str] = None,
     scheduling_method: Optional[str] = None,
-    instruction_durations: Optional[InstructionDurationsType] = None,
     dt: Optional[float] = None,
     approximation_degree: Optional[float] = 1.0,
-    timing_constraints: Optional[Dict[str, int]] = None,
     seed_transpiler: Optional[int] = None,
     optimization_level: Optional[int] = None,
     callback: Optional[Callable[[BasePass, DAGCircuit, float, PropertySet, int], Any]] = None,
@@ -105,26 +67,21 @@ def transpile(  # pylint: disable=too-many-return-statements
 
     The prioritization of transpilation target constraints works as follows: if a ``target``
     input is provided, it will take priority over any ``backend`` input or loose constraints
-    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
-    ``dt`` or ``timing_constraints``). If a ``backend`` is provided together with any loose constraint
+    (``basis_gates``, ``coupling_map``, or ``dt``). If a ``backend`` is provided
+    together with any loose constraint
     from the list above, the loose constraint will take priority over the corresponding backend
-    constraint. This behavior is independent of whether the ``backend`` instance is of type
-    :class:`.BackendV1` or :class:`.BackendV2`, as summarized in the table below. The first column
+    constraint. This behavior is summarized in the table below. The first column
     in the table summarizes the potential user-provided constraints, and each cell shows whether
     the priority is assigned to that specific constraint input or another input
-    (`target`/`backend(V1)`/`backend(V2)`).
-
-    ============================ ========= ======================== =======================
-    User Provided                target    backend(V1)              backend(V2)
-    ============================ ========= ======================== =======================
-    **basis_gates**              target    basis_gates              basis_gates
-    **coupling_map**             target    coupling_map             coupling_map
-    **instruction_durations**    target    instruction_durations    instruction_durations
-    **inst_map**                 target    inst_map                 inst_map
-    **dt**                       target    dt                       dt
-    **timing_constraints**       target    timing_constraints       timing_constraints
-    **backend_properties**       target    backend_properties       backend_properties
-    ============================ ========= ======================== =======================
+    (`target`/`backend(V2)`).
+
+    ============================ ========= ========================
+    User Provided                target    backend(V2)
+    ============================ ========= ========================
+    **basis_gates**              target    basis_gates
+    **coupling_map**             target    coupling_map
+    **dt**                       target    dt
+    ============================ ========= ========================
 
     Args:
         circuits: Circuit(s) to transpile
@@ -133,12 +90,6 @@ 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: 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
-            override the low-level instruction implementation. This feature is available
-            iff the backend supports the pulse gate experiment.
         coupling_map: Directed coupling map (perhaps custom) to target in mapping. If
             the coupling map is symmetric, both directions need to be specified.
 
@@ -148,10 +99,6 @@ def transpile(  # pylint: disable=too-many-return-statements
             #. List, must be given as an adjacency matrix, where each entry
                specifies all directed two-qubit interactions supported by backend,
                e.g: ``[[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]``
-
-        backend_properties: properties returned by a backend, including information on gate
-            errors, readout errors, qubit coherence times, etc. Find a backend
-            that provides this information with: ``backend.properties()``
         initial_layout: Initial position of virtual qubits on physical qubits.
             If this layout makes the circuit compatible with the coupling_map
             constraints, it will be used. The final layout is not guaranteed to be the same,
@@ -191,10 +138,10 @@ def transpile(  # pylint: disable=too-many-return-statements
             This can also be the external plugin name to use for the ``routing`` stage.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"routing"`` for the ``stage_name`` argument.
-        translation_method: Name of translation pass (``"translator"`` or ``"synthesis"``)
-            This can also be the external plugin name to use for the ``translation`` stage.
-            You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
-            ``"translation"`` for the ``stage_name`` argument.
+        translation_method: Name of translation pass (``"default"``, ``"translator"`` or
+            ``"synthesis"``). This can also be the external plugin name to use for the
+            ``translation`` stage.  You can see a list of installed plugins by using
+            :func:`~.list_stage_plugins` with ``"translation"`` for the ``stage_name`` argument.
         scheduling_method: Name of scheduling pass.
             * ``'as_soon_as_possible'``: Schedule instructions greedily, as early as possible
             on a qubit resource. (alias: ``'asap'``)
@@ -204,40 +151,10 @@ def transpile(  # pylint: disable=too-many-return-statements
             to use for the ``scheduling`` stage. You can see a list of installed plugins by
             using :func:`~.list_stage_plugins` with ``"scheduling"`` for the ``stage_name``
             argument.
-        instruction_durations: Durations of instructions.
-            Applicable only if scheduling_method is specified.
-            The gate lengths defined in ``backend.properties`` are used as default.
-            They are overwritten if this ``instruction_durations`` is specified.
-            The format of ``instruction_durations`` must be as follows.
-            The `instruction_durations` must be given as a list of tuples
-            [(instruction_name, qubits, duration, unit), ...].
-            | [('cx', [0, 1], 12.3, 'ns'), ('u3', [0], 4.56, 'ns')]
-            | [('cx', [0, 1], 1000), ('u3', [0], 300)]
-            If unit is omitted, the default is 'dt', which is a sample time depending on backend.
-            If the time unit is 'dt', the duration must be an integer.
         dt: Backend sample time (resolution) in seconds.
-            If ``None`` (default), ``backend.configuration().dt`` is used.
+            If ``None`` (default), ``backend.dt`` is used.
         approximation_degree (float): heuristic dial used for circuit approximation
             (1.0=no approximation, 0.0=maximal approximation)
-        timing_constraints: An optional control hardware restriction on instruction time resolution.
-            A quantum computer backend may report a set of restrictions, namely:
-
-            - granularity: An integer value representing minimum pulse gate
-              resolution in units of ``dt``. A user-defined pulse gate should have
-              duration of a multiple of this granularity value.
-            - min_length: An integer value representing minimum pulse gate
-              length in units of ``dt``. A user-defined pulse gate should be longer
-              than this length.
-            - pulse_alignment: An integer value representing a time resolution of gate
-              instruction starting time. Gate instruction should start at time which
-              is a multiple of the alignment value.
-            - acquire_alignment: An integer value representing a time resolution of measure
-              instruction starting time. Measure instruction should start at time which
-              is a multiple of the alignment value.
-
-            This information will be provided by the backend configuration.
-            If the backend doesn't have any restriction on the instruction time allocation,
-            then ``timing_constraints`` is None and no adjustment will be performed.
         seed_transpiler: Sets random seed for the stochastic parts of the transpiler
         optimization_level: How much optimization to perform on the circuits.
             Higher levels generate more optimized circuits,
@@ -329,58 +246,13 @@ def transpile(  # pylint: disable=too-many-return-statements
     if not circuits:
         return []
 
-    # transpiling schedules is not supported yet.
     start_time = time()
-    if all(isinstance(c, Schedule) for c in circuits):
-        warnings.warn("Transpiling schedules is not supported yet.", UserWarning)
-        end_time = time()
-        _log_transpile_time(start_time, end_time)
-        if arg_circuits_list:
-            return circuits
-        else:
-            return circuits[0]
 
     if optimization_level is None:
         # Take optimization level from the configuration or 1 as default.
         config = user_config.get_config()
         optimization_level = config.get("transpile_optimization_level", 2)
 
-    if backend is not None and getattr(backend, "version", 0) <= 1:
-        warnings.warn(
-            "The `transpile` function 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,
-        )
-        with warnings.catch_warnings():
-            # This is a temporary conversion step to allow for a smoother transition
-            # to a fully target-based transpiler pipeline while maintaining the behavior
-            # of `transpile` with BackendV1 inputs.
-            # TODO BackendV1 is deprecated and this path can be
-            #   removed once it gets removed:
-            #   https://github.com/Qiskit/qiskit/pull/12850
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=r".+qiskit\.providers\.backend_compat\.BackendV2Converter.+",
-                module="qiskit",
-            )
-            backend = BackendV2Converter(backend)
-
-    if (
-        scheduling_method is not None
-        and backend is None
-        and target is None
-        and not instruction_durations
-    ):
-        warnings.warn(
-            "When scheduling circuits without backend,"
-            " 'instruction_durations' should be usually provided.",
-            UserWarning,
-        )
-
     if not ignore_backend_supplied_default_methods:
         if scheduling_method is None and hasattr(backend, "get_scheduling_stage_plugin"):
             scheduling_method = backend.get_scheduling_stage_plugin()
@@ -394,57 +266,27 @@ 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.
-    # 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,
-        )
+    pm = generate_preset_pass_manager(
+        optimization_level,
+        target=target,
+        backend=backend,
+        basis_gates=basis_gates,
+        coupling_map=coupling_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

@@ -41,7 +41,9 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
             the circuit.
 
     Example:
-        .. code-block::
+        .. plot::
+            :include-source:
+            :nofigs:
 
             from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
             from qiskit.dagcircuit import DAGCircuit
@@ -53,7 +55,7 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
             circ.h(q[0])
             circ.cx(q[0], q[1])
             circ.measure(q[0], c[0])
-            circ.rz(0.5, q[1]).c_if(c, 2)
+            circ.rz(0.5, q[1])
             dag = circuit_to_dag(circ)
     """
     # If we have an instance of BluePrintCircuit, make sure it is built by calling ._build()

qiskit/converters/circuit_to_dagdependency.py

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

qiskit/converters/circuit_to_dagdependency_v2.py

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

qiskit/converters/circuit_to_gate.py

@@ -14,7 +14,7 @@
 """Helper function for converting a circuit to a gate"""
 from qiskit.circuit.annotated_operation import AnnotatedOperation
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.exceptions import QiskitError
 
 

qiskit/converters/circuit_to_instruction.py

@@ -11,10 +11,11 @@
 # that they have been altered from the originals.
 
 """Helper function for converting a circuit to an instruction."""
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.instruction import Instruction
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit import ClassicalRegister
 
 
 def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None, label=None):
@@ -43,7 +44,9 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
         yield the components comprising the original circuit.
 
     Example:
-        .. code-block::
+        .. plot::
+            :include-source:
+            :nofigs:
 
             from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
             from qiskit.converters import circuit_to_instruction
@@ -54,7 +57,7 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
             circ.h(q[0])
             circ.cx(q[0], q[1])
             circ.measure(q[0], c[0])
-            circ.rz(0.5, q[1]).c_if(c, 2)
+            circ.rz(0.5, q[1])
             circuit_to_instruction(circ)
     """
     # pylint: disable=cyclic-import
@@ -81,6 +84,10 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
             "Circuits with internal variables cannot yet be converted to instructions."
             " You may be able to use `QuantumCircuit.compose` to inline this circuit into another."
         )
+    if CONTROL_FLOW_OP_NAMES.intersection(circuit.count_ops()):
+        raise QiskitError(
+            "Circuits with control flow operations cannot be converted to an instruction."
+        )
 
     if parameter_map is None:
         parameter_dict = {p: p for p in circuit.parameters}
@@ -117,36 +124,16 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
         creg = ClassicalRegister(out_instruction.num_clbits, "c")
         regs.append(creg)
 
-    clbit_map = {bit: creg[idx] for idx, bit in enumerate(circuit.clbits)}
-    operation_map = {}
-
-    def fix_condition(op):
-        original_id = id(op)
-        if (out := operation_map.get(original_id)) is not None:
-            return out
-
-        condition = getattr(op, "_condition", None)
-        if condition:
-            reg, val = condition
-            if isinstance(reg, Clbit):
-                op = op.c_if(clbit_map[reg], val)
-            elif reg.size == creg.size:
-                op = op.c_if(creg, val)
-            else:
-                raise QiskitError(
-                    "Cannot convert condition in circuit with "
-                    "multiple classical registers to instruction"
-                )
-        operation_map[original_id] = op
-        return op
-
     data = target._data.copy()
     data.replace_bits(qubits=qreg, clbits=creg)
-    data.map_nonstandard_ops(fix_condition)
 
-    qc = QuantumCircuit(*regs, name=out_instruction.name)
+    qc = QuantumCircuit(name=out_instruction.name)
     qc._data = data
 
+    # Re-add the registers.
+    for reg in regs:
+        qc.add_register(reg)
+
     if circuit.global_phase:
         qc.global_phase = circuit.global_phase
 

qiskit/converters/dag_to_circuit.py

@@ -49,7 +49,7 @@ def dag_to_circuit(dag, copy_operations=True):
            circ.h(q[0])
            circ.cx(q[0], q[1])
            circ.measure(q[0], c[0])
-           circ.rz(0.5, q[1]).c_if(c, 2)
+           circ.rz(0.5, q[1])
            dag = circuit_to_dag(circ)
            circuit = dag_to_circuit(dag)
            circuit.draw('mpl')
@@ -66,13 +66,13 @@ def dag_to_circuit(dag, copy_operations=True):
         name=name,
         global_phase=dag.global_phase,
         inputs=dag.iter_input_vars(),
-        captures=dag.iter_captured_vars(),
+        captures=dag.iter_captures(),
     )
     for var in dag.iter_declared_vars():
         circuit.add_uninitialized_var(var)
-    circuit.metadata = dag.metadata
-    circuit._calibrations_prop = dag._calibrations_prop
-
+    for stretch in dag.iter_declared_stretches():
+        circuit.add_stretch(stretch)
+    circuit.metadata = dag.metadata or {}
     circuit._data = circuit_data
 
     circuit._duration = dag.duration

qiskit/converters/dag_to_dagdependency.py

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

qiskit/converters/dag_to_dagdependency_v2.py

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