qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/scheduling/scheduling/asap.py

@@ -0,0 +1,100 @@
+# 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.
+
+"""ASAP Scheduling."""
+from qiskit.circuit import Measure
+from qiskit.transpiler.exceptions import TranspilerError
+
+from qiskit.transpiler.passes.scheduling.scheduling.base_scheduler import BaseScheduler
+
+
+class ASAPScheduleAnalysis(BaseScheduler):
+    """ASAP Scheduling pass, which schedules the start time of instructions as early as possible.
+
+    See the :ref:`transpiler-scheduling-description` section in the :mod:`qiskit.transpiler`
+    module documentation for a more detailed description.
+    """
+
+    def run(self, dag):
+        """Run the ASAPSchedule pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): DAG to schedule.
+
+        Returns:
+            DAGCircuit: A scheduled DAG.
+
+        Raises:
+            TranspilerError: if the circuit is not mapped on physical qubits.
+            TranspilerError: if conditional bit is added to non-supported instruction.
+        """
+        if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
+            raise TranspilerError("ASAP schedule runs on physical circuits only")
+        if self.property_set["time_unit"] == "stretch":
+            raise TranspilerError("Scheduling cannot run on circuits with stretch durations.")
+
+        clbit_write_latency = self.property_set.get("clbit_write_latency", 0)
+
+        node_start_time = {}
+        idle_after = {q: 0 for q in dag.qubits + dag.clbits}
+        for node in dag.topological_op_nodes():
+            op_duration = self._get_node_duration(node, dag)
+
+            # compute t0, t1: instruction interval, note that
+            # t0: start time of instruction
+            # t1: end time of instruction
+            if isinstance(node.op, self.CONDITIONAL_SUPPORTED):
+                t0q = max(idle_after[q] for q in node.qargs)
+                t0 = t0q
+                t1 = t0 + op_duration
+            else:
+                if isinstance(node.op, Measure):
+                    # measure instruction handling is bit tricky due to clbit_write_latency
+                    t0q = max(idle_after[q] for q in node.qargs)
+                    t0c = max(idle_after[c] for c in node.cargs)
+                    # Assume following case (t0c > t0q)
+                    #
+                    #       |t0q
+                    # Q ▒▒▒▒░░░░░░░░░░░░
+                    # C ▒▒▒▒▒▒▒▒░░░░░░░░
+                    #           |t0c
+                    #
+                    # In this case, there is no actual clbit access until clbit_write_latency.
+                    # The node t0 can be push backward by this amount.
+                    #
+                    #         |t0q' = t0c - clbit_write_latency
+                    # Q ▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒
+                    # C ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
+                    #           |t0c' = t0c
+                    #
+                    # rather than naively doing
+                    #
+                    #           |t0q' = t0c
+                    # Q ▒▒▒▒░░░░▒▒▒▒▒▒▒▒
+                    # C ▒▒▒▒▒▒▒▒░░░▒▒▒▒▒
+                    #              |t0c' = t0c + clbit_write_latency
+                    #
+                    t0 = max(t0q, t0c - clbit_write_latency)
+                    t1 = t0 + op_duration
+                    for clbit in node.cargs:
+                        idle_after[clbit] = t1
+                else:
+                    # It happens to be directives such as barrier
+                    t0 = max(idle_after[bit] for bit in node.qargs + node.cargs)
+                    t1 = t0 + op_duration
+
+            for bit in node.qargs:
+                idle_after[bit] = t1
+
+            node_start_time[node] = t0
+
+        self.property_set["node_start_time"] = node_start_time

qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py

