qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/converters/__init__.py

@@ -0,0 +1,74 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""
+=============================================
+Circuit Converters (:mod:`qiskit.converters`)
+=============================================
+
+.. currentmodule:: qiskit.converters
+
+QuantumCircuit -> circuit components
+====================================
+
+.. autofunction:: circuit_to_instruction
+.. autofunction:: circuit_to_gate
+
+QuantumCircuit <-> DagCircuit 
+=============================
+
+.. autofunction:: circuit_to_dag
+.. autofunction:: dag_to_circuit
+
+QuantumCircuit <-> DagDependency 
+================================
+
+.. autofunction:: dagdependency_to_circuit
+.. autofunction:: circuit_to_dagdependency
+
+DagCircuit <-> DagDependency 
+============================
+
+.. autofunction:: dag_to_dagdependency
+.. autofunction:: dagdependency_to_dag
+"""
+
+from .circuit_to_dag import circuit_to_dag
+from .dag_to_circuit import dag_to_circuit
+from .circuit_to_instruction import circuit_to_instruction
+from .circuit_to_gate import circuit_to_gate
+from .circuit_to_dagdependency import circuit_to_dagdependency
+from .dagdependency_to_circuit import dagdependency_to_circuit
+from .dag_to_dagdependency import dag_to_dagdependency
+from .dagdependency_to_dag import dagdependency_to_dag
+
+
+def isinstanceint(obj):
+    """Like isinstance(obj,int), but with casting. Except for strings."""
+    if isinstance(obj, str):
+        return False
+    try:
+        int(obj)
+        return True
+    except TypeError:
+        return False
+
+
+def isinstancelist(obj):
+    """Like isinstance(obj, list), but with casting. Except for strings and dicts."""
+    if isinstance(obj, (str, dict)):
+        return False
+    try:
+        list(obj)
+        return True
+    except TypeError:
+        return False

qiskit/converters/circuit_to_dag.py

@@ -0,0 +1,78 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""Helper function for converting a circuit to a dag"""
+
+from qiskit.circuit.library.blueprintcircuit import BlueprintCircuit
+from qiskit._accelerate.converters import circuit_to_dag as core_circuit_to_dag
+
+
+def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_order=None):
+    """Build a :class:`.DAGCircuit` object from a :class:`.QuantumCircuit`.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        copy_operations (bool): Deep copy the operation objects
+            in the :class:`~.QuantumCircuit` for the output :class:`~.DAGCircuit`.
+            This should only be set to ``False`` if the input :class:`~.QuantumCircuit`
+            will not be used anymore as the operations in the output
+            :class:`~.DAGCircuit` will be shared instances and modifications to
+            operations in the :class:`~.DAGCircuit` will be reflected in the
+            :class:`~.QuantumCircuit` (and vice versa).
+        qubit_order (Iterable[~qiskit.circuit.Qubit] or None): the order that the qubits should be
+            indexed in the output DAG.  Defaults to the same order as in the circuit.
+        clbit_order (Iterable[Clbit] or None): the order that the clbits should be indexed in the
+            output DAG.  Defaults to the same order as in the circuit.
+
+    Return:
+        DAGCircuit: the DAG representing the input circuit.
+
+    Raises:
+        ValueError: if the ``qubit_order`` or ``clbit_order`` parameters do not match the bits in
+            the circuit.
+
+    Example:
+        .. code-block::
+
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.dagcircuit import DAGCircuit
+            from qiskit.converters import circuit_to_dag
+
+            q = QuantumRegister(3, 'q')
+            c = ClassicalRegister(3, 'c')
+            circ = QuantumCircuit(q, c)
+            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)
+            dag = circuit_to_dag(circ)
+    """
+    # If we have an instance of BluePrintCircuit, make sure it is built by calling ._build()
+    if isinstance(circuit, BlueprintCircuit):
+        if not circuit._is_built:
+            circuit._build()
+
+    if qubit_order is not None and (
+        len(qubit_order) != circuit.num_qubits or set(qubit_order) != set(circuit.qubits)
+    ):
+        raise ValueError("'qubit_order' does not contain exactly the same qubits as the circuit")
+
+    if clbit_order is not None and (
+        len(clbit_order) != circuit.num_clbits or set(clbit_order) != set(circuit.clbits)
+    ):
+        raise ValueError("'clbit_order' does not contain exactly the same clbits as the circuit")
+
+    dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
+
+    dagcircuit.duration = circuit.duration
+    dagcircuit.unit = circuit.unit
+    return dagcircuit

qiskit/converters/circuit_to_dagdependency.py

