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

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

qiskit/transpiler/passes/optimization/commutative_cancellation.py

@@ -16,16 +16,17 @@ from collections import defaultdict
 import numpy as np
 
 from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.optimization.commutation_analysis import CommutationAnalysis
 from qiskit.dagcircuit import DAGCircuit, DAGInNode, DAGOutNode
+from qiskit.circuit.commutation_library import CommutationChecker, StandardGateCommutations
 from qiskit.circuit.library.standard_gates.u1 import U1Gate
 from qiskit.circuit.library.standard_gates.rx import RXGate
 from qiskit.circuit.library.standard_gates.p import PhaseGate
 from qiskit.circuit.library.standard_gates.rz import RZGate
-from qiskit.circuit import ControlFlowOp
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 
 
 _CUTOFF_PRECISION = 1e-5
@@ -62,7 +63,18 @@ class CommutativeCancellation(TransformationPass):
             self.basis = set(target.operation_names)
 
         self._var_z_map = {"rz": RZGate, "p": PhaseGate, "u1": U1Gate}
-        self.requires.append(CommutationAnalysis())
+
+        self._z_rotations = {"p", "z", "u1", "rz", "t", "s"}
+        self._x_rotations = {"x", "rx"}
+        self._gates = {"cx", "cy", "cz", "h", "y"}  # Now the gates supported are hard-coded
+
+        # build a commutation checker restricted to the gates we cancel -- the others we
+        # do not have to investigate, which allows to save time
+        commutation_checker = CommutationChecker(
+            StandardGateCommutations, gates=self._gates | self._z_rotations | self._x_rotations
+        )
+
+        self.requires.append(CommutationAnalysis(_commutation_checker=commutation_checker))
 
     def run(self, dag):
         """Run the CommutativeCancellation pass on `dag`.
@@ -72,23 +84,17 @@ class CommutativeCancellation(TransformationPass):
 
         Returns:
             DAGCircuit: the optimized DAG.
-
-        Raises:
-            TranspilerError: when the 1-qubit rotation gates are not found
         """
         var_z_gate = None
         z_var_gates = [gate for gate in dag.count_ops().keys() if gate in self._var_z_map]
         if z_var_gates:
-            # priortize z gates in circuit
+            # prioritize z gates in circuit
             var_z_gate = self._var_z_map[next(iter(z_var_gates))]
         else:
             z_var_gates = [gate for gate in self.basis if gate in self._var_z_map]
             if z_var_gates:
                 var_z_gate = self._var_z_map[next(iter(z_var_gates))]
 
-        # Now the gates supported are hard-coded
-        q_gate_list = ["cx", "cy", "cz", "h", "y"]
-
         # Gate sets to be cancelled
         cancellation_sets = defaultdict(lambda: [])
 
@@ -107,9 +113,11 @@ class CommutativeCancellation(TransformationPass):
                     continue
                 for node in com_set:
                     num_qargs = len(node.qargs)
-                    if num_qargs == 1 and node.name in q_gate_list:
+                    if any(isinstance(p, ParameterExpression) for p in node.params):
+                        continue  # no support for cancellation of parameterized gates
+                    if num_qargs == 1 and node.name in self._gates:
                         cancellation_sets[(node.name, wire, com_set_idx)].append(node)
-                    if num_qargs == 1 and node.name in ["p", "z", "u1", "rz", "t", "s"]:
+                    if num_qargs == 1 and node.name in self._z_rotations:
                         cancellation_sets[("z_rotation", wire, com_set_idx)].append(node)
                     if num_qargs == 1 and node.name in ["rx", "x"]:
                         cancellation_sets[("x_rotation", wire, com_set_idx)].append(node)
@@ -130,7 +138,7 @@ class CommutativeCancellation(TransformationPass):
             if cancel_set_key[0] == "z_rotation" and var_z_gate is None:
                 continue
             set_len = len(cancellation_sets[cancel_set_key])
