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

qiskit/transpiler/passes/basis/basis_translator.py

@@ -13,29 +13,12 @@
 
 """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.transpiler.exceptions import TranspilerError
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit._accelerate.basis.basis_translator import base_run
 
 logger = logging.getLogger(__name__)
 
@@ -142,552 +125,13 @@ 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
 
-        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 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),
         )
-
-        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,13 +11,20 @@
 # that they have been altered from the originals.
 
 """Expand a gate in a circuit using its decomposition rules."""
-from typing import Type, Union, List, Optional
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Type
 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.gate import Gate
+from qiskit.circuit.instruction import Instruction
+
+from ..synthesis import HighLevelSynthesis
 
 
 class Decompose(TransformationPass):
@@ -25,16 +32,21 @@ class Decompose(TransformationPass):
 
     def __init__(
         self,
-        gates_to_decompose: Optional[Union[Type[Gate], List[Type[Gate]], List[str], str]] = None,
+        gates_to_decompose: (
+            str | Type[Instruction] | Sequence[str | Type[Instruction]] | None
+        ) = None,
+        apply_synthesis: bool = False,
     ) -> 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`.
@@ -45,13 +57,26 @@ 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():
-            if self._should_decompose(node):
-                if getattr(node.op, "definition", None) is None:
-                    continue
-                # TODO: allow choosing among multiple decomposition rules
+            # 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:
                 rule = node.op.definition.data
+
                 if (
                     len(rule) == 1
                     and len(node.qargs) == len(rule[0].qubits) == 1  # to preserve gate order
@@ -66,9 +91,8 @@ class Decompose(TransformationPass):
 
         return dag
 
-    def _should_decompose(self, node) -> bool:
-        """Call a decomposition pass on this circuit,
-        to decompose one level (shallow decompose)."""
+    def _should_decompose(self, node: DAGOpNode) -> 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
 
@@ -96,3 +120,12 @@ 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