Skip running decomposer if we're going to consolidate

The running of the 2q decomposer to compute the weyl coordinates and the
number of 2q gates is the most expensive part of the heuristic used to
determine whether we should consolidate or not. It's also the last bit
of data collection we run prior to making the determination of whether
to consolidate or not. This commit introduces a small optimization where
we only run the 2q decomposer when we know the other checks to determine
whether we should consolidate or not are false. If any of them are true
then we can skip the expensive computation and just consolidate the
block.

Author: mtreinish

crates/transpiler/src/passes/consolidate_blocks.rs

@@ -413,31 +413,41 @@ fn py_run_consolidate_blocks(
             ];
             let matrix = blocks_to_matrix(dag, &block, block_index_map).ok();
             if let Some(matrix) = matrix {
-                let num_basis_gates = if let Some(ref decomposer) = decomposer {
-                    match decomposer {
-                        DecomposerType::TwoQubitBasis(decomp) => decomp.num_basis_gates_inner(
-                            nalgebra_array_view::<Complex64, U4, U4>(matrix.as_view()),
-                        )?,
-                        DecomposerType::TwoQubitControlledU(decomp) => decomp
-                            .num_basis_gates_inner(nalgebra_array_view::<Complex64, U4, U4>(
-                                matrix.as_view(),
-                            ))?,
-                    }
-                } else {
-                    // If we don't have a decomposer set we have force_consolidate set.
-                    // This value doesn't matter since we're always going to consolidate,
-                    // but usize::MAX is selected as a safeguard against a logic bug since
-                    // with that value we'll only consolidate if force_consolidate is true
-                    // in the absence of a decomposer.
-                    usize::MAX
-                };
-
-                if force_consolidate
-                    || num_basis_gates < basis_count
+                let consolidate = if force_consolidate
                     || block.len() > MAX_2Q_DEPTH
                     || (basis_gates.is_some() && outside_basis)
                     || (target.is_some() && outside_basis)
                 {
+                    true
+                } else {
+                    let num_basis_gates = if let Some(ref decomposer) = decomposer {
+                        match decomposer {
+                            DecomposerType::TwoQubitBasis(decomp) => {
+                                decomp.num_basis_gates_inner(nalgebra_array_view::<
+                                    Complex64,
+                                    U4,
+                                    U4,
+                                >(
+                                    matrix.as_view()
+                                ))?
+                            }
+                            DecomposerType::TwoQubitControlledU(decomp) => decomp
+                                .num_basis_gates_inner(nalgebra_array_view::<Complex64, U4, U4>(
+                                    matrix.as_view(),
+                                ))?,
+                        }
+                    } else {
+                        // If we don't have a decomposer set we have force_consolidate set.
+                        // This value doesn't matter since we're always going to consolidate,
+                        // but usize::MAX is selected as a safeguard against a logic bug since
+                        // with that value we'll only consolidate if force_consolidate is true
+                        // in the absence of a decomposer.
+                        usize::MAX
+                    };
+                    num_basis_gates < basis_count
+                };
+
+                if consolidate {
                     if approx::abs_diff_eq!(IDENTITY_2Q, matrix) {
                         for node in block {
                             dag.remove_op_node(node);