Use the peephole pass heuristic for best synthesis selection

Previously there was a mismatch between the scoring of synthesis
results and the peephole pass's comparison with the original block. The
pass is documented as using the tuple (num_2q_gates, error, num_gates)
and picking the min of all the choices. But, when we called the unitary
synthesis function that selects the best synthesis outcome it was
maximizing the estimated fidelity but not considering the gate counts
like the pass is documented as doing. This corrects this mismatch by
updating the function doing the synthesis to be generic on score type
and taking a scorer callback. This lets the peephole pass control the
heuristic used for selecting the best score.

Author: mtreinish

crates/transpiler/src/passes/two_qubit_peephole.rs

@@ -34,6 +34,7 @@ use qiskit_circuit::operations::{
 use qiskit_circuit::packed_instruction::{PackedInstruction, PackedOperation};
 use qiskit_circuit::{BlocksMode, Qubit, VarsMode};
 
+use super::unitary_synthesis::Direction2q;
 use crate::passes::unitary_synthesis::{
     Approximation, QpuConstraint, TwoQSynthesisResult, fidelity_2q_sequence, synthesize_2q_matrix,
 };
@@ -42,10 +43,11 @@ use crate::target::Target;
 use qiskit_circuit::PhysicalQubit;
 use qiskit_synthesis::linalg::nalgebra_array_view;
 use qiskit_synthesis::matrix::two_qubit::blocks_to_matrix;
+use qiskit_synthesis::two_qubit_decompose::TwoQubitGateSequence;
 use qiskit_util::getenv_use_multiple_threads;
 use thread_local::ThreadLocal;
 
-type MappingIterItem = Option<(TwoQSynthesisResult, [Qubit; 2])>;
+type MappingIterItem = Option<(TwoQSynthesisResult<f64>, [Qubit; 2])>;
 
 // This is a separate function in case we need to handle any Python synchronization in the future
 // (such as releasing the GIL). For right now this doesn't seem to be necessary, but keeping it
@@ -59,6 +61,24 @@ pub fn py_two_qubit_unitary_peephole_optimize(
     two_qubit_unitary_peephole_optimize(dag, target, approximation_degree)
 }
 
+fn score_sequence(
+    dir: &Direction2q,
+    sequence: &TwoQubitGateSequence,
+    constraint: &QpuConstraint,
+    qargs: [PhysicalQubit; 2],
+) -> (i64, f64, i64) {
+    let fidelity = fidelity_2q_sequence(dir, sequence, constraint, qargs);
+    // Make the gate counts negative because synthesize_2q_matrix picks the largest value
+    // we want to minimize the gate counts.
+    let gate_count = -(sequence.gates.len() as i64);
+    let twoq_gate_count = -(sequence
+        .gates
+        .iter()
+        .filter(|x| x.0.num_qubits() == 2)
+        .count() as i64);
+    (twoq_gate_count, fidelity, gate_count)
+}
+
 /// This function runs the two qubit unitary peephole optimization pass
 ///
 /// It returns None if there is no modifications/optimiations made to the input dag and the pass
@@ -108,6 +128,7 @@ pub fn two_qubit_unitary_peephole_optimize(
                 q_phys,
                 &mut synthesis_state.borrow_mut(),
                 QpuConstraint::Target(target),
+                score_sequence,
             )?;
             if result.is_none() {
                 return Ok(None);
@@ -152,15 +173,20 @@ pub fn two_qubit_unitary_peephole_optimize(
                 original_total_count,
             );
             let new_2q_count = result
-                .sequence
-                .gates
-                .iter()
-                .filter(|x| x.0.num_qubits() == 2)
-                .count();
+                .score
+                .map(|score| -score.0 as usize)
+                .unwrap_or_else(|| {
+                    result
+                        .sequence
+                        .gates
+                        .iter()
+                        .filter(|x| x.0.num_qubits() == 2)
+                        .count()
+                });
             let new_gate_count = result.sequence.gates.len();
             let new_score = (
                 new_2q_count,
-                1. - result.fidelity.unwrap_or_else(|| {
+                1. - result.score.map(|score| score.1).unwrap_or_else(|| {
                     fidelity_2q_sequence(
                         &result.dir,
                         &result.sequence,
@@ -183,6 +209,11 @@ pub fn two_qubit_unitary_peephole_optimize(
                 node_mapping[node.index()] = run_index;
             }
             substitution_made.store(true, std::sync::atomic::Ordering::Relaxed);
+            let result = TwoQSynthesisResult {
+                sequence: result.sequence,
+                dir: result.dir,
+                score: result.score.map(|score| score.1),
+            };
             Ok(Some((result, q_virt)))
         };
 

crates/transpiler/src/passes/unitary_synthesis/mod.rs

@@ -23,7 +23,9 @@ use numpy::PyReadonlyArray2;
 use pyo3::prelude::*;
 use pyo3::{intern, wrap_pyfunction};
 
-use self::decomposers::{Decomposer2q, DecomposerCache, Direction2q, FlipDirection};
+pub(crate) use self::decomposers::Direction2q;
+
+use self::decomposers::{Decomposer2q, DecomposerCache, FlipDirection};
 use crate::QiskitError;
 use crate::target::Target;
 use qiskit_circuit::bit::QuantumRegister;
@@ -487,10 +489,10 @@ fn synthesize_1q_matrix_onto(
 }
 
 #[derive(Debug)]
-pub struct TwoQSynthesisResult {
+pub struct TwoQSynthesisResult<S> {
     pub sequence: TwoQubitGateSequence,
     pub dir: Direction2q,
-    pub fidelity: Option<f64>,
+    pub score: Option<S>,
 }
 
 /// Estimate the fidelity of a synthesized two qubit unitary synthesis output
@@ -544,12 +546,21 @@ pub(crate) fn fidelity_2q_sequence(
 /// `qargs_phys` - The physical qubits the unitary is being applied to
 /// `state` - The internal state of the pass, this includes the configured synthesizers
 /// `constraint` - The qpu constraints used for the synthesis, typically just a Target
-pub(crate) fn synthesize_2q_matrix(
+/// `fidelity_calculation` - A callable that is called with a two qubit synthesis output sequence and
+///   the context around it. It is expected to return a fidelity score to compare that synthesis output
+///   against other decomposers. The synthesis output with the maximum score is selected and is
+///   what is returned by the `synthesize_2q_matrix`.
+pub(crate) fn synthesize_2q_matrix<F, S>(
     mut unitary: CowArray<Complex64, Ix2>,
     qargs_phys: [PhysicalQubit; 2],
     state: &mut UnitarySynthesisState,
     constraint: QpuConstraint,
-) -> PyResult<Option<TwoQSynthesisResult>> {
+    mut fidelity_calculation: F,
+) -> PyResult<Option<TwoQSynthesisResult<S>>>
+where
+    F: FnMut(&Direction2q, &TwoQubitGateSequence, &QpuConstraint, [PhysicalQubit; 2]) -> S,
+    S: PartialOrd,
+{
     let decomposer_cache = &mut state.cache;
     let config = &state.config;
 
@@ -611,9 +622,9 @@ pub(crate) fn synthesize_2q_matrix(
     for sequence in sequences {
         let sequence = sequence?;
         let prev_fidelity = best_fidelity.unwrap_or_else(|| {
-            fidelity_2q_sequence(&best_pair.0, &best_pair.1, &constraint, qargs_phys)
+            fidelity_calculation(&best_pair.0, &best_pair.1, &constraint, qargs_phys)
         });
-        let this_fidelity = fidelity_2q_sequence(&sequence.0, &sequence.1, &constraint, qargs_phys);
+        let this_fidelity = fidelity_calculation(&sequence.0, &sequence.1, &constraint, qargs_phys);
         if this_fidelity > prev_fidelity {
             best_fidelity = Some(this_fidelity);
             best_pair = sequence;
@@ -624,7 +635,7 @@ pub(crate) fn synthesize_2q_matrix(
     Ok(Some(TwoQSynthesisResult {
         sequence: best_pair.1,
         dir: best_pair.0,
-        fidelity: best_fidelity,
+        score: best_fidelity,
     }))
 }
 
@@ -636,7 +647,9 @@ fn synthesize_2q_matrix_onto(
     state: &mut UnitarySynthesisState,
     constraint: QpuConstraint,
 ) -> PyResult<bool> {
-    let Some(result) = synthesize_2q_matrix(unitary, qargs_phys, state, constraint)? else {
+    let Some(result) =
+        synthesize_2q_matrix(unitary, qargs_phys, state, constraint, fidelity_2q_sequence)?
+    else {
         return Ok(false);
     };
     // ... now apply the best sequence.