qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -0,0 +1,177 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+A generic InverseCancellation pass for any set of gate-inverse pairs.
+"""
+from typing import List, Tuple, Union
+
+from qiskit.circuit import Gate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+
+class InverseCancellation(TransformationPass):
+    """Cancel specific Gates which are inverses of each other when they occur back-to-
+    back."""
+
+    def __init__(self, gates_to_cancel: List[Union[Gate, Tuple[Gate, Gate]]]):
+        """Initialize InverseCancellation pass.
+
+        Args:
+            gates_to_cancel: List describing the gates to cancel. Each element of the
+                list is either a single gate or a pair of gates. If a single gate, then
+                it should be self-inverse. If a pair of gates, then the gates in the
+                pair should be inverses of each other.
+
+        Raises:
+            TranspilerError: Input is not a self-inverse gate or a pair of inverse gates.
+        """
+
+        for gates in gates_to_cancel:
+            if isinstance(gates, Gate):
+                if gates != gates.inverse():
+                    raise TranspilerError(f"Gate {gates.name} is not self-inverse")
+            elif isinstance(gates, tuple):
+                if len(gates) != 2:
+                    raise TranspilerError(
+                        f"Too many or too few inputs: {gates}. Only two are allowed."
+                    )
+                if gates[0] != gates[1].inverse():
+                    raise TranspilerError(
+                        f"Gate {gates[0].name} and {gates[1].name} are not inverse."
+                    )
+            else:
+                raise TranspilerError(
+                    "InverseCancellation pass does not take input type {}. Input must be"
+                    " a Gate.".format(type(gates))
+                )
+
+        self.self_inverse_gates = []
+        self.inverse_gate_pairs = []
+        self.self_inverse_gate_names = set()
+        self.inverse_gate_pairs_names = set()
+
+        for gates in gates_to_cancel:
+            if isinstance(gates, Gate):
+                self.self_inverse_gates.append(gates)
+                self.self_inverse_gate_names.add(gates.name)
+            else:
+                self.inverse_gate_pairs.append(gates)
+                self.inverse_gate_pairs_names.update(x.name for x in gates)
+
+        super().__init__()
+
+    def run(self, dag: DAGCircuit):
+        """Run the InverseCancellation pass on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        if self.self_inverse_gates:
+            dag = self._run_on_self_inverse(dag)
+        if self.inverse_gate_pairs:
+            dag = self._run_on_inverse_pairs(dag)
+        return dag
+
+    def _run_on_self_inverse(self, dag: DAGCircuit):
+        """
+        Run self-inverse gates on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+            self_inverse_gates: list of gates who cancel themeselves in pairs
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        op_counts = dag.count_ops()
+        if not self.self_inverse_gate_names.intersection(op_counts):
+            return dag
+        # Sets of gate runs by name, for instance: [{(H 0, H 0), (H 1, H 1)}, {(X 0, X 0}]
+        for gate in self.self_inverse_gates:
+            gate_name = gate.name
+            gate_count = op_counts.get(gate_name, 0)
+            if gate_count <= 1:
+                continue
+            gate_runs = dag.collect_runs([gate_name])
+            for gate_cancel_run in gate_runs:
+                partitions = []
+                chunk = []
+                for i in range(len(gate_cancel_run) - 1):
+                    if gate_cancel_run[i].op == gate:
+                        chunk.append(gate_cancel_run[i])
+                    else:
+                        if chunk:
+                            partitions.append(chunk)
+                            chunk = []
+                        continue
+                    if gate_cancel_run[i].qargs != gate_cancel_run[i + 1].qargs:
+                        partitions.append(chunk)
+                        chunk = []
+                chunk.append(gate_cancel_run[-1])
+                partitions.append(chunk)
+                # Remove an even number of gates from each chunk
+                for chunk in partitions:
+                    if len(chunk) % 2 == 0:
+                        dag.remove_op_node(chunk[0])
+                    for node in chunk[1:]:
+                        dag.remove_op_node(node)
+        return dag
+
+    def _run_on_inverse_pairs(self, dag: DAGCircuit):
+        """
+        Run inverse gate pairs on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+            inverse_gate_pairs: list of gates with inverse angles that cancel each other.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        op_counts = dag.count_ops()
+        if not self.inverse_gate_pairs_names.intersection(op_counts):
+            return dag
+
+        for pair in self.inverse_gate_pairs:
+            gate_0_name = pair[0].name
+            gate_1_name = pair[1].name
+            if gate_0_name not in op_counts or gate_1_name not in op_counts:
+                continue
+            gate_cancel_runs = dag.collect_runs([gate_0_name, gate_1_name])
+            for dag_nodes in gate_cancel_runs:
+                i = 0
+                while i < len(dag_nodes) - 1:
+                    if (
+                        dag_nodes[i].qargs == dag_nodes[i + 1].qargs
+                        and dag_nodes[i].op == pair[0]
+                        and dag_nodes[i + 1].op == pair[1]
+                    ):
+                        dag.remove_op_node(dag_nodes[i])
+                        dag.remove_op_node(dag_nodes[i + 1])
+                        i = i + 2
+                    elif (
+                        dag_nodes[i].qargs == dag_nodes[i + 1].qargs
+                        and dag_nodes[i].op == pair[1]
+                        and dag_nodes[i + 1].op == pair[0]
+                    ):
+                        dag.remove_op_node(dag_nodes[i])
+                        dag.remove_op_node(dag_nodes[i + 1])
+                        i = i + 2
+                    else:
+                        i = i + 1
+        return dag

