qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/transpiler/passes/basis/basis_translator.py

@@ -30,11 +30,12 @@ from qiskit.circuit import (
     QuantumCircuit,
     ParameterExpression,
 )
-from qiskit.dagcircuit import DAGCircuit
+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
 
 logger = logging.getLogger(__name__)
 
@@ -161,7 +162,8 @@ class BasisTranslator(TransformationPass):
         # 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.
-        if source_basis.issubset(target_basis) and not qargs_local_source_basis:
+        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(
@@ -207,7 +209,7 @@ class BasisTranslator(TransformationPass):
                     "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/transpiler_passes."
+                    "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
                     "BasisTranslator#translation-errors"
                 )
 
@@ -225,7 +227,7 @@ class BasisTranslator(TransformationPass):
                 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/transpiler_passes."
+                "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
                 "BasisTranslator#translation-errors"
             )
 
@@ -248,72 +250,85 @@ class BasisTranslator(TransformationPass):
         replace_start_time = time.time()
 
         def apply_translation(dag, wire_map):
-            dag_updated = False
-            for node in dag.op_nodes():
+            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 isinstance(node.op, ControlFlowOp):
+                    if node.name in CONTROL_FLOW_OP_NAMES:
                         flow_blocks = []
                         for block in node.op.blocks:
                             dag_block = circuit_to_dag(block)
-                            dag_updated = apply_translation(
+                            updated_dag, is_updated = apply_translation(
                                 dag_block,
                                 {
                                     inner: wire_map[outer]
                                     for inner, outer in zip(block.qubits, node.qargs)
                                 },
                             )
-                            if dag_updated:
-                                flow_circ_block = dag_to_circuit(dag_block)
+                            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(dag, node, extra_instr_map[qubit_set])
-                elif (node.op.name, node.op.num_qubits) in instr_map:
-                    self._replace_node(dag, node, 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}.")
-                dag_updated = True
-            return dag_updated
+                is_updated = True
+            return out_dag, is_updated
 
-        apply_translation(dag, qarg_indices)
+        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 dag
+        return out_dag
 
     def _replace_node(self, dag, node, instr_map):
-        target_params, target_dag = instr_map[node.op.name, node.op.num_qubits]
-        if len(node.op.params) != len(target_params):
+        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."
-                "Op: {} {} Translation: {}\n{}".format(
-                    node.op.params, node.op.name, target_params, target_dag
-                )
+                f"Op: {node.params} {node.name} Translation: {target_params}\n{target_dag}"
             )
-        if node.op.params:
-            parameter_map = dict(zip(target_params, node.op.params))
-            bound_target_dag = target_dag.copy_empty_like()
+        if node.params:
+            parameter_map = dict(zip(target_params, node.params))
             for inner_node in target_dag.topological_op_nodes():
-                if any(isinstance(x, ParameterExpression) for x in inner_node.op.params):
-                    new_op = inner_node.op.copy()
+                new_node = DAGOpNode.from_instruction(
+                    inner_node._to_circuit_instruction(),
+                    dag=target_dag,
+                )
+                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_op.params:
+                    for param in new_node.params:
                         if not isinstance(param, ParameterExpression):
                             new_params.append(param)
                         else:
@@ -327,10 +342,11 @@ class BasisTranslator(TransformationPass):
                             if not new_value.parameters:
                                 new_value = new_value.numeric()
                             new_params.append(new_value)
-                    new_op.params = new_params
-                else:
-                    new_op = inner_node.op
-                bound_target_dag.apply_operation_back(new_op, inner_node.qargs, inner_node.cargs)
+                    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}
@@ -338,31 +354,37 @@ class BasisTranslator(TransformationPass):
                     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}'")
-                bound_target_dag.global_phase = new_phase
-        else:
-            bound_target_dag = target_dag
-
-        if len(bound_target_dag.op_nodes()) == 1 and len(
-            bound_target_dag.op_nodes()[0].qargs
-        ) == len(node.qargs):
-            dag_op = bound_target_dag.op_nodes()[0].op
-            # 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):
-                dag_op = dag_op.copy()
-            dag.substitute_node(node, dag_op, inplace=True)
-
-            if bound_target_dag.global_phase:
-                dag.global_phase += bound_target_dag.global_phase
+                dag.global_phase += new_phase
+
         else:
-            dag.substitute_node_with_dag(node, bound_target_dag)
+            for inner_node in target_dag.topological_op_nodes():
+                new_node = DAGOpNode.from_instruction(
+                    inner_node._to_circuit_instruction(),
+                    dag=target_dag,
+                )
+                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):
@@ -372,8 +394,8 @@ class BasisTranslator(TransformationPass):
     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.op.num_qubits)
-            if isinstance(node.op, ControlFlowOp):
+                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)
 
@@ -414,10 +436,10 @@ class BasisTranslator(TransformationPass):
                 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.op.num_qubits))
+                qargs_local_source_basis[frozenset(qargs)].add((node.name, node.num_qubits))
             else:
-                source_basis.add((node.name, node.op.num_qubits))
-            if isinstance(node.op, ControlFlowOp):
+                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(
@@ -468,7 +490,7 @@ class BasisSearchVisitor(rustworkx.visit.DijkstraVisitor):
                 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 ciruit.
+        # 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
@@ -512,7 +534,7 @@ class BasisSearchVisitor(rustworkx.visit.DijkstraVisitor):
 
         cost_tot = 0
         for instruction in edge_data.rule.circuit:
-            key = Key(name=instruction.operation.name, num_qubits=len(instruction.qubits))
+            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]
@@ -550,7 +572,7 @@ def _basis_search(equiv_lib, source_basis, target_basis):
     if not source_basis:
         return []
 
-    # This is only neccessary since gates in target basis are currently reported by
+    # 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]
 
@@ -630,7 +652,7 @@ def _compose_transforms(basis_transforms, source_basis, source_dag):
             doomed_nodes = [
                 node
                 for node in dag.op_nodes()
-                if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)
+                if (node.name, node.num_qubits) == (gate_name, gate_num_qubits)
             ]
 
             if doomed_nodes and logger.isEnabledFor(logging.DEBUG):
@@ -644,9 +666,7 @@ def _compose_transforms(basis_transforms, source_basis, source_dag):
 
             for node in doomed_nodes:
 
-                replacement = equiv.assign_parameters(
-                    dict(zip_longest(equiv_params, node.op.params))
-                )
+                replacement = equiv.assign_parameters(dict(zip_longest(equiv_params, node.params)))
 
                 replacement_dag = circuit_to_dag(replacement)
 
@@ -668,8 +688,8 @@ 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.op.name, node.op.num_qubits)] = node.op
-            if isinstance(node.op, ControlFlowOp):
+            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

qiskit/transpiler/passes/basis/translate_parameterized.py

@@ -15,15 +15,13 @@
 from __future__ import annotations
 
 from qiskit.circuit import Instruction, ParameterExpression, Qubit, Clbit
+from qiskit.circuit.equivalence_library import EquivalenceLibrary
 from qiskit.converters import circuit_to_dag
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode
-from qiskit.circuit.equivalence_library import EquivalenceLibrary
 from qiskit.exceptions import QiskitError
-from qiskit.transpiler import Target
-
 from qiskit.transpiler.basepasses import TransformationPass
-
-from .basis_translator import BasisTranslator
+from qiskit.transpiler.passes.basis.basis_translator import BasisTranslator
+from qiskit.transpiler.target import Target
 
 
 class TranslateParameterizedGates(TransformationPass):

qiskit/transpiler/passes/basis/unroll_3q_or_more.py

@@ -78,7 +78,7 @@ class Unroll3qOrMore(TransformationPass):
                     continue
                 raise QiskitError(
                     "Cannot unroll all 3q or more gates. "
-                    "No rule to expand instruction %s." % node.op.name
+                    f"No rule to expand instruction {node.op.name}."
                 )
             decomposition = circuit_to_dag(node.op.definition, copy_operations=False)
             decomposition = self.run(decomposition)  # recursively unroll

qiskit/transpiler/passes/basis/unroll_custom_definitions.py

@@ -60,9 +60,9 @@ class UnrollCustomDefinitions(TransformationPass):
         if self._basis_gates is None and self._target is None:
             return dag
 
+        device_insts = {"measure", "reset", "barrier", "snapshot", "delay", "store"}
         if self._target is None:
