qiskit 1.3.0__cp39-abi3-win32.whl

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

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -0,0 +1,254 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Optimize chains of single-qubit gates using Euler 1q decomposer"""
+
+import logging
+import math
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.synthesis.one_qubit import one_qubit_decompose
+from qiskit._accelerate import euler_one_qubit_decomposer
+from qiskit.circuit.library.standard_gates import (
+    UGate,
+    PhaseGate,
+    U3Gate,
+    U2Gate,
+    U1Gate,
+    RXGate,
+    RYGate,
+    RZGate,
+    RGate,
+    SXGate,
+    XGate,
+)
+from qiskit.circuit import Qubit
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+
+
+logger = logging.getLogger(__name__)
+
+# When expanding the list of supported gates this needs to updated in
+# lockstep with the VALID_BASES constant in src/euler_one_qubit_decomposer.rs
+# and the global variables in one_qubit_decompose.py
+NAME_MAP = {
+    "u": UGate,
+    "u1": U1Gate,
+    "u2": U2Gate,
+    "u3": U3Gate,
+    "p": PhaseGate,
+    "rx": RXGate,
+    "ry": RYGate,
+    "rz": RZGate,
+    "r": RGate,
+    "sx": SXGate,
+    "x": XGate,
+}
+
+
+class Optimize1qGatesDecomposition(TransformationPass):
+    """Optimize chains of single-qubit gates by combining them into a single gate.
+
+    The decision to replace the original chain with a new re-synthesis depends on:
+     - whether the original chain was out of basis: replace
+     - whether the original chain was in basis but re-synthesis is lower error: replace
+     - whether the original chain contains a pulse gate: do not replace
+     - whether the original chain amounts to identity: replace with null
+
+     Error is computed as a multiplication of the errors of individual gates on that qubit.
+    """
+
+    def __init__(self, basis=None, target=None):
+        """Optimize1qGatesDecomposition initializer.
+
+        Args:
+            basis (list[str]): Basis gates to consider, e.g. `['u3', 'cx']`. For the effects
+                of this pass, the basis is the set intersection between the `basis` parameter
+                and the Euler basis. Ignored if ``target`` is also specified.
+            target (Optional[Target]): The :class:`~.Target` object corresponding to the compilation
+                target. When specified, any argument specified for ``basis_gates`` is ignored.
+        """
+        super().__init__()
+
+        if basis:
+            self._basis_gates = set(basis)
+        else:
+            self._basis_gates = None
+        self._target = target
+        self._global_decomposers = None
+        self._local_decomposers_cache = {}
+
+        if basis:
+            self._global_decomposers = _possible_decomposers(set(basis))
+        elif target is None:
+            self._global_decomposers = _possible_decomposers(None)
+            self._basis_gates = None
+
+        self.error_map = self._build_error_map()
+
+    def _build_error_map(self):
+        # include path for when target exists but target.num_qubits is None (BasicSimulator)
+        if self._target is not None and self._target.num_qubits is not None:
+            error_map = euler_one_qubit_decomposer.OneQubitGateErrorMap(self._target.num_qubits)
+            for qubit in range(self._target.num_qubits):
+                gate_error = {}
+                for gate, gate_props in self._target.items():
+                    if gate_props is not None:
+                        props = gate_props.get((qubit,), None)
+                        if props is not None and props.error is not None:
+                            gate_error[gate] = props.error
+                error_map.add_qubit(gate_error)
+            return error_map
+        else:
+            return None
+
+    def _get_decomposer(self, qubit=None):
+        # include path for when target exists but target.num_qubits is None (BasicSimulator)
+        if self._target is not None and self._target.num_qubits is not None:
+            if qubit is not None:
+                qubits_tuple = (qubit,)
+            else:
+                qubits_tuple = None
+            if qubits_tuple in self._local_decomposers_cache:
+                decomposers = self._local_decomposers_cache[qubits_tuple]
+            else:
+                available_1q_basis = set(self._target.operation_names_for_qargs(qubits_tuple))
+                decomposers = _possible_decomposers(available_1q_basis)
+        else:
+            decomposers = self._global_decomposers
+        return decomposers
+
+    def _resynthesize_run(self, matrix, qubit=None):
+        """
+        Re-synthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
+
+        Returns the newly synthesized circuit in the indicated basis, or None
+        if no synthesis routine applied.
+
+        When multiple synthesis options are available, it prefers the one with the lowest
+        error when the circuit is applied to `qubit`.
+        """
+        decomposers = self._get_decomposer(qubit)
+
+        best_synth_circuit = euler_one_qubit_decomposer.unitary_to_gate_sequence(
+            matrix,
+            decomposers,
+            qubit,
+            self.error_map,
+        )
+        return best_synth_circuit
+
+    def _gate_sequence_to_dag(self, best_synth_circuit):
+        qubits = (Qubit(),)
+        out_dag = DAGCircuit()
+        out_dag.add_qubits(qubits)
+        out_dag.global_phase = best_synth_circuit.global_phase
+
+        for gate_name, angles in best_synth_circuit:
+            op = CircuitInstruction.from_standard(gate_name, qubits, angles)
+            out_dag.apply_operation_back(op.operation, qubits, check=False)
+        return out_dag
+
+    def _substitution_checks(
+        self, dag, old_run, new_circ, basis, qubit, old_error=None, new_error=None
+    ):
+        """
+        Returns `True` when it is recommended to replace `old_run` with `new_circ` over `basis`.
+        """
+        if new_circ is None:
+            return False
+
+        # do we even have calibrations?
+        has_cals_p = dag._calibrations_prop is not None and len(dag._calibrations_prop) > 0
+        # does this run have uncalibrated gates?
+        uncalibrated_p = not has_cals_p or any(not dag._has_calibration_for(g) for g in old_run)
+        # does this run have gates not in the image of ._decomposers _and_ uncalibrated?
+        if basis is not None:
+            uncalibrated_and_not_basis_p = any(
+                g.name not in basis and (not has_cals_p or not dag._has_calibration_for(g))
+                for g in old_run
+            )
+        else:
+            # If no basis is specified then we're always in the basis
+            uncalibrated_and_not_basis_p = False
+
+        # if we're outside of the basis set, we're obligated to logically decompose.
+        # if we're outside of the set of gates for which we have physical definitions,
+        #    then we _try_ to decompose, using the results if we see improvement.
+        if not uncalibrated_and_not_basis_p:
+            if new_error is None:
+                new_error = self._error(new_circ, qubit)
+            if old_error is None:
+                old_error = self._error(old_run, qubit)
+        else:
+            new_error = 0.0
+            old_error = 0.0
+
+        return (
+            uncalibrated_and_not_basis_p
+            or (uncalibrated_p and new_error < old_error)
+            or (math.isclose(new_error[0], 0) and not math.isclose(old_error[0], 0))
+        )
+
+    @control_flow.trivial_recurse
+    def run(self, dag):
+        """Run the Optimize1qGatesDecomposition pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
+            dag,
+            target=self._target,
+            global_decomposers=self._global_decomposers,
+            basis_gates=self._basis_gates,
+        )
+        return dag
+
+    def _error(self, circuit, qubit):
+        """
+        Calculate a rough error for a `circuit` that runs on a specific
+        `qubit` of `target` (`circuit` is a list of DAGOPNodes).
+
+        Use basis errors from target if available, otherwise use length
+        of circuit as a weak proxy for error.
+        """
+        return euler_one_qubit_decomposer.compute_error_list(circuit, qubit, self.error_map)
+
+
+def _possible_decomposers(basis_set):
+    decomposers = []
+    if basis_set is None:
+        decomposers = list(one_qubit_decompose.ONE_QUBIT_EULER_BASIS_GATES)
+    else:
+        euler_basis_gates = one_qubit_decompose.ONE_QUBIT_EULER_BASIS_GATES
+        for euler_basis_name, gates in euler_basis_gates.items():
+            if set(gates).issubset(basis_set):
+                decomposers.append(euler_basis_name)
+        # If both U3 and U321 are in decomposer list only run U321 because
+        # in worst case it will produce the same U3 output, but in the general
+        # case it will use U2 and U1 which will be more efficient.
+        if "U3" in decomposers and "U321" in decomposers:
+            decomposers.remove("U3")
+        # If both ZSX and ZSXX are in decomposer list only run ZSXX because
+        # in the worst case it will produce the same output, but in the general
+        # case it will simplify X rotations to use X gate instead of multiple
+        # SX gates and be more efficient. Running multiple decomposers in this
+        # case will just waste time.
+        if "ZSX" in decomposers and "ZSXX" in decomposers:
+            decomposers.remove("ZSX")
+    return decomposers