qiskit/transpiler/passes/optimization/normalize_rx_angle.py

@@ -0,0 +1,149 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Performs three optimizations to reduce the number of pulse calibrations for
+the single-pulse RX gates:
+Wrap RX Gate rotation angles into [0, pi] by sandwiching them with RZ gates.
+Convert RX(pi/2) to SX, and RX(pi) to X if the calibrations exist in the target.
+Quantize the RX rotation angles by assigning the same value for the angles
+that differ within a resolution provided by the user.
+"""
+
+import numpy as np
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.circuit.library.standard_gates import RXGate, RZGate, SXGate, XGate
+
+
+class NormalizeRXAngle(TransformationPass):
+    """Normalize theta parameter of RXGate instruction.
+
+    The parameter normalization is performed with following steps.
+
+    1) Wrap RX Gate theta into [0, pi]. When theta is negative value, the gate is
+    decomposed into the following sequence.
+
+    .. code-block::
+
+          ┌───────┐┌─────────┐┌────────┐
+       q: ┤ Rz(π) ├┤ Rx(|θ|) ├┤ Rz(-π) ├
+          └───────┘└─────────┘└────────┘
+
+    2) If the operation is supported by target, convert RX(pi/2) to SX, and RX(pi) to X.
+
+    3) Quantize theta value according to the user-specified resolution.
+
+    This will help reduce the size of calibration data sent over the wire,
+    and allow us to exploit the more accurate, hardware-calibrated pulses.
+    Note that pulse calibration might be attached per each rotation angle.
+    """
+
+    def __init__(self, target=None, resolution_in_radian=0):
+        """NormalizeRXAngle initializer.
+
+        Args:
+            target (Target): The :class:`~.Target` representing the target backend.
+                If the target contains SX and X calibrations, this pass will replace the
+                corresponding RX gates with SX and X gates.
+            resolution_in_radian (float): Resolution for RX rotation angle quantization.
+                If set to zero, this pass won't modify the rotation angles in the given DAG.
+                (=Provides arbitrary-angle RX)
+        """
+        super().__init__()
+        self.target = target
+        self.resolution_in_radian = resolution_in_radian
+        self.already_generated = {}
+
+    def quantize_angles(self, qubit, original_angle):
+        """Quantize the RX rotation angles by assigning the same value for the angles
+        that differ within a resolution provided by the user.
+
+        Args:
+            qubit (qiskit.circuit.Qubit): This will be the dict key to access the list of
+                quantized rotation angles.
+            original_angle (float): Original rotation angle, before quantization.
+
+        Returns:
+            float: Quantized angle.
+        """
+
+        if (angles := self.already_generated.get(qubit)) is None:
+            self.already_generated[qubit] = np.array([original_angle])
+            return original_angle
+        similar_angles = angles[
+            np.isclose(angles, original_angle, atol=self.resolution_in_radian / 2)
+        ]
+        if similar_angles.size == 0:
+            self.already_generated[qubit] = np.append(angles, original_angle)
+            return original_angle
+        return float(similar_angles[0])
+
+    def run(self, dag):
+        """Run the NormalizeRXAngle pass on ``dag``.
+
+        Args:
+            dag (DAGCircuit): The DAG to be optimized.
+
+        Returns:
+            DAGCircuit: A DAG with RX gate calibration.
+        """
+
+        # Iterate over all op_nodes and replace RX if eligible for modification.
+        for op_node in dag.op_nodes():
+            if not isinstance(op_node.op, RXGate):
+                continue
+
+            raw_theta = op_node.op.params[0]
+            wrapped_theta = np.arctan2(np.sin(raw_theta), np.cos(raw_theta))  # [-pi, pi]
+
+            if self.resolution_in_radian:
+                wrapped_theta = self.quantize_angles(op_node.qargs[0], wrapped_theta)
+
+            half_pi_rotation = np.isclose(
+                abs(wrapped_theta), np.pi / 2, atol=self.resolution_in_radian / 2
+            )
+            pi_rotation = np.isclose(abs(wrapped_theta), np.pi, atol=self.resolution_in_radian / 2)
+
+            should_modify_node = (
+                (wrapped_theta != raw_theta)
+                or (wrapped_theta < 0)
+                or half_pi_rotation
+                or pi_rotation
+            )
+
+            if should_modify_node:
+                mini_dag = DAGCircuit()
+                mini_dag.add_qubits(op_node.qargs)
+
+                # new X-rotation gate with angle in [0, pi]
+                if half_pi_rotation:
+                    physical_qubit_idx = dag.find_bit(op_node.qargs[0]).index
+                    if self.target.instruction_supported("sx", (physical_qubit_idx,)):
+                        mini_dag.apply_operation_back(SXGate(), qargs=op_node.qargs)
+                elif pi_rotation:
+                    physical_qubit_idx = dag.find_bit(op_node.qargs[0]).index
+                    if self.target.instruction_supported("x", (physical_qubit_idx,)):
+                        mini_dag.apply_operation_back(XGate(), qargs=op_node.qargs)
+                else:
+                    mini_dag.apply_operation_back(
+                        RXGate(np.abs(wrapped_theta)), qargs=op_node.qargs
+                    )
+
+                # sandwich with RZ if the intended rotation angle was negative
+                if wrapped_theta < 0:
+                    mini_dag.apply_operation_front(RZGate(np.pi), qargs=op_node.qargs)
+                    mini_dag.apply_operation_back(RZGate(-np.pi), qargs=op_node.qargs)
+
+                dag.substitute_node_with_dag(node=op_node, input_dag=mini_dag, wires=op_node.qargs)
+
+        return dag

qiskit/transpiler/passes/optimization/optimize_1q_commutation.py

@@ -0,0 +1,268 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Reduce 1Q gate complexity by commuting through 2Q gates and resynthesizing."""
+
+from copy import copy
+import logging
+from collections import deque
+
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit.library.standard_gates import CXGate, RZXGate
+from qiskit.dagcircuit import DAGOpNode
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.optimization.optimize_1q_decomposition import (
+    Optimize1qGatesDecomposition,
+)
+
+logger = logging.getLogger(__name__)
+
+
+commutation_table = {
+    RZXGate: (["rz", "p"], ["x", "sx", "rx"]),
+    CXGate: (["rz", "p"], ["x", "sx", "rx"]),
+}
+"""
+Simple commutation rules: G belongs to commutation_table[barrier_type][qubit_preindex] when G
+commutes with the indicated barrier on that qubit wire.
+
+NOTE: Does not cover identities like
+          (X (x) I) .   CX = CX .   (X (x) X) ,  (duplication)
+          (U (x) I) . SWAP = SWAP . (I (x) U) .  (permutation)
+
+NOTE: These rules are _symmetric_, so that they may be applied in reverse.
+"""
+
+
+class Optimize1qGatesSimpleCommutation(TransformationPass):
+    """
+    Optimizes 1Q gate strings interrupted by 2Q gates by commuting the components and
+    resynthesizing the results.  The commutation rules are stored in ``commutation_table``.
+
+    NOTE: In addition to those mentioned in ``commutation_table``, this pass has some limitations:
+          + Does not handle multiple commutations in a row without intermediate progress.
+          + Can only commute into positions where there are pre-existing runs.
+          + Does not exhaustively test all the different ways commuting gates can be assigned to
+            either side of a barrier to try to find low-depth configurations.  (This is particularly
+            evident if all the gates in a run commute with both the predecessor and the successor
+            barriers.)
+    """
+
+    # NOTE: A run from dag.collect_1q_runs is always nonempty, so we sometimes use an empty list
+    #       to signify the absence of a run.
+
+    def __init__(self, basis=None, run_to_completion=False, target=None):
+        """
+        Args:
+            basis (List[str]): See also `Optimize1qGatesDecomposition`.
+            run_to_completion (bool): If `True`, this pass retries until it is unable to do any more
+                work.  If `False`, it finds and performs one optimization, and for full optimization
+                the user is obligated to re-call the pass until the output stabilizes.
+            target (Target): The :class:`~.Target` representing the target backend, if both
+                ``basis`` and this are specified then this argument will take
+                precedence and ``basis`` will be ignored.
+        """
+        super().__init__()
+
+        self._optimize1q = Optimize1qGatesDecomposition(basis=basis, target=target)
+        self._run_to_completion = run_to_completion
+
+    @staticmethod
+    def _find_adjoining_run(dag, runs, run, front=True):
+        """
+        Finds the run which abuts `run` from the front (or the rear if `front == False`), separated
+        by a blocking node.
+
+        Returns a pair of the abutting multiqubit gate and the run which it separates from this
+        one. The next run can be the empty list `[]` if it is absent.
+        """
+        edge_node = run[0] if front else run[-1]
+        blocker = next(dag.predecessors(edge_node) if front else dag.successors(edge_node))
+        possibilities = dag.predecessors(blocker) if front else dag.successors(blocker)
+
+        adjoining_run = []
+        for possibility in possibilities:
+            if isinstance(possibility, DAGOpNode) and possibility.qargs == edge_node.qargs:
+                adjoining_run = []
+                for single_run in runs:
+                    if (
+                        len(single_run) != 0 and single_run[0].qargs == possibility.qargs
+                    ):  # allows us to only check the run on a particular qubit
+                        if possibility in single_run:
+                            adjoining_run = single_run
+                            break
+                break
+        return (blocker, adjoining_run)
+
+    @staticmethod
+    def _commute_through(blocker, run, front=True):
+        """
+        Pulls `DAGOpNode`s from the front of `run` (or the back, if `front == False`) until it
+        encounters a gate which does not commute with `blocker`.
+
+        Returns a pair of lists whose concatenation is `run`.
+        """
+
+        if run == []:
+            return [], []
+        # use deque to have modification
+        # operations which are constant
+        # time
+        run_clone = deque(run)
+
+        commuted = deque([])
+        preindex, commutation_rule = None, None
+        if isinstance(blocker, DAGOpNode):
+            preindex = None
+            for i, q in enumerate(blocker.qargs):
+                if q == run[0].qargs[0]:
+                    preindex = i
+
+            commutation_rule = None
+            if (
+                preindex is not None
+                and isinstance(blocker, DAGOpNode)
+                and blocker.op.base_class in commutation_table
+            ):
+                commutation_rule = commutation_table[blocker.op.base_class][preindex]
+
+        if commutation_rule is not None:
+            while run_clone:
+                next_gate = run_clone[0] if front else run_clone[-1]
+                if next_gate.name not in commutation_rule:
+                    break
+                if front:
+                    run_clone.popleft()
+                    commuted.append(next_gate)
+                else:
+                    run_clone.pop()
+                    commuted.appendleft(next_gate)
+        if front:
+            return list(commuted), list(run_clone)
+        else:
+            return list(run_clone), list(commuted)
+
+    def _resynthesize(self, run, qubit):
+        """
+        Synthesizes an efficient circuit from a sequence `run` of `DAGOpNode`s.
+
+        NOTE: Returns None when resynthesis is not possible.
+        """
+        if len(run) == 0:
+            dag = DAGCircuit()
+            dag.add_qreg(QuantumRegister(1))
+            return dag
+        operator = run[0].op.to_matrix()
+        for gate in run[1:]:
+            operator = gate.op.to_matrix().dot(operator)
+        return self._optimize1q._gate_sequence_to_dag(
+            self._optimize1q._resynthesize_run(operator, qubit)
+        )
+
+    @staticmethod
+    def _replace_subdag(dag, old_run, new_dag):
+        """
+        Replaces a nonempty sequence `old_run` of `DAGNode`s, assumed to be a complete chain in
+        `dag`, with the circuit `new_circ`.
+        """
+
+        node_map = dag.substitute_node_with_dag(old_run[0], new_dag)
+
+        for node in old_run[1:]:
+            dag.remove_op_node(node)
+
+        spliced_run = [node_map[node._node_id] for node in new_dag.topological_op_nodes()]
+        mov_list(old_run, spliced_run)
+
+    def _step(self, dag):
+        """
+        Performs one full pass of optimization work.
+
+        Returns True if `dag` changed, False if no work on `dag` was possible.
+        """
+
+        runs = dag.collect_1q_runs()
+        did_work = False
+
+        for run in runs:
+            # identify the preceding blocking gates
+            run_clone = copy(run)
+            if run == []:
+                continue
+
+            # try to modify preceding_run
+            preceding_blocker, preceding_run = self._find_adjoining_run(dag, runs, run)
+            commuted_preceding = []
+            if preceding_run != []:
+                commuted_preceding, run_clone = self._commute_through(preceding_blocker, run_clone)
+
+            # try to modify succeeding run
+            succeeding_blocker, succeeding_run = self._find_adjoining_run(
+                dag, runs, run, front=False
+            )
+            commuted_succeeding = []
+            if succeeding_run != []:
+                run_clone, commuted_succeeding = self._commute_through(
+                    succeeding_blocker, run_clone, front=False
+                )
+
+            # re-synthesize
+            qubit = dag.find_bit(run[0].qargs[0]).index
+            new_preceding_run = self._resynthesize(preceding_run + commuted_preceding, qubit)
+            new_succeeding_run = self._resynthesize(commuted_succeeding + succeeding_run, qubit)
+            new_run = self._resynthesize(run_clone, qubit)
+
+            # perform the replacement if it was indeed a good idea
+            if self._optimize1q._substitution_checks(
+                dag,
+                (preceding_run or []) + run + (succeeding_run or []),
+                new_preceding_run.op_nodes() + new_run.op_nodes() + new_succeeding_run.op_nodes(),
+                self._optimize1q._basis_gates,
+                dag.find_bit(run[0].qargs[0]).index,
+            ):
+                if preceding_run and new_preceding_run is not None:
+                    self._replace_subdag(dag, preceding_run, new_preceding_run)
+                if succeeding_run and new_succeeding_run is not None:
+                    self._replace_subdag(dag, succeeding_run, new_succeeding_run)
+                if new_run is not None:
+                    self._replace_subdag(dag, run, new_run)
+                did_work = True
+
+        return did_work
+
+    def run(self, dag):
+        """
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+
+        # python doesn't support tail calls
+        while True:
+            did_work = self._step(dag)
+            if not self._run_to_completion or not did_work:
+                break
+
+        return dag
+
+
+def mov_list(destination, source):
+    """
+    Replace `destination` in-place with `source`.
+    """
+
+    while destination:
+        del destination[0]
+    destination += source