-            basic_insts = {"measure", "reset", "barrier", "snapshot", "delay", "store"}
-            device_insts = basic_insts | set(self._basis_gates)
+            device_insts |= set(self._basis_gates)
 
         for node in dag.op_nodes():
             if isinstance(node.op, ControlFlowOp):
@@ -77,14 +77,14 @@ class UnrollCustomDefinitions(TransformationPass):
 
             controlled_gate_open_ctrl = isinstance(node.op, ControlledGate) and node.op._open_ctrl
             if not controlled_gate_open_ctrl:
-                inst_supported = (
-                    self._target.instruction_supported(
+                if self._target is not None:
+                    inst_supported = self._target.instruction_supported(
                         operation_name=node.op.name,
                         qargs=tuple(dag.find_bit(x).index for x in node.qargs),
                     )
-                    if self._target is not None
-                    else node.name in device_insts
-                )
+                else:
+                    inst_supported = node.name in device_insts
+
                 if inst_supported or self._equiv_lib.has_entry(node.op):
                     continue
             try:
@@ -95,9 +95,9 @@ class UnrollCustomDefinitions(TransformationPass):
             if unrolled is None:
                 # opaque node
                 raise QiskitError(
-                    "Cannot unroll the circuit to the given basis, %s. "
-                    "Instruction %s not found in equivalence library "
-                    "and no rule found to expand." % (str(self._basis_gates), node.op.name)
+                    f"Cannot unroll the circuit to the given basis, {str(self._basis_gates)}. "
+                    f"Instruction {node.op.name} not found in equivalence library "
+                    "and no rule found to expand."
                 )
 
             decomposition = circuit_to_dag(unrolled, copy_operations=False)

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -17,13 +17,13 @@ from functools import lru_cache
 import numpy as np
 
 from qiskit.circuit import Instruction
+from qiskit.circuit.library.standard_gates import RXGate
+from qiskit.exceptions import QiskitError
 from qiskit.pulse import Schedule, ScheduleBlock, builder, ScalableSymbolicPulse
 from qiskit.pulse.channels import Channel
 from qiskit.pulse.library.symbolic_pulses import Drag
 from qiskit.transpiler.passes.calibration.base_builder import CalibrationBuilder
-from qiskit.transpiler import Target
-from qiskit.circuit.library.standard_gates import RXGate
-from qiskit.exceptions import QiskitError
+from qiskit.transpiler.target import Target
 
 
 class RXCalibrationBuilder(CalibrationBuilder):

qiskit/transpiler/passes/calibration/rzx_builder.py

@@ -204,7 +204,7 @@ class RZXCalibrationBuilder(CalibrationBuilder):
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
             xgate = self._inst_map.get("x", qubits[0])
             with builder.build(
-                default_alignment="sequential", name="rzx(%.3f)" % theta
+                default_alignment="sequential", name=f"rzx({theta:.3f})"
             ) as rzx_theta_native:
                 for cr_tone, comp_tone in zip(cr_tones, comp_tones):
                     with builder.align_left():
@@ -230,7 +230,7 @@ class RZXCalibrationBuilder(CalibrationBuilder):
             builder.call(szt, name="szt")
 
         with builder.build(
-            default_alignment="sequential", name="rzx(%.3f)" % theta
+            default_alignment="sequential", name=f"rzx({theta:.3f})"
         ) as rzx_theta_flip:
             builder.call(hadamard, name="hadamard")
             for cr_tone, comp_tone in zip(cr_tones, comp_tones):
@@ -297,7 +297,7 @@ class RZXCalibrationBuilderNoEcho(RZXCalibrationBuilder):
 
         # RZXCalibrationNoEcho only good for forward CR direction
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            with builder.build(default_alignment="left", name="rzx(%.3f)" % theta) as rzx_theta:
+            with builder.build(default_alignment="left", name=f"rzx({theta:.3f})") as rzx_theta:
                 stretched_dur = self.rescale_cr_inst(cr_tones[0], 2 * theta)
                 self.rescale_cr_inst(comp_tones[0], 2 * theta)
                 # Placeholder to make pulse gate work

qiskit/transpiler/passes/layout/apply_layout.py

@@ -13,7 +13,7 @@
 """Transform a circuit with virtual qubits into a circuit with physical qubits."""
 
 from qiskit.circuit import QuantumRegister
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.layout import Layout
@@ -79,7 +79,12 @@ class ApplyLayout(TransformationPass):
             virtual_physical_map = layout.get_virtual_bits()
             for node in dag.topological_op_nodes():
                 qargs = [q[virtual_physical_map[qarg]] for qarg in node.qargs]
-                new_dag.apply_operation_back(node.op, qargs, node.cargs, check=False)
+                new_dag._apply_op_node_back(
+                    DAGOpNode.from_instruction(
+                        node._to_circuit_instruction().replace(qubits=qargs)
+                    ),
+                    check=False,
+                )
         else:
             # First build a new layout object going from:
             # old virtual -> old physical -> new virtual -> new physical
@@ -99,7 +104,12 @@ class ApplyLayout(TransformationPass):
             # Apply new layout to the circuit
             for node in dag.topological_op_nodes():
                 qargs = [q[new_virtual_to_physical[qarg]] for qarg in node.qargs]
-                new_dag.apply_operation_back(node.op, qargs, node.cargs, check=False)
+                new_dag._apply_op_node_back(
+                    DAGOpNode.from_instruction(
+                        node._to_circuit_instruction().replace(qubits=qargs)
+                    ),
+                    check=False,
+                )
             self.property_set["layout"] = full_layout
             if (final_layout := self.property_set["final_layout"]) is not None:
                 final_layout_mapping = {

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -35,11 +35,7 @@ from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit._accelerate.nlayout import NLayout
-from qiskit._accelerate.sabre import (
-    sabre_layout_and_routing,
-    Heuristic,
-    NeighborTable,
-)
+from qiskit._accelerate.sabre import sabre_layout_and_routing, Heuristic, NeighborTable, SetScaling
 from qiskit.transpiler.passes.routing.sabre_swap import _build_sabre_dag, _apply_sabre_result
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.coupling import CouplingMap
@@ -144,7 +140,7 @@ class SabreLayout(TransformationPass):
                 with the ``routing_pass`` argument and an error will be raised
                 if both are used.
             layout_trials (int): The number of random seed trials to run
-                layout with. When > 1 the trial that resuls in the output with
+                layout with. When > 1 the trial that results in the output with
                 the fewest swap gates will be selected. If this is not specified
                 (and ``routing_pass`` is not set) then the number of local
                 physical CPUs will be used as the default value. This option is
@@ -393,12 +389,18 @@ class SabreLayout(TransformationPass):
             coupling_map.size(),
             original_qubit_indices,
         )
+        heuristic = (
+            Heuristic(attempt_limit=10 * coupling_map.size())
+            .with_basic(1.0, SetScaling.Size)
+            .with_lookahead(0.5, 20, SetScaling.Size)
+            .with_decay(0.001, 5)
+        )
         sabre_start = time.perf_counter()
         (initial_layout, final_permutation, sabre_result) = sabre_layout_and_routing(
             sabre_dag,
             neighbor_table,
             dist_matrix,
-            Heuristic.Decay,
+            heuristic,
             self.max_iterations,
             self.swap_trials,
             self.layout_trials,
@@ -420,7 +422,7 @@ class SabreLayout(TransformationPass):
         )
 
     def _ancilla_allocation_no_pass_manager(self, dag):
-        """Run the ancilla-allocation and -enlargment passes on the DAG chained onto our
+        """Run the ancilla-allocation and -enlargement passes on the DAG chained onto our
         ``property_set``, skipping the DAG-to-circuit conversion cost of using a ``PassManager``."""
         ancilla_pass = FullAncillaAllocation(self.coupling_map)
         ancilla_pass.property_set = self.property_set

qiskit/transpiler/passes/layout/sabre_pre_layout.py

@@ -14,8 +14,11 @@
 
 import itertools
 
-from qiskit.transpiler import CouplingMap, Target, AnalysisPass, TranspilerError
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.coupling import CouplingMap
+from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes.layout.vf2_layout import VF2Layout
+from qiskit.transpiler.target import Target
 from qiskit._accelerate.error_map import ErrorMap
 
 

qiskit/transpiler/passes/layout/set_layout.py

@@ -11,9 +11,9 @@
 # that they have been altered from the originals.
 
 """Set the ``layout`` property to the given layout."""
-from qiskit.transpiler import Layout
-from qiskit.transpiler.exceptions import InvalidLayoutError
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import InvalidLayoutError
+from qiskit.transpiler.layout import Layout
 
 
 class SetLayout(AnalysisPass):

qiskit/transpiler/passes/layout/vf2_layout.py

@@ -195,7 +195,7 @@ class VF2Layout(AnalysisPass):
             if len(cm_graph) == len(im_graph):
                 chosen_layout = mapping_to_layout(layout_mapping)
                 break
-            # If there is no error map avilable we can just skip the scoring stage as there
+            # If there is no error map available we can just skip the scoring stage as there
             # is nothing to score with, so any match is the best we can find.
             if self.avg_error_map is None:
                 chosen_layout = mapping_to_layout(layout_mapping)

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -19,7 +19,7 @@ import random
 import numpy as np
 from rustworkx import PyDiGraph, PyGraph, connected_components
 
-from qiskit.circuit import ControlFlowOp, ForLoopOp
+from qiskit.circuit import ForLoopOp
 from qiskit.converters import circuit_to_dag
 from qiskit._accelerate import vf2_layout
 from qiskit._accelerate.nlayout import NLayout
@@ -37,7 +37,7 @@ def build_interaction_graph(dag, strict_direction=True):
 
     def _visit(dag, weight, wire_map):
         for node in dag.op_nodes(include_directives=False):
-            if isinstance(node.op, ControlFlowOp):
+            if node.is_control_flow():
                 if isinstance(node.op, ForLoopOp):
                     inner_weight = len(node.op.params[0]) * weight
                 else:
@@ -57,7 +57,7 @@ def build_interaction_graph(dag, strict_direction=True):
                     im_graph_node_map[qargs[0]] = im_graph.add_node(weights)
                     reverse_im_graph_node_map[im_graph_node_map[qargs[0]]] = qargs[0]
                 else:
-                    im_graph[im_graph_node_map[qargs[0]]][node.op.name] += weight
+                    im_graph[im_graph_node_map[qargs[0]]][node.name] += weight
             if len_args == 2:
                 if qargs[0] not in im_graph_node_map:
                     im_graph_node_map[qargs[0]] = im_graph.add_node(defaultdict(int))

qiskit/transpiler/passes/optimization/__init__.py

@@ -38,3 +38,4 @@ from .collect_cliffords import CollectCliffords
 from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
+from .split_2q_unitaries import Split2QUnitaries

qiskit/transpiler/passes/optimization/collect_multiqubit_blocks.py

@@ -218,8 +218,8 @@ class CollectMultiQBlocks(AnalysisPass):
                     prev = bit
                 self.gate_groups[self.find_set(prev)].append(nd)
         # need to turn all groups that still exist into their own blocks
-        for index in self.parent:
-            if self.parent[index] == index and len(self.gate_groups[index]) != 0:
+        for index, item in self.parent.items():
+            if item == index and len(self.gate_groups[index]) != 0:
                 block_list.append(self.gate_groups[index][:])
 
         self.property_set["block_list"] = block_list

qiskit/transpiler/passes/optimization/commutation_analysis.py

@@ -27,9 +27,13 @@ class CommutationAnalysis(AnalysisPass):
     are grouped into a set of gates that commute.
     """
 
-    def __init__(self):
+    def __init__(self, *, _commutation_checker=None):
         super().__init__()
-        self.comm_checker = scc
+        # allow setting a private commutation checker, this allows better performance if we
+        # do not care about commutations of all gates, but just a subset
+        if _commutation_checker is None:
+            _commutation_checker = scc
+        self.comm_checker = _commutation_checker
 
     def run(self, dag):
         """Run the CommutationAnalysis pass on `dag`.
@@ -72,14 +76,7 @@ class CommutationAnalysis(AnalysisPass):
                         does_commute = (
                             isinstance(current_gate, DAGOpNode)
                             and isinstance(prev_gate, DAGOpNode)
-                            and self.comm_checker.commute(
-                                current_gate.op,
-                                current_gate.qargs,
-                                current_gate.cargs,
-                                prev_gate.op,
-                                prev_gate.qargs,
-                                prev_gate.cargs,
-                            )
+                            and self.comm_checker.commute_nodes(current_gate, prev_gate)
                         )
                         if not does_commute:
                             break