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

qiskit/transpiler/passes/basis/basis_translator.py

@@ -13,12 +13,29 @@
 
 """Translates gates to a target basis using a given equivalence library."""
 
+import time
 import logging
 
+from functools import singledispatchmethod
+from itertools import zip_longest
 from collections import defaultdict
 
+import rustworkx
+
+from qiskit.circuit import (
+    Gate,
+    ParameterVector,
+    QuantumRegister,
+    ControlFlowOp,
+    QuantumCircuit,
+    ParameterExpression,
+)
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.converters import circuit_to_dag, dag_to_circuit
+from qiskit.circuit.equivalence import Key, NodeData
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit._accelerate.basis.basis_translator import base_run
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 
 logger = logging.getLogger(__name__)
 
@@ -125,13 +142,552 @@ class BasisTranslator(TransformationPass):
         Returns:
             DAGCircuit: translated circuit.
         """
+        if self._target_basis is None and self._target is None:
+            return dag
+
+        qarg_indices = {qubit: index for index, qubit in enumerate(dag.qubits)}
+
+        # Names of instructions assumed to supported by any backend.
+        if self._target is None:
+            basic_instrs = ["measure", "reset", "barrier", "snapshot", "delay", "store"]
+            target_basis = set(self._target_basis)
+            source_basis = set(self._extract_basis(dag))
+            qargs_local_source_basis = {}
+        else:
+            basic_instrs = ["barrier", "snapshot", "store"]
+            target_basis = self._target.keys() - set(self._non_global_operations)
+            source_basis, qargs_local_source_basis = self._extract_basis_target(dag, qarg_indices)
+
+        target_basis = set(target_basis).union(basic_instrs)
+        # If the source basis is a subset of the target basis and we have no circuit
+        # instructions on qargs that have non-global operations there is nothing to
+        # translate and we can exit early.
+        source_basis_names = {x[0] for x in source_basis}
+        if source_basis_names.issubset(target_basis) and not qargs_local_source_basis:
+            return dag
+
+        logger.info(
+            "Begin BasisTranslator from source basis %s to target basis %s.",
+            source_basis,
+            target_basis,
+        )
+
+        # Search for a path from source to target basis.
+        search_start_time = time.time()
+        basis_transforms = _basis_search(self._equiv_lib, source_basis, target_basis)
+
+        qarg_local_basis_transforms = {}
+        for qarg, local_source_basis in qargs_local_source_basis.items():
+            expanded_target = set(target_basis)
+            # For any multiqubit operation that contains a subset of qubits that
+            # has a non-local operation, include that non-local operation in the
+            # search. This matches with the check we did above to include those
+            # subset non-local operations in the check here.
+            if len(qarg) > 1:
+                for non_local_qarg, local_basis in self._qargs_with_non_global_operation.items():
+                    if qarg.issuperset(non_local_qarg):
+                        expanded_target |= local_basis
+            else:
+                expanded_target |= self._qargs_with_non_global_operation[tuple(qarg)]
+
+            logger.info(
+                "Performing BasisTranslator search from source basis %s to target "
+                "basis %s on qarg %s.",
+                local_source_basis,
+                expanded_target,
+                qarg,
+            )
+            local_basis_transforms = _basis_search(
+                self._equiv_lib, local_source_basis, expanded_target
+            )
+
+            if local_basis_transforms is None:
+                raise TranspilerError(
+                    "Unable to translate the operations in the circuit: "
+                    f"{[x[0] for x in local_source_basis]} to the backend's (or manually "
+                    f"specified) target basis: {list(expanded_target)}. This likely means the "
+                    "target basis is not universal or there are additional equivalence rules "
+                    "needed in the EquivalenceLibrary being used. For more details on this "
+                    "error see: "
+                    "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
+                    "BasisTranslator#translation-errors"
+                )
+
+            qarg_local_basis_transforms[qarg] = local_basis_transforms
+
+        search_end_time = time.time()
+        logger.info(
+            "Basis translation path search completed in %.3fs.", search_end_time - search_start_time
+        )
+
+        if basis_transforms is None:
+            raise TranspilerError(
+                "Unable to translate the operations in the circuit: "
+                f"{[x[0] for x in source_basis]} to the backend's (or manually specified) target "
+                f"basis: {list(target_basis)}. This likely means the target basis is not universal "
+                "or there are additional equivalence rules needed in the EquivalenceLibrary being "
+                "used. For more details on this error see: "
+                "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
+                "BasisTranslator#translation-errors"
+            )
+
+        # Compose found path into a set of instruction substitution rules.
+
+        compose_start_time = time.time()
+        instr_map = _compose_transforms(basis_transforms, source_basis, dag)
+        extra_instr_map = {
+            qarg: _compose_transforms(transforms, qargs_local_source_basis[qarg], dag)
+            for qarg, transforms in qarg_local_basis_transforms.items()
+        }
+
+        compose_end_time = time.time()
+        logger.info(
+            "Basis translation paths composed in %.3fs.", compose_end_time - compose_start_time
+        )
+
+        # Replace source instructions with target translations.
+
+        replace_start_time = time.time()
+
+        def apply_translation(dag, wire_map):
+            is_updated = False
+            out_dag = dag.copy_empty_like()
+            for node in dag.topological_op_nodes():
+                node_qargs = tuple(wire_map[bit] for bit in node.qargs)
+                qubit_set = frozenset(node_qargs)
+                if node.name in target_basis or len(node.qargs) < self._min_qubits:
+                    if node.name in CONTROL_FLOW_OP_NAMES:
+                        flow_blocks = []
+                        for block in node.op.blocks:
+                            dag_block = circuit_to_dag(block)
+                            updated_dag, is_updated = apply_translation(
+                                dag_block,
+                                {
+                                    inner: wire_map[outer]
+                                    for inner, outer in zip(block.qubits, node.qargs)
+                                },
+                            )
+                            if is_updated:
+                                flow_circ_block = dag_to_circuit(updated_dag)
+                            else:
+                                flow_circ_block = block
+                            flow_blocks.append(flow_circ_block)
+                        node.op = node.op.replace_blocks(flow_blocks)
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
+                    continue
+                if (
+                    node_qargs in self._qargs_with_non_global_operation
+                    and node.name in self._qargs_with_non_global_operation[node_qargs]
+                ):
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
+                    continue
+
+                if dag.has_calibration_for(node):
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
+                    continue
+                if qubit_set in extra_instr_map:
+                    self._replace_node(out_dag, node, extra_instr_map[qubit_set])
+                elif (node.name, node.num_qubits) in instr_map:
+                    self._replace_node(out_dag, node, instr_map)
+                else:
+                    raise TranspilerError(f"BasisTranslator did not map {node.name}.")
+                is_updated = True
+            return out_dag, is_updated
 
-        return base_run(
-            dag,
-            self._equiv_lib,
-            self._qargs_with_non_global_operation,
-            self._min_qubits,
-            None if self._target_basis is None else set(self._target_basis),
-            self._target,
-            None if self._non_global_operations is None else set(self._non_global_operations),
+        out_dag, _ = apply_translation(dag, qarg_indices)
+        replace_end_time = time.time()
+        logger.info(
+            "Basis translation instructions replaced in %.3fs.",
+            replace_end_time - replace_start_time,
         )
+
+        return out_dag
+
+    def _replace_node(self, dag, node, instr_map):
+        target_params, target_dag = instr_map[node.name, node.num_qubits]
+        if len(node.params) != len(target_params):
+            raise TranspilerError(
+                "Translation num_params not equal to op num_params."
+                f"Op: {node.params} {node.name} Translation: {target_params}\n{target_dag}"
+            )
+        if node.params:
+            parameter_map = dict(zip(target_params, node.params))
+            for inner_node in target_dag.topological_op_nodes():
+                new_node = DAGOpNode.from_instruction(inner_node._to_circuit_instruction())
+                new_node.qargs = tuple(
+                    node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
+                )
+                new_node.cargs = tuple(
+                    node.cargs[target_dag.find_bit(x).index] for x in inner_node.cargs
+                )
+
+                if not new_node.is_standard_gate():
+                    new_node.op = new_node.op.copy()
+                if any(isinstance(x, ParameterExpression) for x in inner_node.params):
+                    new_params = []
+                    for param in new_node.params:
+                        if not isinstance(param, ParameterExpression):
+                            new_params.append(param)
+                        else:
+                            bind_dict = {x: parameter_map[x] for x in param.parameters}
+                            if any(isinstance(x, ParameterExpression) for x in bind_dict.values()):
+                                new_value = param
+                                for x in bind_dict.items():
+                                    new_value = new_value.assign(*x)
+                            else:
+                                new_value = param.bind(bind_dict)
+                            if not new_value.parameters:
+                                new_value = new_value.numeric()
+                            new_params.append(new_value)
+                    new_node.params = new_params
+                    if not new_node.is_standard_gate():
+                        new_node.op.params = new_params
+                dag._apply_op_node_back(new_node)
+
+            if isinstance(target_dag.global_phase, ParameterExpression):
+                old_phase = target_dag.global_phase
+                bind_dict = {x: parameter_map[x] for x in old_phase.parameters}
+                if any(isinstance(x, ParameterExpression) for x in bind_dict.values()):
+                    new_phase = old_phase
+                    for x in bind_dict.items():
+                        new_phase = new_phase.assign(*x)
+                else:
+                    new_phase = old_phase.bind(bind_dict)
+                if not new_phase.parameters:
+                    new_phase = new_phase.numeric()
+                    if isinstance(new_phase, complex):
+                        raise TranspilerError(f"Global phase must be real, but got '{new_phase}'")
+                dag.global_phase += new_phase
+
+        else:
+            for inner_node in target_dag.topological_op_nodes():
+                new_node = DAGOpNode.from_instruction(
+                    inner_node._to_circuit_instruction(),
+                )
+                new_node.qargs = tuple(
+                    node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
+                )
+                new_node.cargs = tuple(
+                    node.cargs[target_dag.find_bit(x).index] for x in inner_node.cargs
+                )
+                if not new_node.is_standard_gate:
+                    new_node.op = new_node.op.copy()
+                # dag_op may be the same instance as other ops in the dag,
+                # so if there is a condition, need to copy
+                if getattr(node.op, "condition", None):
+                    new_node_op = new_node.op.to_mutable()
+                    new_node_op.condition = node.op.condition
+                    new_node.op = new_node_op
+                dag._apply_op_node_back(new_node)
+            if target_dag.global_phase:
+                dag.global_phase += target_dag.global_phase
+
+    @singledispatchmethod
+    def _extract_basis(self, circuit):
+        return circuit
+
+    @_extract_basis.register
+    def _(self, dag: DAGCircuit):
+        for node in dag.op_nodes():
+            if not dag.has_calibration_for(node) and len(node.qargs) >= self._min_qubits:
+                yield (node.name, node.num_qubits)
+            if node.name in CONTROL_FLOW_OP_NAMES:
+                for block in node.op.blocks:
+                    yield from self._extract_basis(block)
+
+    @_extract_basis.register
+    def _(self, circ: QuantumCircuit):
+        for instruction in circ.data:
+            operation = instruction.operation
+            if (
+                not circ.has_calibration_for(instruction)
+                and len(instruction.qubits) >= self._min_qubits
+            ):
+                yield (operation.name, operation.num_qubits)
+            if isinstance(operation, ControlFlowOp):
+                for block in operation.blocks:
+                    yield from self._extract_basis(block)
+
+    def _extract_basis_target(
+        self, dag, qarg_indices, source_basis=None, qargs_local_source_basis=None
+    ):
+        if source_basis is None:
+            source_basis = set()
+        if qargs_local_source_basis is None:
+            qargs_local_source_basis = defaultdict(set)
+        for node in dag.op_nodes():
+            qargs = tuple(qarg_indices[bit] for bit in node.qargs)
+            if dag.has_calibration_for(node) or len(node.qargs) < self._min_qubits:
+                continue
+            # Treat the instruction as on an incomplete basis if the qargs are in the
+            # qargs_with_non_global_operation dictionary or if any of the qubits in qargs
+            # are a superset for a non-local operation. For example, if the qargs
+            # are (0, 1) and that's a global (ie no non-local operations on (0, 1)
+            # operation but there is a non-local operation on (1,) we need to
+            # do an extra non-local search for this op to ensure we include any
+            # single qubit operation for (1,) as valid. This pattern also holds
+            # true for > 2q ops too (so for 4q operations we need to check for 3q, 2q,
+            # and 1q operations in the same manner)
+            if qargs in self._qargs_with_non_global_operation or any(
+                frozenset(qargs).issuperset(incomplete_qargs)
+                for incomplete_qargs in self._qargs_with_non_global_operation
+            ):
+                qargs_local_source_basis[frozenset(qargs)].add((node.name, node.num_qubits))
+            else:
+                source_basis.add((node.name, node.num_qubits))
+            if node.name in CONTROL_FLOW_OP_NAMES:
+                for block in node.op.blocks:
+                    block_dag = circuit_to_dag(block)
+                    source_basis, qargs_local_source_basis = self._extract_basis_target(
+                        block_dag,
+                        {
+                            inner: qarg_indices[outer]
+                            for inner, outer in zip(block.qubits, node.qargs)
+                        },
+                        source_basis=source_basis,
+                        qargs_local_source_basis=qargs_local_source_basis,
+                    )
+        return source_basis, qargs_local_source_basis
+
+
+class StopIfBasisRewritable(Exception):
+    """Custom exception that signals `rustworkx.dijkstra_search` to stop."""
+
+
+class BasisSearchVisitor(rustworkx.visit.DijkstraVisitor):
+    """Handles events emitted during `rustworkx.dijkstra_search`."""
+
+    def __init__(self, graph, source_basis, target_basis):
+        self.graph = graph
+        self.target_basis = set(target_basis)
+        self._source_gates_remain = set(source_basis)
+        self._num_gates_remain_for_rule = {}
+        save_index = -1
+        for edata in self.graph.edges():
+            if save_index == edata.index:
+                continue
+            self._num_gates_remain_for_rule[edata.index] = edata.num_gates
+            save_index = edata.index
+
+        self._basis_transforms = []
+        self._predecessors = {}
+        self._opt_cost_map = {}
+
+    def discover_vertex(self, v, score):
+        gate = self.graph[v].key
+        self._source_gates_remain.discard(gate)
+        self._opt_cost_map[gate] = score
+        rule = self._predecessors.get(gate, None)
+        if rule is not None:
+            logger.debug(
+                "Gate %s generated using rule \n%s\n with total cost of %s.",
+                gate.name,
+                rule.circuit,
+                score,
+            )
+            self._basis_transforms.append((gate.name, gate.num_qubits, rule.params, rule.circuit))
+        # we can stop the search if we have found all gates in the original circuit.
+        if not self._source_gates_remain:
+            # if we start from source gates and apply `basis_transforms` in reverse order, we'll end
+            # up with gates in the target basis. Note though that `basis_transforms` may include
+            # additional transformations that are not required to map our source gates to the given
+            # target basis.
+            self._basis_transforms.reverse()
+            raise StopIfBasisRewritable
+
+    def examine_edge(self, edge):
+        _, target, edata = edge
+        if edata is None:
+            return
+
+        self._num_gates_remain_for_rule[edata.index] -= 1
+
+        target = self.graph[target].key
+        # if there are gates in this `rule` that we have not yet generated, we can't apply
+        # this `rule`. if `target` is already in basis, it's not beneficial to use this rule.
+        if self._num_gates_remain_for_rule[edata.index] > 0 or target in self.target_basis:
+            raise rustworkx.visit.PruneSearch
+
+    def edge_relaxed(self, edge):
+        _, target, edata = edge
+        if edata is not None:
+            gate = self.graph[target].key
+            self._predecessors[gate] = edata.rule
+
+    def edge_cost(self, edge_data):
+        """Returns the cost of an edge.
+
+        This function computes the cost of this edge rule by summing
+        the costs of all gates in the rule equivalence circuit. In the
+        end, we need to subtract the cost of the source since `dijkstra`
+        will later add it.
+        """
+
+        if edge_data is None:
+            # the target of the edge is a gate in the target basis,
+            # so we return a default value of 1.
+            return 1
+
+        cost_tot = 0
+        for instruction in edge_data.rule.circuit:
+            key = Key(name=instruction.name, num_qubits=len(instruction.qubits))
+            cost_tot += self._opt_cost_map[key]
+
+        return cost_tot - self._opt_cost_map[edge_data.source]
+
+    @property
+    def basis_transforms(self):
+        """Returns the gate basis transforms."""
+        return self._basis_transforms
+
+
+def _basis_search(equiv_lib, source_basis, target_basis):
+    """Search for a set of transformations from source_basis to target_basis.
+
+    Args:
+        equiv_lib (EquivalenceLibrary): Source of valid translations
+        source_basis (Set[Tuple[gate_name: str, gate_num_qubits: int]]): Starting basis.
+        target_basis (Set[gate_name: str]): Target basis.
+
+    Returns:
+        Optional[List[Tuple[gate, equiv_params, equiv_circuit]]]: List of (gate,
+            equiv_params, equiv_circuit) tuples tuples which, if applied in order
+            will map from source_basis to target_basis. Returns None if no path
+            was found.
+    """
+
+    logger.debug("Begining basis search from %s to %s.", source_basis, target_basis)
+
+    source_basis = {
+        (gate_name, gate_num_qubits)
+        for gate_name, gate_num_qubits in source_basis
+        if gate_name not in target_basis
+    }
+
+    # if source basis is empty, no work to be done.
+    if not source_basis:
+        return []
+
+    # This is only necessary since gates in target basis are currently reported by
+    # their names and we need to have in addition the number of qubits they act on.
+    target_basis_keys = [key for key in equiv_lib.keys() if key.name in target_basis]
+
+    graph = equiv_lib.graph
+    vis = BasisSearchVisitor(graph, source_basis, target_basis_keys)
+
+    # we add a dummy node and connect it with gates in the target basis.
+    # we'll start the search from this dummy node.
+    dummy = graph.add_node(NodeData(key="key", equivs=[("dummy starting node", 0)]))
+
+    try:
+        graph.add_edges_from_no_data(
+            [(dummy, equiv_lib.node_index(key)) for key in target_basis_keys]
+        )
+        rtn = None
+        try:
+            rustworkx.digraph_dijkstra_search(graph, [dummy], vis.edge_cost, vis)
+        except StopIfBasisRewritable:
+            rtn = vis.basis_transforms
+
+            logger.debug("Transformation path:")
+            for gate_name, gate_num_qubits, params, equiv in rtn:
+                logger.debug("%s/%s => %s\n%s", gate_name, gate_num_qubits, params, equiv)
+    finally:
+        # Remove dummy node in order to return graph to original state
+        graph.remove_node(dummy)
+
+    return rtn
+
+
+def _compose_transforms(basis_transforms, source_basis, source_dag):
+    """Compose a set of basis transforms into a set of replacements.
+
+    Args:
+        basis_transforms (List[Tuple[gate_name, params, equiv]]): List of
+            transforms to compose.
+        source_basis (Set[Tuple[gate_name: str, gate_num_qubits: int]]): Names
+            of gates which need to be translated.
+        source_dag (DAGCircuit): DAG with example gates from source_basis.
+            (Used to determine num_params for gate in source_basis.)
+
+    Returns:
+        Dict[gate_name, Tuple(params, dag)]: Dictionary mapping between each gate
+            in source_basis and a DAGCircuit instance to replace it. Gates in
+            source_basis but not affected by basis_transforms will be included
+            as a key mapping to itself.
+    """
+    example_gates = _get_example_gates(source_dag)
+    mapped_instrs = {}
+
+    for gate_name, gate_num_qubits in source_basis:
+        # Need to grab a gate instance to find num_qubits and num_params.
+        # Can be removed following https://github.com/Qiskit/qiskit-terra/pull/3947 .
+        example_gate = example_gates[gate_name, gate_num_qubits]
+        num_params = len(example_gate.params)
+
+        placeholder_params = ParameterVector(gate_name, num_params)
+        placeholder_gate = Gate(gate_name, gate_num_qubits, list(placeholder_params))
+        placeholder_gate.params = list(placeholder_params)
+
+        dag = DAGCircuit()
+        qr = QuantumRegister(gate_num_qubits)
+        dag.add_qreg(qr)
+        dag.apply_operation_back(placeholder_gate, qr, (), check=False)
+        mapped_instrs[gate_name, gate_num_qubits] = placeholder_params, dag
+
+    for gate_name, gate_num_qubits, equiv_params, equiv in basis_transforms:
+        logger.debug(
+            "Composing transform step: %s/%s %s =>\n%s",
+            gate_name,
+            gate_num_qubits,
+            equiv_params,
+            equiv,
+        )
+
+        for mapped_instr_name, (dag_params, dag) in mapped_instrs.items():
+            doomed_nodes = [
+                node
+                for node in dag.op_nodes()
+                if (node.name, node.num_qubits) == (gate_name, gate_num_qubits)
+            ]
+
+            if doomed_nodes and logger.isEnabledFor(logging.DEBUG):
+
+                logger.debug(
+                    "Updating transform for mapped instr %s %s from \n%s",
+                    mapped_instr_name,
+                    dag_params,
+                    dag_to_circuit(dag, copy_operations=False),
+                )
+
+            for node in doomed_nodes:
+
+                replacement = equiv.assign_parameters(dict(zip_longest(equiv_params, node.params)))
+
+                replacement_dag = circuit_to_dag(replacement)
+
+                dag.substitute_node_with_dag(node, replacement_dag)
+
+            if doomed_nodes and logger.isEnabledFor(logging.DEBUG):
+
+                logger.debug(
+                    "Updated transform for mapped instr %s %s to\n%s",
+                    mapped_instr_name,
+                    dag_params,
+                    dag_to_circuit(dag, copy_operations=False),
+                )
+
+    return mapped_instrs
+
+
+def _get_example_gates(source_dag):
+    def recurse(dag, example_gates=None):
+        example_gates = example_gates or {}
+        for node in dag.op_nodes():
+            example_gates[(node.name, node.num_qubits)] = node
+            if node.name in CONTROL_FLOW_OP_NAMES:
+                for block in node.op.blocks:
+                    example_gates = recurse(circuit_to_dag(block), example_gates)
+        return example_gates
+
+    return recurse(source_dag)

qiskit/transpiler/passes/basis/decompose.py

@@ -11,20 +11,13 @@
 # that they have been altered from the originals.
 
 """Expand a gate in a circuit using its decomposition rules."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Type