@@ -0,0 +1,88 @@
+# 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.
+
+"""Base circuit scheduling pass."""
+
+import warnings
+
+from qiskit.circuit import Delay, Gate
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.dagcircuit import DAGOpNode, DAGCircuit
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.instruction_durations import InstructionDurations
+from qiskit.transpiler.passes.scheduling.time_unit_conversion import TimeUnitConversion
+from qiskit.transpiler.target import Target
+
+
+class BaseScheduler(AnalysisPass):
+    """Base scheduler pass."""
+
+    CONDITIONAL_SUPPORTED = (Gate, Delay)
+
+    def __init__(self, durations: InstructionDurations = None, target: Target = None):
+        """Scheduler initializer.
+
+        Args:
+            durations: Durations of instructions to be used in scheduling
+            target: The :class:`~.Target` representing the target backend, if both
+                  ``durations`` and this are specified then this argument will take
+                  precedence and ``durations`` will be ignored.
+
+        """
+        super().__init__()
+        self.durations = durations
+        if target is not None:
+            self.durations = target.durations()
+
+        # Ensure op node durations are attached and in consistent unit
+        self.requires.append(TimeUnitConversion(inst_durations=durations, target=target))
+
+        # Initialize timeslot
+        if "node_start_time" in self.property_set:
+            warnings.warn(
+                "This circuit has been already scheduled. "
+                "The output of previous scheduling pass will be overridden.",
+                UserWarning,
+            )
+        self.property_set["node_start_time"] = {}
+
+    def _get_node_duration(
+        self,
+        node: DAGOpNode,
+        dag: DAGCircuit,
+    ) -> int:
+        """A helper method to get duration from node"""
+        indices = [dag.find_bit(qarg).index for qarg in node.qargs]
+
+        if node.name == "delay":
+            # `TimeUnitConversion` already handled the unit conversions.
+            duration = node.op.duration
+        else:
+            unit = "s" if self.durations.dt is None else "dt"
+            try:
+                duration = self.durations.get(node.name, indices, unit=unit)
+            except TranspilerError:
+                duration = None
+
+        if isinstance(duration, ParameterExpression):
+            raise TranspilerError(
+                f"Parameterized duration ({duration}) "
+                f"of {node.op.name} on qubits {indices} is not bounded."
+            )
+        if duration is None:
+            raise TranspilerError(f"Duration of {node.op.name} on qubits {indices} is not found.")
+
+        return duration
+
+    def run(self, dag: DAGCircuit):
+        raise NotImplementedError

qiskit/transpiler/passes/scheduling/scheduling/set_io_latency.py