@@ -0,0 +1,51 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Helper function for converting a circuit to a dag dependency"""
+
+from qiskit.dagcircuit.dagdependency import DAGDependency
+
+
+def circuit_to_dagdependency(circuit, create_preds_and_succs=True):
+    """Build a ``DAGDependency`` object from a :class:`~.QuantumCircuit`.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        create_preds_and_succs (bool): whether to construct lists of
+            predecessors and successors for every node.
+
+    Return:
+        DAGDependency: the DAG representing the input circuit as a dag dependency.
+    """
+    dagdependency = DAGDependency()
+    dagdependency.name = circuit.name
+    dagdependency.metadata = circuit.metadata
+
+    dagdependency.add_qubits(circuit.qubits)
+    dagdependency.add_clbits(circuit.clbits)
+
+    for register in circuit.qregs:
+        dagdependency.add_qreg(register)
+
+    for register in circuit.cregs:
+        dagdependency.add_creg(register)
+
+    for instruction in circuit.data:
+        dagdependency.add_op_node(instruction.operation, instruction.qubits, instruction.clbits)
+
+    if create_preds_and_succs:
+        dagdependency._add_predecessors()
+        dagdependency._add_successors()
+
+    dagdependency.calibrations = circuit.calibrations
+
+    return dagdependency

qiskit/converters/circuit_to_dagdependency_v2.py

@@ -0,0 +1,47 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Helper function for converting a circuit to a dag dependency"""
+
+from qiskit.dagcircuit.dagdependency_v2 import _DAGDependencyV2
+
+
+def _circuit_to_dagdependency_v2(circuit):
+    """Build a ``_DAGDependencyV2`` object from a :class:`~.QuantumCircuit`.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+
+    Return:
+        _DAGDependencyV2: the DAG representing the input circuit as a dag dependency.
+    """
+    dagdependency = _DAGDependencyV2()
+    dagdependency.name = circuit.name
+    dagdependency.metadata = circuit.metadata
+    dagdependency.calibrations = circuit.calibrations
+    dagdependency.global_phase = circuit.global_phase
+
+    dagdependency.add_qubits(circuit.qubits)
+    dagdependency.add_clbits(circuit.clbits)
+
+    for register in circuit.qregs:
+        dagdependency.add_qreg(register)
+
+    for register in circuit.cregs:
+        dagdependency.add_creg(register)
+
+    for instruction in circuit.data:
+        dagdependency.apply_operation_back(
+            instruction.operation, instruction.qubits, instruction.clbits
+        )
+
+    return dagdependency

qiskit/converters/circuit_to_gate.py

@@ -0,0 +1,107 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+
+"""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.exceptions import QiskitError
+
+
+def _check_is_gate(op):
+    """Checks whether op can be converted to Gate."""
+    if isinstance(op, Gate):
+        return True
+    elif isinstance(op, AnnotatedOperation):
+        return _check_is_gate(op.base_op)
+    return False
+
+
+def circuit_to_gate(circuit, parameter_map=None, equivalence_library=None, label=None):
+    """Build a :class:`.Gate` object from a :class:`.QuantumCircuit`.
+
+    The gate is anonymous (not tied to a named quantum register),
+    and so can be inserted into another circuit. The gate will
+    have the same string name as the circuit.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        parameter_map (dict): For parameterized circuits, a mapping from
+           parameters in the circuit to parameters to be used in the gate.
+           If None, existing circuit parameters will also parameterize the
+           Gate.
+        equivalence_library (EquivalenceLibrary): Optional equivalence library
+           where the converted gate will be registered.
+        label (str): Optional gate label.
+
+    Raises:
+        QiskitError: if circuit is non-unitary or if
+            parameter_map is not compatible with circuit
+
+    Return:
+        Gate: a Gate equivalent to the action of the
+        input circuit. Upon decomposition, this gate will
+        yield the components comprising the original circuit.
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+    if circuit.clbits:
+        raise QiskitError("Circuit with classical bits cannot be converted to gate.")
+    if circuit.num_vars:
+        raise QiskitError("circuits with realtime classical variables cannot be converted to gates")
+
+    for instruction in circuit.data:
+        if not _check_is_gate(instruction.operation):
+            raise QiskitError(
+                "One or more instructions cannot be converted to"
+                f' a gate. "{instruction.operation.name}" is not a gate instruction'
+            )
+
+    if parameter_map is None:
+        parameter_dict = {p: p for p in circuit.parameters}
+    else:
+        parameter_dict = circuit._unroll_param_dict(parameter_map)
+
+    if parameter_dict.keys() != circuit.parameters:
+        raise QiskitError(
+            "parameter_map should map all circuit parameters. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {parameter_dict}"
+        )
+
+    gate = Gate(
+        name=circuit.name,
+        num_qubits=circuit.num_qubits,
+        params=[*parameter_dict.values()],
+        label=label,
+    )
+    gate.condition = None
+
+    target = circuit.assign_parameters(parameter_dict, inplace=False)
+
+    if equivalence_library is not None:
+        equivalence_library.add_equivalence(gate, target)
+
+    qc = QuantumCircuit(name=gate.name, global_phase=target.global_phase)
+    if gate.num_qubits > 0:
+        q = QuantumRegister(gate.num_qubits, "q")
+        qc.add_register(q)
+    qubit_map = {bit: q[idx] for idx, bit in enumerate(circuit.qubits)}
+
+    # The 3rd parameter in the output tuple) is hard coded to [] because
+    # Gate objects do not have cregs set and we've verified that all
+    # instructions are gates
+    for instruction in target.data:
+        qc._append(instruction.replace(qubits=tuple(qubit_map[y] for y in instruction.qubits)))
+    gate.definition = qc
+    return gate

