Fix C transpiler level 3 optimisation loop (#15967)

* Update transpiler.rs

* Update transpiler.rs

* Update transpiler.rs

* Update transpiler.rs

* Update transpiler.rs

* Create fix-min-point-state-level3.yaml

* Update transpiler.rs

* Update test_transpiler.c

* Update transpiler.rs

* Apply suggestions from code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* Fix rustfmt

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

Author: rajnisht7

crates/transpiler/src/transpiler.rs

@@ -565,14 +565,19 @@ impl MinPointState {
             true
         } else if (new_depth, new_size) > (self.best_depth, self.best_size) {
             self.count += 1;
-            true
+            // Limit to 5 iterations without improvement
+            // and back track to previous best
+            self.count < 5
         } else if (new_depth, new_size) < (self.best_depth, self.best_size) {
             self.count = 1;
             self.best_depth = new_depth;
             self.best_size = new_size;
+            self.best_dag = dag.clone();
             true
         } else {
-            (new_depth, new_size) != (self.best_depth, self.best_size)
+            // When depth and size are unchanged, we reach a fixed point
+            // and can stop the optimization loop
+            false
         }
     }
 }
@@ -847,4 +852,115 @@ mod tests {
             assert!(result.1.output_permutation().is_some());
         }
     }
+
+    #[test]
+    fn test_update_best_dag() {
+        let circuit1 = CircuitData::from_packed_operations(
+            1,
+            1,
+            vec![Ok((
+                StandardGate::H.into(),
+                smallvec![],
+                vec![Qubit(0)],
+                vec![],
+            ))],
+            Param::Float(0.),
+        )
+        .unwrap();
+
+        let dag1 = DAGCircuit::from_circuit_data(&circuit1, false, None, None, None, None).unwrap();
+        let circuit2 = CircuitData::from_packed_operations(1, 1, vec![], Param::Float(0.)).unwrap();
+        let dag2 = DAGCircuit::from_circuit_data(&circuit2, false, None, None, None, None).unwrap();
+
+        let mut state = MinPointState::new(&dag1);
+        assert!(state.update_with(&dag1));
+        assert_eq!(state.count, 0);
+        assert!(state.update_with(&dag2));
+        assert_eq!(state.count, 1);
+        assert_eq!(
+            state.best_dag.depth(false).unwrap(),
+            dag2.depth(false).unwrap()
+        );
+        assert_eq!(
+            state.best_dag.size(false).unwrap(),
+            dag2.size(false).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_backtrack_limit_stops_loop() {
+        let circuit1 = CircuitData::from_packed_operations(1, 1, vec![], Param::Float(0.)).unwrap();
+        let dag1 = DAGCircuit::from_circuit_data(&circuit1, false, None, None, None, None).unwrap();
+        let circuit2 = CircuitData::from_packed_operations(
+            1,
+            1,
+            vec![Ok((
+                StandardGate::H.into(),
+                smallvec![],
+                vec![Qubit(0)],
+                vec![],
+            ))],
+            Param::Float(0.),
+        )
+        .unwrap();
+
+        let dag2 = DAGCircuit::from_circuit_data(&circuit2, false, None, None, None, None).unwrap();
+        let mut state = MinPointState::new(&dag1);
+
+        state.update_with(&dag1);
+        for i in 0..5 {
+            let continue_loop = state.update_with(&dag2);
+            if i < 4 {
+                assert!(continue_loop);
+            } else {
+                assert!(!continue_loop);
+            }
+        }
+    }
+
+    #[test]
+    fn test_backtrack_resets_on_improvement() {
+        let circuit1 = CircuitData::from_packed_operations(
+            1,
+            1,
+            vec![
+                Ok((StandardGate::H.into(), smallvec![], vec![Qubit(0)], vec![])),
+                Ok((StandardGate::H.into(), smallvec![], vec![Qubit(0)], vec![])),
+            ],
+            Param::Float(0.),
+        )
+        .unwrap();
+        let dag_worst =
+            DAGCircuit::from_circuit_data(&circuit1, false, None, None, None, None).unwrap();
+        let circuit2 = CircuitData::from_packed_operations(
+            1,
+            1,
+            vec![Ok((
+                StandardGate::H.into(),
+                smallvec![],
+                vec![Qubit(0)],
+                vec![],
+            ))],
+            Param::Float(0.),
+        )
+        .unwrap();
+        let dag_better =
+            DAGCircuit::from_circuit_data(&circuit2, false, None, None, None, None).unwrap();
+        let circuit3 = CircuitData::from_packed_operations(1, 1, vec![], Param::Float(0.)).unwrap();
+        let dag_best =
+            DAGCircuit::from_circuit_data(&circuit3, false, None, None, None, None).unwrap();
+        let mut state = MinPointState::new(&dag_worst);
+
+        state.update_with(&dag_worst);
+        state.update_with(&dag_better);
+        for _i in 0..3 {
+            state.update_with(&dag_worst);
+        }
+        state.update_with(&dag_best);
+        assert_eq!(state.count, 1);
+        // After updating to the dag_best the state tracked dag should
+        // be empty
+        assert_eq!(state.best_dag.depth(false).unwrap(), 0);
+        assert_eq!(state.best_dag.size(false).unwrap(), 0);
+    }
 }

releasenotes/notes/fix-min-point-state-level3.yaml

@@ -0,0 +1,8 @@
+fixes:
+  - |
+    Fixed an issue with the :c:func:`qk_transpile` and
+    :c:func:`qk_transpile_stage_optimization` C API functions when using
+    ``optimization_level`` 3 in the :c:struct:`QkTranspileOptions`. Previously
+    the internal minimum-point tracking logic was not updating the DAG even
+    after finding a better circuit. This resulted in returning a circuit that
+    had not been correctly optimized depth/size.

test/c/test_transpiler.c

@@ -191,13 +191,13 @@ static int test_transpile_idle_qubits(void) {
             result = EqualityError;
             goto cleanup;
         }
-        if ((opt_level == 1 || opt_level == 3) && num_instructions != 8) {
+        if (opt_level == 1 && num_instructions != 8) {
             printf("opt_level: %d num_instructions: %zu is not the expected value 8\n", opt_level,
                    num_instructions);
             result = EqualityError;
             goto cleanup;
         }
-        if (opt_level == 2 && num_instructions != 7) {
+        if ((opt_level == 2 || opt_level == 3) && num_instructions != 7) {
             printf("opt_level: %d num_instructions: %zu is not the expected value 7\n", opt_level,
                    num_instructions);
             result = EqualityError;