Oxidize the internals of Optimize1qGatesDecomposition

qiskit/transpiler/passes/optimization/optimize_1q_commutation.py

@@ -165,7 +165,9 @@ def _resynthesize(self, run, qubit):
         operator = run[0].op.to_matrix()
         for gate in run[1:]:
             operator = gate.op.to_matrix().dot(operator)
-        return self._optimize1q._resynthesize_run(operator, qubit)
+        return self._optimize1q._gate_sequence_to_dag(
+            self._optimize1q._resynthesize_run(operator, qubit)
+        )
 
     @staticmethod
     def _replace_subdag(dag, old_run, new_dag):

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -13,15 +13,45 @@
 """Optimize chains of single-qubit gates using Euler 1q decomposer"""
 
 import logging
-from functools import partial
-import numpy as np
+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__)
 
+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.
@@ -58,6 +88,23 @@ def __init__(self, basis=None, target=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 in self._target:
+                    if self._target[gate] is not None:
+                        props = self._target[gate].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):
         """
         Resynthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
@@ -81,13 +128,23 @@ def _resynthesize_run(self, matrix, qubit=None):
                 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
 
-        new_circs = [decomposer._decompose(matrix) for decomposer in decomposers]
+    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
 
-        if len(new_circs) == 0:
-            return None
-        else:
-            return min(new_circs, key=partial(_error, target=self._target, qubit=qubit))
+        for gate_name, angles in best_synth_circuit:
+            out_dag.apply_operation_back(NAME_MAP[gate_name](*angles), qubits)
+        return out_dag
 
     def _substitution_checks(self, dag, old_run, new_circ, basis, qubit):
         """
@@ -115,11 +172,8 @@ def _substitution_checks(self, dag, old_run, new_circ, basis, qubit):
         #    then we _try_ to decompose, using the results if we see improvement.
         return (
             uncalibrated_and_not_basis_p
-            or (
-                uncalibrated_p
-                and _error(new_circ, self._target, qubit) < _error(old_run, self._target, qubit)
-            )
-            or np.isclose(_error(new_circ, self._target, qubit), 0)
+            or (uncalibrated_p and self._error(new_circ, qubit) < self._error(old_run, qubit))
+            or math.isclose(self._error(new_circ, qubit)[0], 0)
         )
 
     @control_flow.trivial_recurse
@@ -147,62 +201,42 @@ def run(self, dag):
                 basis = self._target.operation_names_for_qargs((qubit,))
 
             if new_dag is not None and self._substitution_checks(dag, run, new_dag, basis, qubit):
+                new_dag = self._gate_sequence_to_dag(new_dag)
                 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 could also be a list of DAGNodes)
+
+        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 = [
-            one_qubit_decompose.OneQubitEulerDecomposer(basis, use_dag=True)
-            for basis in one_qubit_decompose.ONE_QUBIT_EULER_BASIS_GATES
-        ]
+        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):
-                decomposer = one_qubit_decompose.OneQubitEulerDecomposer(
-                    euler_basis_name, use_dag=True
-                )
-                decomposers.append(decomposer)
+                decomposers.append(euler_basis_name)
+        if "U3" in basis_set and "U321" in basis_set:
+            decomposers.remove("U3")
     return decomposers
-
-
-def _error(circuit, target=None, qubit=None):
-    """
-    Calculate a rough error for a `circuit` that runs on a specific
-    `qubit` of `target` (circuit could also be a list of DAGNodes)
-
-    Use basis errors from target if available, otherwise use length
-    of circuit as a weak proxy for error.
-    """
-    if target is None:
-        if isinstance(circuit, list):
-            return len(circuit)
-        else:
-            return len(circuit._multi_graph) - 2
-    else:
-        if isinstance(circuit, list):
-            gate_fidelities = [
-                1 - getattr(target[node.name].get((qubit,)), "error", 0.0) for node in circuit
-            ]
-        else:
-            gate_fidelities = [
-                1 - getattr(target[inst.op.name].get((qubit,)), "error", 0.0)
-                for inst in circuit.op_nodes()
-            ]
-        gate_error = 1 - np.product(gate_fidelities)
-        if gate_error == 0.0:
-            if isinstance(circuit, list):
-                return -100 + len(circuit)
-            else:
-                return -100 + len(
-                    circuit._multi_graph
-                )  # prefer shorter circuits among those with zero error
-        else:
-            return gate_error

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -706,7 +706,9 @@ def run(self, unitary, **options):
 
         if unitary.shape == (2, 2):
             _decomposer1q = Optimize1qGatesDecomposition(basis_gates, target)
-            return _decomposer1q._resynthesize_run(unitary, qubits[0])  # already in dag format
+            return _decomposer1q._gate_sequence_to_dag(
+                _decomposer1q._resynthesize_run(unitary, qubits[0])
+            )  # already in dag format
         elif unitary.shape == (4, 4):
             # select synthesizers that can lower to the target
             if target is not None:

releasenotes/notes/speedup-one-qubit-optimize-pass-483429af948a415e.yaml

@@ -0,0 +1,10 @@
+---
+features:
+  - |
+    The runtime performance of the :class:`~.Optimize1qGatesDecomposition`
+    transpiler pass hass been significantly improved. This was done by both
+    rewriting all the computation for the pass in Rust and also decreasing
+    the amount of intermediate objects created as part of the pass's
+    execution. This should also correspond to a similar improvement
+    in the runtime performance of :func:`~.transpile` with the
+    ``optimization_level`` keyword argument set to ``1``, ``2``, or ``3``.