+from typing import Type, Union, List, Optional
 from fnmatch import fnmatch
 
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.dagcircuit.dagnode import DAGOpNode
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.converters.circuit_to_dag import circuit_to_dag
-from qiskit.circuit.instruction import Instruction
-
-from ..synthesis import HighLevelSynthesis
+from qiskit.circuit.gate import Gate
 
 
 class Decompose(TransformationPass):
@@ -32,21 +25,16 @@ class Decompose(TransformationPass):
 
     def __init__(
         self,
-        gates_to_decompose: (
-            str | Type[Instruction] | Sequence[str | Type[Instruction]] | None
-        ) = None,
-        apply_synthesis: bool = False,
+        gates_to_decompose: Optional[Union[Type[Gate], List[Type[Gate]], List[str], str]] = None,
     ) -> None:
-        """
+        """Decompose initializer.
+
         Args:
             gates_to_decompose: optional subset of gates to be decomposed,
                 identified by gate label, name or type. Defaults to all gates.
-            apply_synthesis: If ``True``, run :class:`.HighLevelSynthesis` to synthesize operations
-                that do not have a definition attached.
         """
         super().__init__()
         self.gates_to_decompose = gates_to_decompose
-        self.apply_synthesis = apply_synthesis
 
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the Decompose pass on `dag`.
@@ -57,26 +45,13 @@ class Decompose(TransformationPass):
         Returns:
             output dag where ``gate`` was expanded.
         """