qiskit/converters/circuit_to_instruction.py

@@ -0,0 +1,155 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""Helper function for converting a circuit to an instruction."""
+from qiskit.exceptions import QiskitError
+from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+
+
+def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None, label=None):
+    """Build an :class:`~.circuit.Instruction` object from a :class:`.QuantumCircuit`.
+
+    The instruction is anonymous (not tied to a named quantum register),
+    and so can be inserted into another circuit. The instruction will
+    have the same string name as the circuit.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        parameter_map (dict): For parameterized circuits, a mapping from
+           parameters in the circuit to parameters to be used in the instruction.
+           If None, existing circuit parameters will also parameterize the
+           instruction.
+        equivalence_library (EquivalenceLibrary): Optional equivalence library
+           where the converted instruction will be registered.
+        label (str): Optional instruction label.
+
+    Raises:
+        QiskitError: if parameter_map is not compatible with circuit
+
+    Return:
+        qiskit.circuit.Instruction: an instruction equivalent to the action of the
+        input circuit. Upon decomposition, this instruction will
+        yield the components comprising the original circuit.
+
+    Example:
+        .. code-block::
+
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.converters import circuit_to_instruction
+
+            q = QuantumRegister(3, 'q')
+            c = ClassicalRegister(3, 'c')
+            circ = QuantumCircuit(q, c)
+            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)
+            circuit_to_instruction(circ)
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+    if circuit.num_input_vars:
+        # This could be supported by moving the `input` variables to be parameters of the
+        # instruction, but we don't really have a good representation of that yet, so safer to
+        # forbid it.
+        raise QiskitError("Circuits with 'input' variables cannot yet be converted to instructions")
+    if circuit.num_captured_vars:
+        raise QiskitError("Circuits that capture variables cannot be converted to instructions")
+    if circuit.num_declared_vars:
+        # This could very easily be supported in representations, since the variables are allocated
+        # and freed within the instruction itself.  The reason to initially forbid it is to avoid
+        # needing to support unrolling such instructions within the transpiler; we would potentially
+        # need to remap variables to unique names in the larger context, and we don't yet have a way
+        # to return that information from the transpiler.  We have to catch that in the transpiler
+        # as well since a user could manually make an instruction with such a definition, but
+        # forbidding it here means users get a more meaningful error at the point that the
+        # instruction actually gets created (since users often aren't aware that
+        # `QuantumCircuit.append(QuantumCircuit)` implicitly converts to an instruction).
+        raise QiskitError(
+            "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 parameter_map is None:
+        parameter_dict = {p: p for p in circuit.parameters}
+    else:
+        parameter_dict = circuit._unroll_param_dict(parameter_map)
+
+    if parameter_dict.keys() != circuit.parameters:
+        raise QiskitError(
+            "parameter_map should map all circuit parameters. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {parameter_dict}"
+        )
+
+    out_instruction = Instruction(
+        name=circuit.name,
+        num_qubits=circuit.num_qubits,
+        num_clbits=circuit.num_clbits,
+        params=[*parameter_dict.values()],
+        label=label,
+    )
+    out_instruction._condition = None
+
+    target = circuit.assign_parameters(parameter_dict, inplace=False)
+
+    if equivalence_library is not None:
+        equivalence_library.add_equivalence(out_instruction, target)
+
+    regs = []
+    qreg, creg = None, None
+    if out_instruction.num_qubits > 0:
+        qreg = QuantumRegister(out_instruction.num_qubits, "q")
+        regs.append(qreg)
+
+    if out_instruction.num_clbits > 0:
+        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._data = data
+
+    if circuit.global_phase:
+        qc.global_phase = circuit.global_phase
+
+    out_instruction.definition = qc
+
+    return out_instruction

qiskit/converters/dag_to_circuit.py

@@ -0,0 +1,77 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""Helper function for converting a dag to a circuit."""
+
+from qiskit.circuit import QuantumCircuit
+
+
+def dag_to_circuit(dag, copy_operations=True):
+    """Build a ``QuantumCircuit`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+        copy_operations (bool): Deep copy the operation objects
+            in the :class:`~.DAGCircuit` for the output :class:`~.QuantumCircuit`.
+            This should only be set to ``False`` if the input :class:`~.DAGCircuit`
+            will not be used anymore as the operations in the output
+            :class:`~.QuantumCircuit` will be shared instances and
+            modifications to operations in the :class:`~.DAGCircuit` will
+            be reflected in the :class:`~.QuantumCircuit` (and vice versa).
+
+    Return:
+        QuantumCircuit: the circuit representing the input dag.
+
+    Example:
+        .. plot::
+           :include-source:
+
+           from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+           from qiskit.dagcircuit import DAGCircuit
+           from qiskit.converters import circuit_to_dag
+           from qiskit.circuit.library.standard_gates import CHGate, U2Gate, CXGate
+           from qiskit.converters import dag_to_circuit
+
+           q = QuantumRegister(3, 'q')
+           c = ClassicalRegister(3, 'c')
+           circ = QuantumCircuit(q, c)
+           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)
+           dag = circuit_to_dag(circ)
+           circuit = dag_to_circuit(dag)
+           circuit.draw('mpl')
+    """
+
+    name = dag.name or None
+    circuit = QuantumCircuit(
+        dag.qubits,
+        dag.clbits,
+        *dag.qregs.values(),
+        *dag.cregs.values(),
+        name=name,
+        global_phase=dag.global_phase,
+        inputs=dag.iter_input_vars(),
+        captures=dag.iter_captured_vars(),
+    )
+    for var in dag.iter_declared_vars():
+        circuit.add_uninitialized_var(var)
+    circuit.metadata = dag.metadata
+    circuit.calibrations = dag.calibrations
+
+    for node in dag.topological_op_nodes():
+        circuit._append(node._to_circuit_instruction(deepcopy=copy_operations))
+
+    circuit.duration = dag.duration
+    circuit.unit = dag.unit
+    return circuit

qiskit/converters/dag_to_dagdependency.py

@@ -0,0 +1,55 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Helper function for converting a dag circuit to a dag dependency"""
+from qiskit.dagcircuit.dagdependency import DAGDependency
+
+
+def dag_to_dagdependency(dag, create_preds_and_succs=True):
+    """Build a ``DAGDependency`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+        create_preds_and_succs (bool): whether to construct lists of
+            predecessors and successors for every node.
+
+    Return:
+        DAGDependency: the DAG representing the input circuit as a dag dependency.
+    """
+
+    dagdependency = DAGDependency()
+    dagdependency.name = dag.name
+    dagdependency.metadata = dag.metadata
+
+    dagdependency.add_qubits(dag.qubits)
+    dagdependency.add_clbits(dag.clbits)
+
+    for register in dag.qregs.values():
+        dagdependency.add_qreg(register)
+
+    for register in dag.cregs.values():
+        dagdependency.add_creg(register)
+
+    for node in dag.topological_op_nodes():
+        # Get arguments for classical control (if any)
+        inst = node.op.copy()
+        dagdependency.add_op_node(inst, node.qargs, node.cargs)
+
+    if create_preds_and_succs:
+        dagdependency._add_predecessors()
+        dagdependency._add_successors()
+
+    # copy metadata
+    dagdependency.global_phase = dag.global_phase
+    dagdependency.calibrations = dag.calibrations
+
+    return dagdependency

qiskit/converters/dag_to_dagdependency_v2.py

@@ -0,0 +1,44 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Helper function for converting a dag circuit to a dag dependency"""
+from qiskit.dagcircuit.dagdependency_v2 import _DAGDependencyV2
+
+
+def _dag_to_dagdependency_v2(dag):
+    """Build a ``_DAGDependencyV2`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+
+    Return:
+        _DAGDependencyV2: the DAG representing the input circuit as a dag dependency.
+    """
+    dagdependency = _DAGDependencyV2()
+    dagdependency.name = dag.name
+    dagdependency.metadata = dag.metadata
+    dagdependency.global_phase = dag.global_phase
+    dagdependency.calibrations = dag.calibrations
+
+    dagdependency.add_qubits(dag.qubits)
+    dagdependency.add_clbits(dag.clbits)
+
+    for register in dag.qregs.values():
+        dagdependency.add_qreg(register)
+
+    for register in dag.cregs.values():
+        dagdependency.add_creg(register)
+
+    for node in dag.topological_op_nodes():
+        dagdependency.apply_operation_back(node.op.copy(), node.qargs, node.cargs)
+
+    return dagdependency