-            if set_len > 1 and cancel_set_key[0] in q_gate_list:
+            if set_len > 1 and cancel_set_key[0] in self._gates:
                 gates_to_cancel = cancellation_sets[cancel_set_key]
                 for c_node in gates_to_cancel[: (set_len // 2) * 2]:
                     dag.remove_op_node(c_node)
@@ -142,31 +150,37 @@ class CommutativeCancellation(TransformationPass):
                 total_phase = 0.0
                 for current_node in run:
                     if (
-                        getattr(current_node.op, "condition", None) is not None
+                        current_node.condition is not None
                         or len(current_node.qargs) != 1
                         or current_node.qargs[0] != run_qarg
                     ):
-                        raise TranspilerError("internal error")
+                        raise RuntimeError("internal error")
 
                     if current_node.name in ["p", "u1", "rz", "rx"]:
-                        current_angle = float(current_node.op.params[0])
+                        current_angle = float(current_node.params[0])
                     elif current_node.name in ["z", "x"]:
                         current_angle = np.pi
                     elif current_node.name == "t":
                         current_angle = np.pi / 4
                     elif current_node.name == "s":
                         current_angle = np.pi / 2
+                    else:
+                        raise RuntimeError(
+                            f"Angle for operation {current_node.name } is not defined"
+                        )
 
                     # Compose gates
                     total_angle = current_angle + total_angle
-                    if current_node.op.definition:
-                        total_phase += current_node.op.definition.global_phase
+                    if current_node.definition:
+                        total_phase += current_node.definition.global_phase
 
                 # Replace the data of the first node in the run
                 if cancel_set_key[0] == "z_rotation":
                     new_op = var_z_gate(total_angle)
                 elif cancel_set_key[0] == "x_rotation":
                     new_op = RXGate(total_angle)
+                else:
+                    raise RuntimeError("impossible case")
 
                 new_op_phase = 0
                 if np.mod(total_angle, (2 * np.pi)) > _CUTOFF_PRECISION:
@@ -198,7 +212,9 @@ class CommutativeCancellation(TransformationPass):
         """
 
         pass_manager = PassManager([CommutationAnalysis(), self])
-        for node in dag.op_nodes(ControlFlowOp):
+        for node in dag.op_nodes():
+            if node.name not in CONTROL_FLOW_OP_NAMES:
+                continue
             mapped_blocks = []
             for block in node.op.blocks:
                 new_circ = pass_manager.run(block)

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -24,10 +24,11 @@ from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
 from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 from qiskit.circuit.library.standard_gates import CXGate
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.circuit.controlflow import ControlFlowOp
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.synthesis import unitary_synthesis
-from qiskit.transpiler.passes.utils import _block_to_matrix
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
+
 from .collect_1q_runs import Collect1qRuns
 from .collect_2q_blocks import Collect2qBlocks
 
@@ -105,14 +106,14 @@ class ConsolidateBlocks(TransformationPass):
                 block_cargs = set()
                 for nd in block:
                     block_qargs |= set(nd.qargs)
-                    if isinstance(nd, DAGOpNode) and getattr(nd.op, "condition", None):
-                        block_cargs |= set(getattr(nd.op, "condition", None)[0])
+                    if isinstance(nd, DAGOpNode) and getattr(nd, "condition", None):
+                        block_cargs |= set(getattr(nd, "condition", None)[0])
                     all_block_gates.add(nd)
                 block_index_map = self._block_qargs_to_indices(dag, block_qargs)
                 for nd in block:
-                    if nd.op.name == basis_gate_name:
+                    if nd.name == basis_gate_name:
                         basis_count += 1
-                    if self._check_not_in_basis(dag, nd.op.name, nd.qargs):
+                    if self._check_not_in_basis(dag, nd.name, nd.qargs):
                         outside_basis = True
                 if len(block_qargs) > 2:
                     q = QuantumRegister(len(block_qargs))
@@ -124,7 +125,7 @@ class ConsolidateBlocks(TransformationPass):
                         qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
                     unitary = UnitaryGate(Operator(qc), check_input=False)
                 else:
-                    matrix = _block_to_matrix(block, block_index_map)
+                    matrix = blocks_to_matrix(block, block_index_map)
                     unitary = UnitaryGate(matrix, check_input=False)
 
                 max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.
@@ -192,7 +193,9 @@ class ConsolidateBlocks(TransformationPass):
             pass_manager.append(Collect2qBlocks())
 
         pass_manager.append(self)
-        for node in dag.op_nodes(ControlFlowOp):
+        for node in dag.op_nodes():
+            if node.name not in CONTROL_FLOW_OP_NAMES:
+                continue
             node.op = node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks)
         return dag
 

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -53,8 +53,8 @@ class InverseCancellation(TransformationPass):
                     )
             else:
                 raise TranspilerError(
-                    "InverseCancellation pass does not take input type {}. Input must be"
-                    " a Gate.".format(type(gates))
+                    f"InverseCancellation pass does not take input type {type(gates)}. Input must be"
+                    " a Gate."
                 )
 
         self.self_inverse_gates = []
@@ -112,15 +112,15 @@ class InverseCancellation(TransformationPass):
                 partitions = []
                 chunk = []
                 max_index = len(gate_cancel_run) - 1
-                for i in range(len(gate_cancel_run)):
-                    if gate_cancel_run[i].op == gate:
-                        chunk.append(gate_cancel_run[i])
+                for i, cancel_gate in enumerate(gate_cancel_run):
+                    if cancel_gate.op == gate:
+                        chunk.append(cancel_gate)
                     else:
                         if chunk:
                             partitions.append(chunk)
                             chunk = []
                         continue
-                    if i == max_index or gate_cancel_run[i].qargs != gate_cancel_run[i + 1].qargs:
+                    if i == max_index or cancel_gate.qargs != gate_cancel_run[i + 1].qargs:
                         partitions.append(chunk)
                         chunk = []
                 # Remove an even number of gates from each chunk