qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -0,0 +1,263 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.quantum_info.synthesis 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.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 qiskit/quantum_info/synthesis/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__()
+
+        self._basis_gates = basis
+        self._target = target
+        self._global_decomposers = []
+        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):
+        if self._target 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 _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`.
+        """
+        if self._target:
+            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)
+                self._local_decomposers_cache[qubits_tuple] = decomposers
+        else:
+            decomposers = self._global_decomposers
+        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:
+            out_dag.apply_operation_back(NAME_MAP[gate_name](*angles), qubits, check=False)
+        return out_dag
+
+    def _substitution_checks(self, dag, old_run, new_circ, basis, qubit):
+        """
+        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 is not None and len(dag.calibrations) > 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.
+        new_error = 0.0
+        old_error = 0.0
+        if not uncalibrated_and_not_basis_p:
+            new_error = self._error(new_circ, qubit)
+            old_error = self._error(old_run, qubit)
+
+        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.
+        """
+        runs = dag.collect_1q_runs()
+        for run in runs:
+            qubit = dag.find_bit(run[0].qargs[0]).index
+            operator = run[0].op.to_matrix()
+            for node in run[1:]:
+                operator = node.op.to_matrix().dot(operator)
+            best_circuit_sequence = self._resynthesize_run(operator, qubit)
+
+            if self._target is None:
+                basis = self._basis_gates
+            else:
+                basis = self._target.operation_names_for_qargs((qubit,))
+
+            if best_circuit_sequence is not None and self._substitution_checks(
+                dag, run, best_circuit_sequence, basis, qubit
+            ):
+                new_dag = self._gate_sequence_to_dag(best_circuit_sequence)
+                dag.substitute_node_with_dag(run[0], new_dag)
+                # Delete the other nodes in the run
+                for current_node in run[1:]:
+                    dag.remove_op_node(current_node)
+
+        return dag
+
+    def _error(self, circuit, qubit):
+        """
+        Calculate a rough error for a `circuit` that runs on a specific
+        `qubit` of `target` (`circuit` can either be an OneQubitGateSequence
+        from Rust or a list of DAGOPNodes).
+
+        Use basis errors from target if available, otherwise use length
+        of circuit as a weak proxy for error.
+        """
+        if isinstance(circuit, euler_one_qubit_decomposer.OneQubitGateSequence):
+            return euler_one_qubit_decomposer.compute_error_one_qubit_sequence(
+                circuit, qubit, self.error_map
+            )
+        else:
+            circuit_list = [(x.op.name, []) for x in circuit]
+            return euler_one_qubit_decomposer.compute_error_list(
+                circuit_list, 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

qiskit/transpiler/passes/optimization/optimize_1q_gates.py

@@ -0,0 +1,384 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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 u1, u2, u3 gates by combining them into a single gate."""
+
+from itertools import groupby
+
+import numpy as np
+
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.circuit.library.standard_gates.p import PhaseGate
+from qiskit.circuit.library.standard_gates.u import UGate
+from qiskit.circuit.library.standard_gates.u1 import U1Gate
+from qiskit.circuit.library.standard_gates.u2 import U2Gate
+from qiskit.circuit.library.standard_gates.u3 import U3Gate
+from qiskit.circuit import ParameterExpression
+from qiskit.circuit.gate import Gate
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.quantum_info.synthesis import Quaternion
+from qiskit._accelerate.optimize_1q_gates import compose_u3_rust
+
+_CHOP_THRESHOLD = 1e-15
+
+
+class Optimize1qGates(TransformationPass):
+    """Optimize chains of single-qubit u1, u2, u3 gates by combining them into a single gate."""
+
+    def __init__(self, basis=None, eps=1e-15, target=None):
+        """Optimize1qGates 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 set `{'u1','u2','u3', 'u', 'p'}`.
+            eps (float): EPS to check against
+            target (Target): The :class:`~.Target` representing the target backend, if both
+                ``basis`` and ``target`` are specified then this argument will take
+                precedence and ``basis`` will be ignored.
+        """
+        super().__init__()
+        self.basis = set(basis) if basis else {"u1", "u2", "u3"}
+        self.eps = eps
+        self.target = target
+
+    def run(self, dag):
+        """Run the Optimize1qGates pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+
+        Raises:
+            TranspilerError: if ``YZY`` and ``ZYZ`` angles do not give same rotation matrix.
+        """
+        use_u = "u" in self.basis
+        use_p = "p" in self.basis
+        runs = dag.collect_runs(["u1", "u2", "u3", "u", "p"])
+        runs = _split_runs_on_parameters(runs)
+        for run in runs:
+            run_qubits = None
+            if self.target is not None:
+                run_qubits = tuple(dag.find_bit(x).index for x in run[0].qargs)
+
+                if self.target.instruction_supported("p", run_qubits):
+                    right_name = "p"
+                else:
+                    right_name = "u1"
+            else:
+                if use_p:
+                    right_name = "p"
+                else:
+                    right_name = "u1"
+            right_parameters = (0, 0, 0)  # (theta, phi, lambda)
+            right_global_phase = 0
+            for current_node in run:
+                left_name = current_node.name
+                if (
+                    getattr(current_node.op, "condition", None) is not None
+                    or len(current_node.qargs) != 1
+                    or left_name not in ["p", "u1", "u2", "u3", "u", "id"]
+                ):
+                    raise TranspilerError("internal error")
+                if left_name in ("u1", "p"):
+                    left_parameters = (0, 0, current_node.op.params[0])
+                elif left_name == "u2":
+                    left_parameters = (
+                        np.pi / 2,
+                        current_node.op.params[0],
+                        current_node.op.params[1],
+                    )
+                elif left_name in ("u3", "u"):
+                    left_parameters = tuple(current_node.op.params)
+                else:
+                    if use_p:
+                        left_name = "p"
+                    else:
+                        left_name = "u1"  # replace id with u1
+                    left_parameters = (0, 0, 0)
+                if (
+                    current_node.op.definition is not None
+                    and current_node.op.definition.global_phase
+                ):
+                    right_global_phase += current_node.op.definition.global_phase
+
+                # If there are any sympy objects coming from the gate convert
+                # to numpy.
+                try:
+                    left_parameters = tuple(float(x) for x in left_parameters)
+                except TypeError:
+                    # If left_parameters contained any unbound Parameters
+                    pass
+
+                # Compose gates
+                name_tuple = (left_name, right_name)
+                if name_tuple in (("u1", "u1"), ("p", "p")):
+                    # u1(lambda1) * u1(lambda2) = u1(lambda1 + lambda2)
+                    right_parameters = (0, 0, right_parameters[2] + left_parameters[2])
+                elif name_tuple in (("u1", "u2"), ("p", "u2")):
+                    # u1(lambda1) * u2(phi2, lambda2) = u2(phi2 + lambda1, lambda2)
+                    right_parameters = (
+                        np.pi / 2,
+                        right_parameters[1] + left_parameters[2],
+                        right_parameters[2],
+                    )
+                elif name_tuple in (("u2", "u1"), ("u2", "p")):
+                    # u2(phi1, lambda1) * u1(lambda2) = u2(phi1, lambda1 + lambda2)
+                    right_name = "u2"
+                    right_parameters = (
+                        np.pi / 2,
+                        left_parameters[1],
+                        right_parameters[2] + left_parameters[2],
+                    )
+                elif name_tuple in (("u1", "u3"), ("u1", "u"), ("p", "u3"), ("p", "u")):
+                    # u1(lambda1) * u3(theta2, phi2, lambda2) =
+                    #     u3(theta2, phi2 + lambda1, lambda2)
+                    right_parameters = (
+                        right_parameters[0],
+                        right_parameters[1] + left_parameters[2],
+                        right_parameters[2],
+                    )
+                elif name_tuple in (("u3", "u1"), ("u", "u1"), ("u3", "p"), ("u", "p")):
+                    # u3(theta1, phi1, lambda1) * u1(lambda2) =
+                    #     u3(theta1, phi1, lambda1 + lambda2)
+                    if use_u:
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+                    right_parameters = (
+                        left_parameters[0],
+                        left_parameters[1],
+                        right_parameters[2] + left_parameters[2],
+                    )
+                elif name_tuple == ("u2", "u2"):
+                    # Using Ry(pi/2).Rz(2*lambda).Ry(pi/2) =
+                    #    Rz(pi/2).Ry(pi-2*lambda).Rz(pi/2),
+                    # u2(phi1, lambda1) * u2(phi2, lambda2) =
+                    #    u3(pi - lambda1 - phi2, phi1 + pi/2, lambda2 + pi/2)
+                    if use_u:
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+                    right_parameters = (
+                        np.pi - left_parameters[2] - right_parameters[1],
+                        left_parameters[1] + np.pi / 2,
+                        right_parameters[2] + np.pi / 2,
+                    )
+                elif name_tuple[1] == "nop":
+                    right_name = left_name
+                    right_parameters = left_parameters
+                else:
+                    # For composing u3's or u2's with u3's, use
+                    # u2(phi, lambda) = u3(pi/2, phi, lambda)
+                    # together with the qiskit.mapper.compose_u3 method.
+                    if use_u:
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+                    # Evaluate the symbolic expressions for efficiency
+                    right_parameters = Optimize1qGates.compose_u3(
+                        left_parameters[0],
+                        left_parameters[1],
+                        left_parameters[2],
+                        right_parameters[0],
+                        right_parameters[1],
+                        right_parameters[2],
+                    )
+                    # Why evalf()? This program:
+                    #   OPENQASM 2.0;
+                    #   include "qelib1.inc";
+                    #   qreg q[2];
+                    #   creg c[2];
+                    #   u3(0.518016983430947*pi,1.37051598592907*pi,1.36816383603222*pi) q[0];
+                    #   u3(1.69867232277986*pi,0.371448347747471*pi,0.461117217930936*pi) q[0];
+                    #   u3(0.294319836336836*pi,0.450325871124225*pi,1.46804720442555*pi) q[0];
+                    #   measure q -> c;
+                    # took >630 seconds (did not complete) to optimize without
+                    # calling evalf() at all, 19 seconds to optimize calling
+                    # evalf() AFTER compose_u3, and 1 second to optimize
+                    # calling evalf() BEFORE compose_u3.
+                # 1. Here down, when we simplify, we add f(theta) to lambda to
+                # correct the global phase when f(theta) is 2*pi. This isn't
+                # necessary but the other steps preserve the global phase, so
+                # we continue in that manner.
+                # 2. The final step will remove Z rotations by 2*pi.
+                # 3. Note that is_zero is true only if the expression is exactly
+                # zero. If the input expressions have already been evaluated
+                # then these final simplifications will not occur.
+                # TODO After we refactor, we should have separate passes for
+                # exact and approximate rewriting.
+
+                # Y rotation is 0 mod 2*pi, so the gate is a u1
+                if (
+                    not isinstance(right_parameters[0], ParameterExpression)
+                    and abs(np.mod(right_parameters[0], (2 * np.pi))) < self.eps
+                    and right_name != "u1"
+                    and right_name != "p"
+                ):
+                    if use_p:
+                        right_name = "p"
+                    else:
+                        right_name = "u1"
+                    right_parameters = (
+                        0,
+                        0,
+                        right_parameters[1] + right_parameters[2] + right_parameters[0],
+                    )
+                # Y rotation is pi/2 or -pi/2 mod 2*pi, so the gate is a u2
+                if right_name in ("u3", "u"):
+                    if not isinstance(right_parameters[0], ParameterExpression):
+                        # theta = pi/2 + 2*k*pi
+                        right_angle = right_parameters[0] - np.pi / 2
+                        if abs(right_angle) < self.eps:
+                            right_angle = 0
+                        if abs(np.mod((right_angle), 2 * np.pi)) < self.eps:
+                            right_name = "u2"
+                            right_parameters = (
+                                np.pi / 2,
+                                right_parameters[1],
+                                right_parameters[2] + (right_parameters[0] - np.pi / 2),
+                            )
+                        # theta = -pi/2 + 2*k*pi
+                        right_angle = right_parameters[0] + np.pi / 2
+                        if abs(right_angle) < self.eps:
+                            right_angle = 0
+                        if abs(np.mod(right_angle, 2 * np.pi)) < self.eps:
+                            right_name = "u2"
+                            right_parameters = (
+                                np.pi / 2,
+                                right_parameters[1] + np.pi,
+                                right_parameters[2] - np.pi + (right_parameters[0] + np.pi / 2),
+                            )
+
+                # u1 and lambda is 0 mod 2*pi so gate is nop (up to a global phase)
+                if (
+                    not isinstance(right_parameters[2], ParameterExpression)
+                    and right_name in ("u1", "p")
+                    and abs(np.mod(right_parameters[2], 2 * np.pi)) < self.eps
+                ):
+                    right_name = "nop"
+
+            if self.target is not None:
+                if right_name == "u2" and not self.target.instruction_supported("u2", run_qubits):
+                    if self.target.instruction_supported("u", run_qubits):
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+                if right_name in ("u1", "p") and not self.target.instruction_supported(
+                    right_name, run_qubits
+                ):
+                    if self.target.instruction_supported("u", run_qubits):
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+            else:
+                if right_name == "u2" and "u2" not in self.basis:
+                    if use_u:
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+                if right_name in ("u1", "p") and right_name not in self.basis:
+                    if use_u:
+                        right_name = "u"
+                    else:
+                        right_name = "u3"
+
+            new_op = Gate(name="", num_qubits=1, params=[])
+            if right_name == "u1":
+                new_op = U1Gate(right_parameters[2])
+            if right_name == "p":
+                new_op = PhaseGate(right_parameters[2])
+            if right_name == "u2":
+                new_op = U2Gate(right_parameters[1], right_parameters[2])
+            if right_name == "u":
+                if "u" in self.basis:
+                    new_op = UGate(*right_parameters)
+            if right_name == "u3":
+                if "u3" in self.basis:
+                    new_op = U3Gate(*right_parameters)
+                else:
+                    raise TranspilerError("It was not possible to use the basis %s" % self.basis)
+
+            dag.global_phase += right_global_phase
+
+            if right_name != "nop":
+                dag.substitute_node(run[0], new_op, inplace=True)
+
+            # Delete the other nodes in the run
+            for current_node in run[1:]:
+                dag.remove_op_node(current_node)
+            if right_name == "nop":
+                dag.remove_op_node(run[0])
+
+        return dag
+
+    @staticmethod
+    def compose_u3(theta1, phi1, lambda1, theta2, phi2, lambda2):
+        """Return a triple theta, phi, lambda for the product.
+
+        u3(theta, phi, lambda)
+           = u3(theta1, phi1, lambda1).u3(theta2, phi2, lambda2)
+           = Rz(phi1).Ry(theta1).Rz(lambda1+phi2).Ry(theta2).Rz(lambda2)
+           = Rz(phi1).Rz(phi').Ry(theta').Rz(lambda').Rz(lambda2)
+           = u3(theta', phi1 + phi', lambda2 + lambda')
+
+        Return theta, phi, lambda.
+        """
+        (theta, phi, lamb) = compose_u3_rust(theta1, phi1, lambda1, theta2, phi2, lambda2)
+        return (theta, phi, lamb)
+
+    @staticmethod
+    def yzy_to_zyz(xi, theta1, theta2, eps=1e-9):  # pylint: disable=invalid-name
+        """Express a Y.Z.Y single qubit gate as a Z.Y.Z gate.
+
+        Solve the equation
+
+        .. math::
+
+        Ry(theta1).Rz(xi).Ry(theta2) = Rz(phi).Ry(theta).Rz(lambda)
+
+        for theta, phi, and lambda.
+
+        Return a solution theta, phi, and lambda.
+        """
+        quaternion_yzy = Quaternion.from_euler([theta1, xi, theta2], "yzy")
+        euler = quaternion_yzy.to_zyz()
+        quaternion_zyz = Quaternion.from_euler(euler, "zyz")
+        # output order different than rotation order
+        out_angles = (euler[1], euler[0], euler[2])
+        abs_inner = abs(quaternion_zyz.data.dot(quaternion_yzy.data))
+        if not np.allclose(abs_inner, 1, eps):
+            raise TranspilerError("YZY and ZYZ angles do not give same rotation matrix.")
+        out_angles = tuple(0 if np.abs(angle) < _CHOP_THRESHOLD else angle for angle in out_angles)
+        return out_angles
+
+
+def _split_runs_on_parameters(runs):
+    """Finds runs containing parameterized gates and splits them into sequential
+    runs excluding the parameterized gates.
+    """
+
+    out = []
+    for run in runs:
+        # We exclude only u3 and u gate because for u1 and u2 we can really straightforward
+        # merge two gate with parameters.
+        # It would be great to combine all gate with parameters but this requires
+        # support parameters in qiskit.quantum_info.synthesis.Quaternion.
+        groups = groupby(run, lambda x: x.op.is_parameterized() and x.op.name in ("u3", "u"))
+
+        for group_is_parameterized, gates in groups:
+            if not group_is_parameterized:
+                out.append(list(gates))
+
+    return out