qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -0,0 +1,95 @@
+# 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
+from qiskit.transpiler.passes.utils import control_flow
+
+from qiskit._accelerate.inverse_cancellation import inverse_cancellation
+
+
+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(
+                    f"InverseCancellation pass does not take input type {type(gates)}. Input must be"
+                    " a Gate."
+                )
+
+        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__()
+
+    @control_flow.trivial_recurse
+    def run(self, dag: DAGCircuit):
+        """Run the InverseCancellation pass on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        inverse_cancellation(
+            dag,
+            self.inverse_gate_pairs,
+            self.self_inverse_gates,
+            self.inverse_gate_pairs_names,
+            self.self_inverse_gate_names,
+        )
+        return dag

qiskit/transpiler/passes/optimization/light_cone.py

@@ -0,0 +1,135 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""Cancel the redundant (self-adjoint) gates through commutation relations."""
+from __future__ import annotations
+import warnings
+from qiskit.circuit import Gate, Qubit
+from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
+from qiskit.circuit.library import PauliGate, ZGate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils.remove_final_measurements import calc_final_ops
+
+translation_table = str.maketrans({"+": "X", "-": "X", "l": "Y", "r": "Y", "0": "Z", "1": "Z"})
+
+
+class LightCone(TransformationPass):
+    """Remove the gates that do not affect the outcome of a measurement on a circuit.
+
+    Pass for computing the light-cone of an observable or measurement. The Pass can handle
+    either an observable one would like to measure or a measurement on a set of qubits.
+    """
+
+    def __init__(self, bit_terms: str | None = None, indices: list[int] | None = None) -> None:
+        """
+        Args:
+            bit_terms: If ``None`` the light-cone will be computed for the set of measurements
+                in the circuit. If a string is specified, the light-cone will correspond to the
+                reduced circuit with the same expectation value for the observable.
+            indices: list of non-trivial indices corresponding to the observable in ``bit_terms``.
+        """
+        super().__init__()
+        valid_characters = {"X", "Y", "Z", "+", "-", "l", "r", "0", "1"}
+        self.bit_terms = None
+        if bit_terms is not None:
+            if not indices:
+                raise ValueError("`indices` must be non-empty when providing `bit_terms`.")
+            if not set(bit_terms).issubset(valid_characters):
+                raise ValueError(
+                    f"`bit_terms` should contain only characters in {valid_characters}."
+                )
+            if len(bit_terms) != len(indices):
+                raise ValueError("`bit_terms` must be the same length as `indices`.")
+            self.bit_terms = bit_terms.translate(translation_table)
+        self.indices = indices
+
+    @staticmethod
+    def _find_measurement_qubits(dag: DAGCircuit) -> set[Qubit]:
+        final_nodes = calc_final_ops(dag, {"measure"})
+        qubits_measured = set()
+        for node in final_nodes:
+            qubits_measured |= set(node.qargs)
+        return qubits_measured
+
+    def _get_initial_lightcone(
+        self, dag: DAGCircuit
+    ) -> tuple[set[Qubit], list[tuple[Gate, list[Qubit]]]]:
+        """Returns the initial light-cone.
+        If observable is `None`, the light-cone is the set of measured qubits.
+        If a `bit_terms` is provided, the qubits corresponding to the
+        non-trivial Paulis define the light-cone.
+        """
+        lightcone_qubits = self._find_measurement_qubits(dag)
+        if self.bit_terms is None:
+            lightcone_operations = [(ZGate(), [qubit_index]) for qubit_index in lightcone_qubits]
+        else:
+            # Having both measurements and an observable is not allowed
+            if len(dag.qubits) < max(self.indices) + 1:
+                raise ValueError("`indices` contains values outside the qubit range.")
+            if lightcone_qubits:
+                raise ValueError(
+                    "The circuit contains measurements and an observable has been given: "
+                    "remove the observable or the measurements."
+                )
+            lightcone_qubits = [dag.qubits[i] for i in self.indices]
+            # `lightcone_operations` is a list of tuples, each containing (operation, list_of_qubits)
+            lightcone_operations = [(PauliGate(self.bit_terms), lightcone_qubits)]
+
+        return set(lightcone_qubits), lightcone_operations
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the LightCone pass on `dag`.
+
+        Args:
+            dag: The DAG to reduce.
+
+        Returns:
+            The DAG reduced to the light-cone of the observable.
+        """
+
+        # Get the initial light-cone and operations
+        lightcone_qubits, lightcone_operations = self._get_initial_lightcone(dag)
+
+        #  Initialize a new, empty DAG
+        new_dag = dag.copy_empty_like()
+
+        # Iterate over the nodes in reverse topological order
+        for node in reversed(list(dag.topological_op_nodes())):
+            # Check if the node belongs to the light-cone
+            if lightcone_qubits.intersection(node.qargs):
+                # Check commutation with all previous operations
+                commutes_bool = True
+                for op in lightcone_operations:
+                    max_num_qubits = max(len(op[1]), len(node.qargs))
+                    if max_num_qubits > 10:
+                        warnings.warn(
+                            "LightCone pass is checking commutation of"
+                            f"operators of size {max_num_qubits}."
+                            "This operation can be slow.",
+                            category=RuntimeWarning,
+                        )
+                    commute_bool = scc.commute(
+                        op[0], op[1], [], node.op, node.qargs, [], max_num_qubits=max_num_qubits
+                    )
+                    if not commute_bool:
+                        # If the current node does not commute, update the light-cone
+                        lightcone_qubits.update(node.qargs)
+                        lightcone_operations.append((node.op, node.qargs))
+                        commutes_bool = False
+                        break
+
+                # If the node is in the light-cone and commutes with previous `ops`,
+                # add it to the new DAG at the front
+                if not commutes_bool:
+                    new_dag.apply_operation_front(node.op, node.qargs, node.cargs)
+        return new_dag

qiskit/transpiler/passes/optimization/optimize_1q_commutation.py

@@ -0,0 +1,267 @@
+# 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(
+                (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