@@ -0,0 +1,64 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+"""Set classical IO latency information to circuit."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.dagcircuit import DAGCircuit
+
+
+class SetIOLatency(AnalysisPass):
+    """Set IOLatency information to the input circuit.
+
+    The ``clbit_write_latency`` and ``conditional_latency`` are added to
+    the property set of pass manager. This information can be shared among the passes
+    that perform scheduling on instructions acting on classical registers.
+
+    Once these latencies are added to the property set, this information
+    is also copied to the output circuit object as protected attributes,
+    so that it can be utilized outside the transpilation,
+    for example, the timeline visualization can use latency to accurately show
+    time occupation by instructions on the classical registers.
+    """
+
+    def __init__(
+        self,
+        clbit_write_latency: int = 0,
+        conditional_latency: int = 0,
+    ):
+        """Create pass with latency information.
+
+        Args:
+            clbit_write_latency: A control flow constraints. Because standard superconducting
+                quantum processor implement dispersive QND readout, the actual data transfer
+                to the clbit happens after the round-trip stimulus signal is buffered
+                and discriminated into quantum state.
+                The interval ``[t0, t0 + clbit_write_latency]`` is regarded as idle time
+                for clbits associated with the measure instruction.
+                This defaults to 0 dt which is identical to Qiskit Pulse scheduler.
+            conditional_latency: A control flow constraints. This value represents
+                a latency of reading a classical register for the conditional operation.
+                The gate operation occurs after this latency. This appears as a delay
+                in front of the DAGOpNode of the gate.
+                This defaults to 0 dt.
+        """
+        super().__init__()
+        self._conditional_latency = conditional_latency
+        self._clbit_write_latency = clbit_write_latency
+
+    def run(self, dag: DAGCircuit):
+        """Add IO latency information.
+
+        Args:
+            dag: Input DAG circuit.
+        """
+        self.property_set["conditional_latency"] = self._conditional_latency
+        self.property_set["clbit_write_latency"] = self._clbit_write_latency

qiskit/transpiler/passes/scheduling/time_unit_conversion.py

@@ -0,0 +1,237 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 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.
+
+"""Unify time unit in circuit for scheduling and following passes."""
+from typing import Set
+
+from qiskit.circuit import Delay, Duration
+from qiskit.circuit.classical import expr
+from qiskit.circuit.duration import duration_in_dt
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.instruction_durations import InstructionDurations
+from qiskit.transpiler.target import Target
+from qiskit.utils import apply_prefix
+
+
+class TimeUnitConversion(TransformationPass):
+    """Choose a time unit to be used in the following time-aware passes,
+    and make all circuit time units consistent with that.
+
+    This pass will add a :attr:`.Instruction.duration` metadata to each op whose duration is known
+    which will be used by subsequent scheduling passes for scheduling.
+
+    If ``dt`` (in seconds) is known to transpiler, the unit ``'dt'`` is chosen. Otherwise,
+    the unit to be selected depends on what units are used in delays and instruction durations:
+
+    * ``'s'``: if they are all in SI units.
+    * ``'dt'``: if they are all in the unit ``'dt'``.
+    * raise error: if they are a mix of SI units and ``'dt'``.
+    """
+
+    def __init__(self, inst_durations: InstructionDurations = None, target: Target = None):
+        """TimeUnitAnalysis initializer.
+
+        Args:
+            inst_durations (InstructionDurations): A dictionary of durations of instructions.
+            target: The :class:`~.Target` representing the target backend, if both
+                  ``inst_durations`` and ``target`` are specified then this argument will take
+                  precedence and ``inst_durations`` will be ignored.
+
+
+        """
+        super().__init__()
+        self.inst_durations = inst_durations or InstructionDurations()
+        if target is not None:
+            # The priority order for instruction durations is: target > standalone.
+            self.inst_durations = target.durations()
+        self._durations_provided = inst_durations is not None or target is not None
+
+    def run(self, dag: DAGCircuit):
+        """Run the TimeUnitAnalysis pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): DAG to be checked.
+
+        Returns:
+            DAGCircuit: DAG with consistent timing and op nodes annotated with duration.
+
+        Raises:
+            TranspilerError: if the units are not unifiable
+        """
+
+        inst_durations = InstructionDurations()
+        if self._durations_provided:
+            inst_durations.update(self.inst_durations, getattr(self.inst_durations, "dt", None))
+
+        # The float-value converted units for delay expressions, either all in 'dt'
+        # or all in seconds.
+        expression_durations = {}
+
+        # Choose unit
+        has_dt = False
+        has_si = False
+
+        # We _always_ need to traverse duration expressions to convert them to
+        # a float. But we also use the opportunity to note if they intermix cycles
+        # and wall-time, in case we don't have a `dt` to use to unify all instruction
+        # durations.
+        for node in dag.op_nodes(op=Delay):
+            if isinstance(node.op.duration, expr.Expr):
+                if any(
+                    isinstance(x, expr.Stretch) for x in expr.iter_identifiers(node.op.duration)
+                ):
+                    # If any of the delays use a stretch expression, we can't run scheduling
+                    # passes anyway, so we bail out. In theory, we _could_ still traverse
+                    # through the stretch expression and replace any Duration value nodes it may
+                    # contain with ones of the same units, but it'd be complex and probably unuseful.
+                    self.property_set["time_unit"] = "stretch"
+                    return dag
+
+                visitor = _EvalDurationImpl(inst_durations.dt)
+                duration = node.op.duration.accept(visitor)
+                if visitor.in_cycles():
+                    has_dt = True
+                    # We need to round in case the expression evaluated to a non-integral 'dt'.
+                    duration = duration_in_dt(duration, 1.0)
+                else:
+                    has_si = True
+                if duration < 0:
+                    raise TranspilerError(
+                        f"Expression '{node.op.duration}' resolves to a negative duration!"
+                    )
+                expression_durations[node._node_id] = duration
+            else:
+                if node.op.unit == "dt":
+                    has_dt = True
+                else:
+                    has_si = True
+            if inst_durations.dt is None and has_dt and has_si:
+                raise TranspilerError(
+                    "Fail to unify time units in delays. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+
+        if inst_durations.dt is None:
+            # Check what units are used in other instructions: dt or SI or mixed
+            units_other = inst_durations.units_used()
+            unified_unit = self._unified(units_other)
+            has_si = has_si or unified_unit in {"SI", "mixed"}
+            has_dt = has_dt or unified_unit in {"dt", "mixed"}
+            if has_si and has_dt:
+                raise TranspilerError(
+                    "Fail to unify time units. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+            if has_si:
+                time_unit = "s"
+            else:
+                # Either dt units were used or no units were used and we
+                # default to dt
+                time_unit = "dt"
+        else:
+            time_unit = "dt"
+
+        # Make instructions with local durations consistent.
+        for node in dag.op_nodes(Delay):
+            op = node.op.to_mutable()
+            if node._node_id in expression_durations:
+                op.duration = expression_durations[node._node_id]
+            else:
+                op.duration = inst_durations._convert_unit(op.duration, op.unit, time_unit)
+            op.unit = time_unit
+            dag.substitute_node(node, op)
+
+        self.property_set["time_unit"] = time_unit
+        return dag
+
+    @staticmethod
+    def _unified(unit_set: Set[str]) -> str:
+        if not unit_set:
+            return "none"
+
+        if len(unit_set) == 1 and "dt" in unit_set:
+            return "dt"
+
+        all_si = True
+        for unit in unit_set:
+            if not unit.endswith("s"):
+                all_si = False
+                break
+
+        if all_si:
+            return "SI"
+
+        return "mixed"
+
+
+class _EvalDurationImpl(expr.ExprVisitor[float]):
+    """Evaluates the expression to a single float result.
+
+    If ``dt`` is provided or all durations are already in ``dt``, the result is in ``dt``.
+    Otherwise, the result will be in seconds, and all durations MUST be in wall-time (SI).
+    """
+
+    __slots__ = ("dt", "has_dt", "has_si")
+
+    def __init__(self, dt=None):
+        self.dt = dt
+        self.has_dt = False
+        self.has_si = False
+
+    def in_cycles(self):
+        """Returns ``True`` if units are 'dt' after visit."""
+        return self.has_dt or self.dt is not None
+
+    def visit_value(self, node, /) -> float:
+        if isinstance(node.value, float):
+            return node.value
+        if isinstance(node.value, Duration.dt):
+            if self.has_si and self.dt is None:
+                raise TranspilerError(
+                    "Fail to unify time units in delays. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+            self.has_dt = True
+            return node.value[0]
+        if isinstance(node.value, Duration):
+            if self.has_dt and self.dt is None:
+                raise TranspilerError(
+                    "Fail to unify time units in delays. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+            self.has_si = True
+            # Setting 'divisor' to 1 when there's no 'dt' is just to simplify
+            # the logic (we don't need to divide).
+            divisor = self.dt if self.dt is not None else 1
+            if isinstance(node.value, Duration.s):
+                return node.value[0] / divisor
+            from_unit = node.value.unit()
+            return apply_prefix(node.value[0], from_unit) / divisor
+        raise TranspilerError(f"invalid duration expression: {node}")
+
+    def visit_binary(self, node, /) -> float:
+        left = node.left.accept(self)
+        right = node.right.accept(self)
+        if node.op == expr.Binary.Op.ADD:
+            return left + right
+        if node.op == expr.Binary.Op.SUB:
+            return left - right
+        if node.op == expr.Binary.Op.MUL:
+            return left * right
+        if node.op == expr.Binary.Op.DIV:
+            return left / right
+        raise TranspilerError(f"invalid duration expression: {node}")
+
+    def visit_cast(self, node, /) -> float:
+        return node.operand.accept(self)

qiskit/transpiler/passes/synthesis/__init__.py

@@ -0,0 +1,21 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Module containing transpiler synthesis passes."""
+
+from .unitary_synthesis import UnitarySynthesis
+from .plugin import high_level_synthesis_plugin_names, unitary_synthesis_plugin_names
+from .linear_functions_synthesis import LinearFunctionsToPermutations
+from .high_level_synthesis import HighLevelSynthesis, HLSConfig
+from .solovay_kitaev_synthesis import SolovayKitaev, SolovayKitaevSynthesis
+from .clifford_unitary_synth_plugin import CliffordUnitarySynthesis
+from .aqc_plugin import AQCSynthesisPlugin