-        # We might use HLS to synthesize objects that do not have a definition
-        hls = HighLevelSynthesis() if self.apply_synthesis else None
-
         # Walk through the DAG and expand each non-basis node
         for node in dag.op_nodes():
-            # Check in self.gates_to_decompose if the operation should be decomposed
-            if not self._should_decompose(node):
-                continue
-
-            if getattr(node.op, "definition", None) is None:
-                # if we try to synthesize, turn the node into a DAGCircuit and run HLS
-                if self.apply_synthesis:
-                    node_as_dag = _node_to_dag(node)
-                    synthesized = hls.run(node_as_dag)
-                    dag.substitute_node_with_dag(node, synthesized)
-
-                # else: no definition and synthesis not enabled, so we do nothing
-            else:
+            if self._should_decompose(node):
+                if getattr(node.op, "definition", None) is None:
+                    continue
+                # TODO: allow choosing among multiple decomposition rules
                 rule = node.op.definition.data
-
                 if (
                     len(rule) == 1
                     and len(node.qargs) == len(rule[0].qubits) == 1  # to preserve gate order
@@ -91,8 +66,9 @@ class Decompose(TransformationPass):
 
         return dag
 
-    def _should_decompose(self, node: DAGOpNode) -> bool:
-        """Call a decomposition pass on this circuit to decompose one level (shallow decompose)."""
+    def _should_decompose(self, node) -> bool:
+        """Call a decomposition pass on this circuit,
+        to decompose one level (shallow decompose)."""
         if self.gates_to_decompose is None:  # check if no gates given
             return True
 
@@ -120,12 +96,3 @@ class Decompose(TransformationPass):
             return True
         else:
             return False
-
-
-def _node_to_dag(node: DAGOpNode) -> DAGCircuit:
-    dag = DAGCircuit()
-    dag.add_qubits(node.qargs)
-    dag.add_clbits(node.cargs)
-
-    dag.apply_operation_back(node.op, node.qargs, node.cargs)
-    return dag