qiskit/transpiler/passes/synthesis/aqc_plugin.py

@@ -0,0 +1,153 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2023.
+#
+# 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.
+"""
+==============================================================================
+AQC Synthesis Plugin (in :mod:`qiskit.transpiler.passes.synthesis.aqc_plugin`)
+==============================================================================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   AQCSynthesisPlugin
+"""
+from functools import partial
+import math
+
+from qiskit.converters import circuit_to_dag
+from qiskit.transpiler.passes.synthesis.plugin import UnitarySynthesisPlugin
+
+
+class AQCSynthesisPlugin(UnitarySynthesisPlugin):
+    """
+    An AQC-based Qiskit unitary synthesis plugin.
+
+    This plugin is invoked by :func:`~.compiler.transpile` when the ``unitary_synthesis_method``
+    parameter is set to ``"aqc"``.
+
+    This plugin supports customization and additional parameters can be passed to the plugin
+    by passing a dictionary as the ``unitary_synthesis_plugin_config`` parameter of
+    the :func:`~qiskit.compiler.transpile` function.
+
+    Supported parameters in the dictionary:
+
+    network_layout (str)
+        Type of network geometry, one of {``"sequ"``, ``"spin"``, ``"cart"``, ``"cyclic_spin"``,
+        ``"cyclic_line"``}. Default value is ``"spin"``.
+
+    connectivity_type (str)
+        type of inter-qubit connectivity, {``"full"``, ``"line"``, ``"star"``}.  Default value
+        is ``"full"``.
+
+    depth (int)
+        depth of the CNOT-network, i.e. the number of layers, where each layer consists of a
+        single CNOT-block.
+
+    optimizer (:class:`~.Minimizer`)
+        An implementation of the ``Minimizer`` protocol to be used in the optimization process.
+
+    seed (int)
+        A random seed.
+
+    initial_point (:class:`~numpy.ndarray`)
+        Initial values of angles/parameters to start the optimization process from.
+    """
+
+    @property
+    def max_qubits(self):
+        """Maximum number of supported qubits is ``14``."""
+        return 14
+
+    @property
+    def min_qubits(self):
+        """Minimum number of supported qubits is ``3``."""
+        return 3
+
+    @property
+    def supports_natural_direction(self):
+        """The plugin does not support natural direction,
+        it assumes bidirectional two qubit gates."""
+        return False
+
+    @property
+    def supports_pulse_optimize(self):
+        """The plugin does not support optimization of pulses."""
+        return False
+
+    @property
+    def supports_gate_lengths(self):
+        """The plugin does not support gate lengths."""
+        return False
+
+    @property
+    def supports_gate_errors(self):
+        """The plugin does not support gate errors."""
+        return False
+
+    @property
+    def supported_bases(self):
+        """The plugin does not support bases for synthesis."""
+        return None
+
+    @property
+    def supports_basis_gates(self):
+        """The plugin does not support basis gates and by default it synthesizes a circuit using
+        ``["rx", "ry", "rz", "cx"]`` gate basis."""
+        return False
+
+    @property
+    def supports_coupling_map(self):
+        """The plugin does not support coupling maps."""
+        return False
+
+    def run(self, unitary, **options):
+
+        # Runtime imports to avoid the overhead of these imports for
+        # plugin discovery and only use them if the plugin is run/used
+        from scipy.optimize import minimize
+        from qiskit.synthesis.unitary.aqc import AQC
+        from qiskit.synthesis.unitary.aqc.cnot_structures import make_cnot_network
+        from qiskit.synthesis.unitary.aqc.cnot_unit_circuit import CNOTUnitCircuit
+        from qiskit.synthesis.unitary.aqc.fast_gradient.fast_gradient import FastCNOTUnitObjective
+
+        num_qubits = round(math.log2(unitary.shape[0]))
+
+        config = options.get("config") or {}
+
+        network_layout = config.get("network_layout", "spin")
+        connectivity_type = config.get("connectivity_type", "full")
+        depth = config.get("depth", 0)
+
+        cnots = make_cnot_network(
+            num_qubits=num_qubits,
+            network_layout=network_layout,
+            connectivity_type=connectivity_type,
+            depth=depth,
+        )
+
+        default_optimizer = partial(minimize, args=(), method="L-BFGS-B", options={"maxiter": 1000})
+        optimizer = config.get("optimizer", default_optimizer)
+        seed = config.get("seed")
+        aqc = AQC(optimizer, seed)
+
+        approximate_circuit = CNOTUnitCircuit(num_qubits=num_qubits, cnots=cnots)
+        approximating_objective = FastCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)
+
+        initial_point = config.get("initial_point")
+        aqc.compile_unitary(
+            target_matrix=unitary,
+            approximate_circuit=approximate_circuit,
+            approximating_objective=approximating_objective,
+            initial_point=initial_point,
+        )
+
+        dag_circuit = circuit_to_dag(approximate_circuit)
+        return dag_circuit